# install_dir / "llvm" / "build",
                         install_dir,
                         input_file,
                         output_file,
                         skip_patterns=True,
-                        skip_formats=True
+                        skip_formats=True,
                     )
                     metrics["n_success"] += 1
                 except AssertionError:
                     pass
                     metrics["n_failed"] += 1

                         output_file,
                         skip_patterns=False,
                         skip_formats=not args.formats,
                         ext=predicate,
                         mattr=mattr,
-
                     )
                     if output_file.is_file():
                         metrics["n_success"] += 1
                         if args.formats:
                             file_artifact_fmt_dest = f"llvm/lib/Target/RISCV/seal5/{set_name}/{out_name_fmt}"

 
 logger = logging.getLogger("riscv_gisel_legalizer")
 
 # if (ST.hasVendorXCvsimd()) {
 
+
 def type_helper(ty):
     print("type_helper", ty)
     ty_ = ty.replace("seal5_", "")
     if ty_.startswith("p"):
         sz = ty_[1:]

         n = int(n)
         sz = int(sz)
         return f"const LLT {ty} = LLT::fixed_vector({n}, LLT::scalar({sz}));"
     else:
         raise RuntimeError(f"Unsupported: {ty}")
-
 
 
 def gen_riscv_gisel_legalizer_str(legalizer_settings: RISCVLegalizerSettings):
     print("legalizer_settings", legalizer_settings)
     ops = legalizer_settings.ops

                 if gisel_settings:
                     content = gen_riscv_gisel_legalizer_str(gisel_settings)
                     with open(out_path, "w") as f:
                         f.write(content)
                     riscv_gisel_legalizer_patch = NamedPatch(
-                        "llvm/lib/Target/RISCV/GISel/RISCVLegalizerInfo.cpp", key="riscv_legalizer_info", src_path=out_path
+                        "llvm/lib/Target/RISCV/GISel/RISCVLegalizerInfo.cpp",
+                        key="riscv_legalizer_info",
+                        src_path=out_path,
                     )
                     artifacts[None].append(riscv_gisel_legalizer_patch)
     if args.metrics:
         raise NotImplementedError
         metrics_file = args.metrics

 from seal5.settings import ExtensionsSettings, LLVMVersion
 
 logger = logging.getLogger("riscv_isa_info")
 
 
-MAKO_TEMPLATE = "    {\"${arch}\", RISCVExtensionVersion{${version_major}, ${version_minor}}},"
-MAKO_TEMPLATE_LLVM18 = "    {\"${arch}\", {${version_major}, ${version_minor}}},"
+MAKO_TEMPLATE = '    {"${arch}", RISCVExtensionVersion{${version_major}, ${version_minor}}},'
+MAKO_TEMPLATE_LLVM18 = '    {"${arch}", {${version_major}, ${version_minor}}},'
 
 
 def gen_riscv_isa_info_str(name: str, ext_settings: ExtensionsSettings, llvm_version: LLVMVersion):
     # print("name", name)
     # print("ext_settings", ext_settings)

                 f.write(content)
             if ext_settings.experimental:
                 key = "riscv_isa_info_experimental"
             else:
                 key = "riscv_isa_info"
-            riscv_isa_info_patch = NamedPatch(
-                "llvm/lib/Support/RISCVISAInfo.cpp", key=key, src_path=out_path
-            )
+            riscv_isa_info_patch = NamedPatch("llvm/lib/Support/RISCVISAInfo.cpp", key=key, src_path=out_path)
             artifacts[None].append(riscv_isa_info_patch)
     if args.metrics:
         metrics_file = args.metrics
         with open(metrics_file, "w") as f:
             f.write(",".join(metrics.keys()))

 from lit.llvm import llvm_config
 from lit.llvm.subst import FindTool
 from lit.llvm.subst import ToolSubst
 
 # name: The name of this test suite.
-config.name = 'LLVM'
+config.name = "LLVM"
 
 # testFormat: The test format to use to interpret tests.
 # config.test_format = lit.formats.ShTest(not llvm_config.use_lit_shell)
 config.test_format = lit.formats.ShTest(True)
 
 # # suffixes: A list of file extensions to treat as test files. This is overriden
 # # by individual lit.local.cfg files in the test subdirectories.
-config.suffixes = ['.ll', '.c', '.test', '.txt', '.s', '.mir', '.yaml']
+config.suffixes = [".ll", ".c", ".test", ".txt", ".s", ".mir", ".yaml"]

 @dataclass
 class LLVMSettings(YAMLSettings):
     state: Optional[LLVMState] = None
     configs: Optional[Dict[str, LLVMConfig]] = None
 
+
 @dataclass
 class RISCVLegalizerSetting(YAMLSettings):
     name: Optional[Union[str, List[str]]] = None
     types: Optional[Union[str, List[str]]] = None
     onlyif: Optional[Union[str, List[str]]] = None
 
+
 @dataclass
 class RISCVLegalizerSettings(YAMLSettings):
     ops: Optional[List[RISCVLegalizerSetting]] = None
+
 
 @dataclass
 class RISCVSettings(YAMLSettings):
     xlen: Optional[int] = None
     features: Optional[List[str]] = None

 
 
 @dataclass
 class ToolsSettings(YAMLSettings):
     pattern_gen: Optional[PatternGenSettings] = None
+
 
 @dataclass
 class Seal5Settings(YAMLSettings):
     logging: Optional[LoggingSettings] = None
     filter: Optional[FilterSettings] = None

         "pattern-gen", cwd=dest, print_func=logger.info if verbose else logger.debug, live=True, use_ninja=use_ninja
     )
 
 
 def get_pattern_gen_patches(
-    src: Path, temp_dir: Path, verbose: bool = False,
+    src: Path,
+    temp_dir: Path,
+    verbose: bool = False,
 ):
     # TODO: copy!
     artifacts = []
     directory_artifact = Directory(
         "llvm/tools/pattern-gen",

                 logger.error("Target directory does not exist! Aborting...")
                 sys.exit(1)
             sha, version_info = llvm.clone_llvm_repo(self.directory, clone_url, ref=clone_ref, label=self.name)
         else:
             if force:
-                sha, version_info = llvm.clone_llvm_repo(self.directory, clone_url, ref=clone_ref, refresh=True, label=self.name)
+                sha, version_info = llvm.clone_llvm_repo(
+                    self.directory, clone_url, ref=clone_ref, refresh=True, label=self.name
+                )
         if self.meta_dir.is_dir():
             if force is False and not utils.ask_user(
                 "Overwrite existing .seal5 diretcory?", default=False, interactive=interactive
             ):
                 logger.error(f"Directory {self.meta_dir} already exists! Aborting...")

                             cdsl2llvm_build_dir = str(self.build_dir / config)
                         else:
                             cdsl2llvm_build_dir = str(self.deps_dir / "cdsl2llvm" / "llvm" / "build")
                         cdsl2llvm.convert_ll_to_gmir(
                             # self.deps_dir / "cdsl2llvm" / "llvm" / "build", ll_file, output_file
-                            cdsl2llvm_build_dir, ll_file, output_file
+                            cdsl2llvm_build_dir,
+                            ll_file,
+                            output_file,
                         )
                     except AssertionError:
                         pass
                         # errs.append((insn_name, str(ex)))
         if len(errs) > 0:

         #     patches.extend(self.gen_mc_tests_patches())
 
         # # Codegen Level
         # if "selection_dag_legalizer" not in skip:
         #     patches.extend(self.gen_selection_dag_legalizer_patches())
-        if ("riscv_gisel_legalizer" in only or len(only) == 0) and ("riscv_gisel_legalizer" not in skip or len(skip) == 0):
+        if ("riscv_gisel_legalizer" in only or len(only) == 0) and (
+            "riscv_gisel_legalizer" not in skip or len(skip) == 0
+        ):
             self.gen_riscv_gisel_legalizer_patch(verbose=verbose)
         # if "scalar_costs" not in skip:
         #     patches.extend(self.gen_scalar_costs_patches())
         # if "simd_costs" not in skip:
         #     patches.extend(self.gen_simd_costs_patches())

             size += length
         assert size in [16, 32, 64, 128], f"Invalid size: {size}"
         if drop2 and keep2:
             ret = size not in drop2 and size in keep2
         elif keep2:
-            ret =  size in keep2
+            ret = size in keep2
         elif drop2:
             ret = size not in drop2
         if not ret:
             return False
         if opcode is None:  # not found (not a riscv insn?)