diff --git a/BUILD.bazel b/BUILD.bazel index e71d72af8..4558ba5cc 100644 --- a/BUILD.bazel +++ b/BUILD.bazel @@ -14,8 +14,8 @@ exports_files([ py_library( name = "CompilerGym", data = [ - "//compiler_gym/third_party/cBench:benchmarks_list", - "//compiler_gym/third_party/cBench:crc32", + "//compiler_gym/third_party/cbench:benchmarks_list", + "//compiler_gym/third_party/cbench:crc32", ], deps = [ "//compiler_gym", diff --git a/benchmarks/BUILD b/benchmarks/BUILD index bcd8d8c4a..f57da9c96 100644 --- a/benchmarks/BUILD +++ b/benchmarks/BUILD @@ -10,6 +10,7 @@ py_test( shard_count = 8, deps = [ "//compiler_gym", + "//examples/example_compiler_gym_service", "//tests:test_main", "//tests/pytest_plugins:llvm", ], diff --git a/benchmarks/bench_test.py b/benchmarks/bench_test.py index 076c50f7e..9a5349358 100644 --- a/benchmarks/bench_test.py +++ b/benchmarks/bench_test.py @@ -4,8 +4,7 @@ # LICENSE file in the root directory of this source tree. """Microbenchmarks for CompilerGym environments. -To run these benchmarks within bazel, compile with optimiztions and stream the -test output: +To run these benchmarks an optimized build using bazel: $ bazel test -c opt --test_output=streamed //benchmarks:bench_test @@ -14,84 +13,170 @@ multiple runs using: $ pytest-benchmark compare --group-by=name --sort=fullname \ - /tmp/compiler_gym/pytest_benchmark/*_bench_test.json + /tmp/compiler_gym/pytest_benchmark/*/*_bench_test.json """ -# pylint: disable=redefined-outer-name import gym import pytest +import examples.example_compiler_gym_service as dummy from compiler_gym.envs import CompilerEnv, LlvmEnv, llvm from compiler_gym.service import CompilerGymServiceConnection +from tests.pytest_plugins.llvm import OBSERVATION_SPACE_NAMES, REWARD_SPACE_NAMES from tests.test_main import main -pytest_plugins = ["tests.pytest_plugins.llvm"] -# Redefine this fixture since running all of the benchmarks in cBench would -# take too long, but we do want to use at least one small and one large -# benchmark to see both per-invocation overhead and overhead that is a result -# of the size of the fixture. -# -# adpcm is small and jpeg-d is large. ghostscript is the largest but that -# one takes too long. @pytest.fixture( - params=["cBench-v1/crc32", "cBench-v1/jpeg-d"], - ids=["fast_benchmark", "slow_benchmark"], + params=["llvm-v0", "example-cc-v0", "example-py-v0"], + ids=["llvm", "dummy-cc", "dummy-py"], ) -def benchmark_name(request) -> str: +def env_id(request) -> str: yield request.param -@pytest.fixture(params=["cBench-v1/crc32"], ids=["fast_benchmark"]) -def fast_benchmark_name(request) -> str: - yield request.param - - -@pytest.fixture(params=["-globaldce", "-gvn"], ids=["fast_action", "slow_action"]) -def action_name(request) -> str: +@pytest.fixture( + params=["llvm-v0", "example-cc-v0", "example-py-v0"], + ids=["llvm", "dummy-cc", "dummy-py"], +) +def env(request) -> CompilerEnv: yield request.param -def test_make_local(benchmark): - benchmark(lambda: gym.make("llvm-v0").close()) - - -def test_make_service(benchmark): - service = CompilerGymServiceConnection(llvm.LLVM_SERVICE_BINARY) +@pytest.mark.parametrize( + "env_id", + ["llvm-v0", "example-cc-v0", "example-py-v0"], + ids=["llvm", "dummy-cc", "dummy-py"], +) +def test_make_local(benchmark, env_id): + benchmark(lambda: gym.make(env_id).close()) + + +@pytest.mark.parametrize( + "args", + [ + (llvm.LLVM_SERVICE_BINARY, LlvmEnv), + (dummy.EXAMPLE_CC_SERVICE_BINARY, CompilerEnv), + (dummy.EXAMPLE_PY_SERVICE_BINARY, CompilerEnv), + ], + ids=["llvm", "dummy-cc", "dummy-py"], +) +def test_make_service(benchmark, args): + service_binary, env_class = args + service = CompilerGymServiceConnection(service_binary) try: - benchmark(lambda: LlvmEnv(service=service.connection.url).close()) + benchmark(lambda: env_class(service=service.connection.url).close()) finally: service.close() -def test_reset(benchmark, env: CompilerEnv, benchmark_name): - env.observation_space = "Autophase" - benchmark(env.reset, benchmark_name) - - -def test_step(benchmark, env: CompilerEnv, benchmark_name, action_name): - env.observation_space = "Autophase" - env.reward_space = "IrInstructionCount" - - env.reset(benchmark_name) - action = env.action_space.flags.index(action_name) - benchmark(env.step, action) - - -def test_observation( - benchmark, env: CompilerEnv, fast_benchmark_name, observation_space -): - env.reset(fast_benchmark_name) - benchmark(lambda: env.observation[observation_space]) +@pytest.mark.parametrize( + "make_env", + [ + lambda: gym.make("llvm-autophase-ic-v0", benchmark="cbench-v1/crc32"), + lambda: gym.make("llvm-autophase-ic-v0", benchmark="cbench-v1/jpeg-d"), + lambda: gym.make("example-cc-v0"), + lambda: gym.make("example-py-v0"), + ], + ids=["llvm;fast-benchmark", "llvm;slow-benchmark", "dummy-cc", "dummy-py"], +) +def test_reset(benchmark, make_env: CompilerEnv): + with make_env() as env: + benchmark(env.reset) + + +@pytest.mark.parametrize( + "args", + [ + ( + lambda: gym.make("llvm-autophase-ic-v0", benchmark="cbench-v1/crc32"), + "-globaldce", + ), + (lambda: gym.make("llvm-autophase-ic-v0", benchmark="cbench-v1/crc32"), "-gvn"), + ( + lambda: gym.make("llvm-autophase-ic-v0", benchmark="cbench-v1/jpeg-d"), + "-globaldce", + ), + ( + lambda: gym.make("llvm-autophase-ic-v0", benchmark="cbench-v1/jpeg-d"), + "-gvn", + ), + (lambda: gym.make("example-cc-v0"), "a"), + (lambda: gym.make("example-py-v0"), "a"), + ], + ids=[ + "llvm;fast-benchmark;fast-action", + "llvm;fast-benchmark;slow-action", + "llvm;slow-benchmark;fast-action", + "llvm;slow-benchmark;slow-action", + "dummy-cc", + "dummy-py", + ], +) +def test_step(benchmark, args): + make_env, action_name = args + with make_env() as env: + env.reset() + action = env.action_space[action_name] + benchmark(env.step, action) + + +_args = dict( + { + f"llvm;{obs}": (lambda: gym.make("llvm-v0", benchmark="cbench-v1/qsort"), obs) + for obs in OBSERVATION_SPACE_NAMES + }, + **{ + "dummy-cc": (lambda: gym.make("example-cc-v0"), "ir"), + "dummy-py": (lambda: gym.make("example-py-v0"), "features"), + }, +) -def test_reward(benchmark, env: CompilerEnv, benchmark_name, reward_space): - env.reset(benchmark_name) - benchmark(lambda: env.reward[reward_space]) +@pytest.mark.parametrize("args", _args.values(), ids=_args.keys()) +def test_observation(benchmark, args): + make_env, observation_space = args + with make_env() as env: + env.reset() + benchmark(lambda: env.observation[observation_space]) + + +_args = dict( + { + f"llvm;{reward}": ( + lambda: gym.make("llvm-v0", benchmark="cbench-v1/qsort"), + reward, + ) + for reward in REWARD_SPACE_NAMES + }, + **{ + "dummy-cc": (lambda: gym.make("example-cc-v0"), "runtime"), + "dummy-py": (lambda: gym.make("example-py-v0"), "runtime"), + }, +) -def test_fork(benchmark, env: CompilerEnv, benchmark_name): - env.reset(benchmark_name) - benchmark(lambda: env.fork().close()) +@pytest.mark.parametrize("args", _args.values(), ids=_args.keys()) +def test_reward(benchmark, args): + make_env, reward_space = args + with make_env() as env: + env.reset() + benchmark(lambda: env.reward[reward_space]) + + +@pytest.mark.parametrize( + "make_env", + [ + lambda: gym.make("llvm-autophase-ic-v0", benchmark="cbench-v1/crc32"), + lambda: gym.make("llvm-autophase-ic-v0", benchmark="cbench-v1/jpeg-d"), + # TODO: Example service does not yet support fork() operator. + # lambda: gym.make("example-cc-v0"), + # lambda: gym.make("example-py-v0"), + ], + ids=["llvm;fast-benchmark", "llvm;slow-benchmark"], +) +def test_fork(benchmark, make_env): + with make_env() as env: + env.reset() + benchmark(lambda: env.fork().close()) if __name__ == "__main__": @@ -99,6 +184,7 @@ def test_fork(benchmark, env: CompilerEnv, benchmark_name): extra_pytest_args=[ "--benchmark-storage=/tmp/compiler_gym/pytest_benchmark", "--benchmark-save=bench_test", + "--benchmark-sort=name", "-x", ], debug_level=0, diff --git a/compiler_gym/bin/BUILD b/compiler_gym/bin/BUILD index a3494ec17..92cfc45a8 100644 --- a/compiler_gym/bin/BUILD +++ b/compiler_gym/bin/BUILD @@ -22,6 +22,7 @@ py_binary( srcs = ["datasets.py"], visibility = ["//visibility:public"], deps = [ + ":service", "//compiler_gym/datasets", "//compiler_gym/envs", "//compiler_gym/util", @@ -81,6 +82,7 @@ py_binary( srcs = ["service.py"], visibility = ["//visibility:public"], deps = [ + "//compiler_gym/datasets", "//compiler_gym/envs", "//compiler_gym/spaces", "//compiler_gym/util", diff --git a/compiler_gym/bin/datasets.py b/compiler_gym/bin/datasets.py index 773d6c584..cde0dffce 100644 --- a/compiler_gym/bin/datasets.py +++ b/compiler_gym/bin/datasets.py @@ -99,23 +99,14 @@ A :code:`--delete_all` flag can be used to delete all of the locally installed datasets. """ -import os import sys -from pathlib import Path -from typing import Tuple -import humanize from absl import app, flags +from deprecated.sphinx import deprecated -from compiler_gym.datasets.dataset import ( - LegacyDataset, - activate, - deactivate, - delete, - require, -) +from compiler_gym.bin.service import summarize_datasets +from compiler_gym.datasets.dataset import activate, deactivate, delete from compiler_gym.util.flags.env_from_flags import env_from_flags -from compiler_gym.util.tabulate import tabulate flags.DEFINE_list( "download", @@ -143,31 +134,15 @@ FLAGS = flags.FLAGS -def get_count_and_size_of_directory_contents(root: Path) -> Tuple[int, int]: - """Return the number of files and combined size of a directory.""" - count, size = 0, 0 - for root, _, files in os.walk(str(root)): - count += len(files) - size += sum(os.path.getsize(f"{root}/{file}") for file in files) - return count, size - - -def enumerate_directory(name: str, path: Path): - rows = [] - for path in path.iterdir(): - if not path.is_file() or not path.name.endswith(".json"): - continue - dataset = LegacyDataset.from_json_file(path) - rows.append( - (dataset.name, dataset.license, dataset.file_count, dataset.size_bytes) - ) - rows.append(("Total", "", sum(r[2] for r in rows), sum(r[3] for r in rows))) - return tabulate( - [(n, l, humanize.intcomma(f), humanize.naturalsize(s)) for n, l, f, s in rows], - headers=(name, "License", "#. Benchmarks", "Size on disk"), - ) - - +@deprecated( + version="0.1.8", + reason=( + "Command-line management of datasets is deprecated. Please use " + ":mod:`compiler_gym.bin.service` to print a tabular overview of the " + "available datasets. For management of datasets, use the " + ":class:`env.datasets ` property." + ), +) def main(argv): """Main entry point.""" if len(argv) != 1: @@ -175,28 +150,20 @@ def main(argv): env = env_from_flags() try: - if not env.datasets_site_path: - raise app.UsageError("Environment has no benchmarks site path") - - env.datasets_site_path.mkdir(parents=True, exist_ok=True) - env.inactive_datasets_site_path.mkdir(parents=True, exist_ok=True) - invalidated_manifest = False for name_or_url in FLAGS.download: - require(env, name_or_url) + env.datasets.install(name_or_url) if FLAGS.download_all: - for dataset in env.available_datasets: - require(env, dataset) + for dataset in env.datasets: + dataset.install() for name in FLAGS.activate: activate(env, name) invalidated_manifest = True if FLAGS.activate_all: - for path in env.inactive_datasets_site_path.iterdir(): - activate(env, path.name) invalidated_manifest = True for name in FLAGS.deactivate: @@ -204,8 +171,6 @@ def main(argv): invalidated_manifest = True if FLAGS.deactivate_all: - for path in env.datasets_site_path.iterdir(): - deactivate(env, path.name) invalidated_manifest = True for name in FLAGS.delete: @@ -214,41 +179,8 @@ def main(argv): if invalidated_manifest: env.make_manifest_file() - print(f"{env.spec.id} benchmarks site dir: {env.datasets_site_path}") - print() - print( - enumerate_directory("Active Datasets", env.datasets_site_path), - ) - print( - "These benchmarks are ready for use. Deactivate them using `--deactivate=`." - ) - print() - print(enumerate_directory("Inactive Datasets", env.inactive_datasets_site_path)) - print("These benchmarks may be activated using `--activate=`.") - print() - print( - tabulate( - sorted( - [ - ( - d.name, - d.license, - humanize.intcomma(d.file_count), - humanize.naturalsize(d.size_bytes), - ) - for d in env.available_datasets.values() - ] - ), - headers=( - "Downloadable Dataset", - "License", - "#. Benchmarks", - "Size on disk", - ), - ) - ) print( - "These benchmarks may be installed using `--download= --activate=`." + summarize_datasets(env.datasets), ) finally: env.close() diff --git a/compiler_gym/bin/manual_env.py b/compiler_gym/bin/manual_env.py index 9eef94cc8..45df0b0a1 100644 --- a/compiler_gym/bin/manual_env.py +++ b/compiler_gym/bin/manual_env.py @@ -224,6 +224,7 @@ import random import readline import sys +from itertools import islice from absl import app, flags @@ -284,10 +285,12 @@ def __init__(self, env: CompilerEnv): self.env = env - self.init_benchmarks() - # Get the benchmarks - self.benchmarks = sorted(self.env.benchmarks) + self.benchmarks = [] + for dataset in self.env.datasets: + self.benchmarks += islice(dataset.benchmark_uris(), 50) + self.benchmarks.sort() + # Strip default benchmark:// protocol. for i, benchmark in enumerate(self.benchmarks): if benchmark.startswith("benchmark://"): @@ -324,24 +327,12 @@ def postloop(self): self.env.close() self.env = None - def init_benchmarks(self): - """Initialise the set of benchmarks""" - # Get the benchmarks - self.benchmarks = sorted(self.env.benchmarks) - # Strip default benchmark:// protocol. - for i, benchmark in enumerate(self.benchmarks): - if benchmark.startswith("benchmark://"): - self.benchmarks[i] = benchmark[len("benchmark://") :] - def set_prompt(self): """Set the prompt - shows the benchmark name""" - if self.env.benchmark: - bname = self.env.benchmark - if bname.startswith("benchmark://"): - bname = bname[len("benchmark://") :] - else: - bname = "NO-BENCHMARK" - prompt = f"compilergym:{bname}>" + benchmark_name = self.env.benchmark.uri + if benchmark_name.startswith("benchmark://"): + benchmark_name = benchmark_name[len("benchmark://") :] + prompt = f"compiler_gym:{benchmark_name}>" self.prompt = f"\n{emph(prompt)} " def simple_complete(self, text, options): @@ -352,38 +343,16 @@ def simple_complete(self, text, options): return options def get_datasets(self): - """Get the list of available datasets""" - return sorted([k for k in self.env.available_datasets]) + """Get the list of datasets""" + return sorted([k.name for k in self.env.datasets.datasets()]) def do_list_datasets(self, arg): - """List all of the available datasets""" + """List all of the datasets""" print(", ".join(self.get_datasets())) - def complete_require_dataset(self, text, line, begidx, endidx): - """Complete the require_benchmark argument""" - return self.simple_complete(text, self.get_datasets()) - - def do_require_dataset(self, arg): - """Require dataset - The argument is the name of the dataset to require. - """ - if self.get_datasets().count(arg): - with Timer(f"Downloaded dataset {arg}"): - self.env.require_dataset(arg) - self.init_benchmarks() - else: - print("Unknown dataset, '" + arg + "'") - print("Available datasets are listed with command, list_available_datasets") - def do_list_benchmarks(self, arg): - """List all of the available benchmarks""" - if not self.benchmarks: - doc_root_url = "https://facebookresearch.github.io/CompilerGym/" - install_url = doc_root_url + "getting_started.html#installing-benchmarks" - print("No benchmarks available. See " + install_url) - print("Datasets can be installed with command, require_dataset") - else: - print(", ".join(self.benchmarks)) + """List the benchmarks""" + print(", ".join(self.benchmarks)) def complete_set_benchmark(self, text, line, begidx, endidx): """Complete the set_benchmark argument""" @@ -398,15 +367,16 @@ def do_set_benchmark(self, arg): Use '-' for a random benchmark. """ if arg == "-": - arg = random.choice(self.benchmarks) + arg = self.env.datasets.benchmark().uri print(f"set_benchmark {arg}") - if self.benchmarks.count(arg): + try: + benchmark = self.env.datasets.benchmark(arg) self.stack.clear() # Set the current benchmark with Timer() as timer: - observation = self.env.reset(benchmark=arg) + observation = self.env.reset(benchmark=benchmark) print(f"Reset {self.env.benchmark} environment in {timer}") if self.env.observation_space and observation is not None: @@ -415,10 +385,9 @@ def do_set_benchmark(self, arg): ) self.set_prompt() - - else: + except LookupError: print("Unknown benchmark, '" + arg + "'") - print("Bencmarks are listed with command, list_benchmarks") + print("Benchmarks are listed with command, list_benchmarks") def get_actions(self): """Get the list of actions""" @@ -440,10 +409,6 @@ def do_action(self, arg): Tab completion will be used if available. Use '-' for a random action. """ - if not self.env.benchmark: - print("No benchmark set, please call the set_benchmark command") - return - if self.stack and self.stack[-1].done: print( "No action possible, last action ended by the environment with error:", @@ -546,10 +511,6 @@ def do_hill_climb(self, arg): An argument, if given, should be the number of steps to take. The search will try to improve the default reward. Please call set_default_reward if needed. """ - if not self.env.benchmark: - print("No benchmark set, please call the set_benchmark command") - return - if not self.env.reward_space: print("No default reward set. Call set_default_reward") return @@ -606,10 +567,6 @@ def get_action_rewards(self): def do_try_all_actions(self, args): """Tries all actions from this position and reports the results in sorted order by reward""" - if not self.env.benchmark: - print("No benchmark set, please call the set_benchmark command") - return - if not self.env.reward_space: print("No default reward set. Call set_default_reward") return @@ -635,10 +592,6 @@ def do_greedy(self, arg): An argument, if given, should be the number of steps to take. The search will try to improve the default reward. Please call set_default_reward if needed. """ - if not self.env.benchmark: - print("No benchmark set, please call the set_benchmark command") - return - if not self.env.reward_space: print("No default reward set. Call set_default_reward") return @@ -679,10 +632,6 @@ def do_observation(self, arg): The name should come from the list of observations printed by the command list_observations. Tab completion will be used if available. """ - if not self.env.benchmark: - print("No benchmark set, please call the set_benchmark command") - return - if arg == "" and self.env.observation_space: arg = self.env.observation_space_spec.id @@ -707,10 +656,6 @@ def do_set_default_observation(self, arg): With no argument it will set to None. This command will rerun the actions on the stack. """ - if not self.env.benchmark: - print("No benchmark set, please call the set_benchmark command") - return - arg = arg.strip() if not arg or self.observations.count(arg): with Timer() as timer: @@ -735,10 +680,6 @@ def do_reward(self, arg): The name should come from the list of rewards printed by the command list_rewards. Tab completion will be used if available. """ - if not self.env.benchmark: - print("No benchmark set, please call the set_benchmark command") - return - if arg == "" and self.env.reward_space: arg = self.env.reward_space.id @@ -761,10 +702,6 @@ def do_set_default_reward(self, arg): With no argument it will set to None. This command will rerun the actions on the stack. """ - if not self.env.benchmark: - print("No benchmark set, please call the set_benchmark command") - return - arg = arg.strip() if not arg or self.rewards.count(arg): with Timer(f"Reward {arg}"): @@ -780,10 +717,6 @@ def do_commandline(self, arg): def do_stack(self, arg): """Show the environments on the stack. The current environment is the first shown.""" - if not self.env.benchmark: - print("No benchmark set, please call the set_benchmark command") - return - rows = [] total = 0 for i, hist in enumerate(self.stack): @@ -810,10 +743,6 @@ def do_simplify_stack(self, arg): being removed that previously had a negative reward being necessary for a later action to have a positive reward. This means you might see non-positive rewards on the stack afterwards. """ - if not self.env.benchmark: - print("No benchmark set, please call the set_benchmark command") - return - self.env.reset() old_stack = self.stack self.stack = [] @@ -879,7 +808,6 @@ def main(argv): raise app.UsageError(f"Unknown command line arguments: {argv[1:]}") with Timer("Initialized environment"): - # FIXME Chris, I don't seem to actually get a benchmark benchmark = benchmark_from_flags() env = env_from_flags(benchmark) diff --git a/compiler_gym/bin/random_search.py b/compiler_gym/bin/random_search.py index 47ff6d7b8..c0e3f4927 100644 --- a/compiler_gym/bin/random_search.py +++ b/compiler_gym/bin/random_search.py @@ -106,8 +106,6 @@ def make_env(): env = make_env() try: env.reset() - if not env.benchmark: - raise app.UsageError("No benchmark specified.") finally: env.close() diff --git a/compiler_gym/bin/service.py b/compiler_gym/bin/service.py index 3b8c97442..ec83b4866 100644 --- a/compiler_gym/bin/service.py +++ b/compiler_gym/bin/service.py @@ -72,41 +72,102 @@ $ python -m compiler_gym.bin.service --local_service_binary=/path/to/service/binary """ +import sys +from typing import Iterable + +import humanize from absl import app, flags +from compiler_gym.datasets import Dataset from compiler_gym.envs import CompilerEnv from compiler_gym.spaces import Commandline from compiler_gym.util.flags.env_from_flags import env_from_flags from compiler_gym.util.tabulate import tabulate from compiler_gym.util.truncate import truncate -flags.DEFINE_integer( - "heading_level", - 1, - "The base level for generated markdown headers, in the range [1,4].", +flags.DEFINE_string( + "heading_underline_char", + "-", + "The character to repeat to underline headings.", ) FLAGS = flags.FLAGS -def header(message: str, level: int): - prefix = "#" * level - return f"\n\n{prefix} {message}\n" +def header(message: str): + underline = FLAGS.heading_underline_char * ( + len(message) // len(FLAGS.heading_underline_char) + ) + return f"\n\n{message}\n{underline}\n" + + +def shape2str(shape, n: int = 80): + string = str(shape) + if len(string) > n: + return f"`{string[:n-4]}` ..." + return f"`{string}`" -def print_service_capabilities(env: CompilerEnv, base_heading_level: int = 1): +def summarize_datasets(datasets: Iterable[Dataset]) -> str: + rows = [] + # Override the default iteration order of datasets. + for dataset in sorted(datasets, key=lambda d: d.name): + # Raw numeric values here, formatted below. + description = truncate(dataset.description, max_line_len=60) + links = ", ".join( + f"`{name} <{url}>`__" for name, url in sorted(dataset.references.items()) + ) + if links: + description = f"{description} [{links}]" + rows.append( + ( + dataset.name, + dataset.size, + description, + dataset.validatable, + ) + ) + rows.append(("Total", sum(r[1] for r in rows), "", "")) + return ( + tabulate( + [ + ( + n, + humanize.intcomma(f) if f >= 0 else "∞", + l, + v, + ) + for n, f, l, v in rows + ], + headers=( + "Dataset", + "Num. Benchmarks [#f1]_", + "Description", + "Validatable [#f2]_", + ), + ) + + f""" + +.. [#f1] Values obtained on {sys.platform}. Datasets are platform-specific. +.. [#f2] A **validatable** dataset is one where the behavior of the benchmarks + can be checked by compiling the programs to binaries and executing + them. If the benchmarks crash, or are found to have different behavior, + then validation fails. This type of validation is used to check that + the compiler has not broken the semantics of the program. + See :mod:`compiler_gym.bin.validate`. +""" + ) + + +def print_service_capabilities(env: CompilerEnv): """Discover and print the capabilities of a CompilerGym service. :param env: An environment. """ - print(header(f"CompilerGym Service `{env.service}`", base_heading_level).strip()) - print(header("Programs", base_heading_level + 1)) + print(header("Datasets")) print( - tabulate( - [(p,) for p in sorted(env.benchmarks)], - headers=("Benchmark",), - ) + summarize_datasets(env.datasets), ) - print(header("Observation Spaces", base_heading_level + 1)) + print(header("Observation Spaces")) print( tabulate( sorted( @@ -118,7 +179,7 @@ def print_service_capabilities(env: CompilerEnv, base_heading_level: int = 1): headers=("Observation space", "Shape"), ) ) - print(header("Reward Spaces", base_heading_level + 1)) + print(header("Reward Spaces")) print( tabulate( [ @@ -141,14 +202,8 @@ def print_service_capabilities(env: CompilerEnv, base_heading_level: int = 1): ) ) - print(header("Action Spaces", base_heading_level + 1).rstrip()) for action_space in env.action_spaces: - print( - header( - f"`{action_space.name}` ({type(action_space).__name__})", - base_heading_level + 2, - ) - ) + print(header(f"{action_space.name} Action Space")) # Special handling for commandline action spaces to print additional # information. if isinstance(action_space, Commandline): @@ -173,11 +228,10 @@ def print_service_capabilities(env: CompilerEnv, base_heading_level: int = 1): def main(argv): """Main entry point.""" assert len(argv) == 1, f"Unrecognized flags: {argv[1:]}" - assert 0 < FLAGS.heading_level <= 4, "--heading_level must be in range [1,4]" env = env_from_flags() try: - print_service_capabilities(env, base_heading_level=FLAGS.heading_level) + print_service_capabilities(env) finally: env.close() diff --git a/compiler_gym/datasets/__init__.py b/compiler_gym/datasets/__init__.py index ea7aba216..df9b009a4 100644 --- a/compiler_gym/datasets/__init__.py +++ b/compiler_gym/datasets/__init__.py @@ -11,7 +11,6 @@ from compiler_gym.datasets.dataset import ( Dataset, DatasetInitError, - LegacyDataset, activate, deactivate, delete, @@ -32,7 +31,6 @@ "deactivate", "delete", "FilesDataset", - "LegacyDataset", "require", "TarDataset", "TarDatasetWithManifest", diff --git a/compiler_gym/datasets/dataset.py b/compiler_gym/datasets/dataset.py index f75c5ea0b..295ab4a00 100644 --- a/compiler_gym/datasets/dataset.py +++ b/compiler_gym/datasets/dataset.py @@ -2,23 +2,17 @@ # # This source code is licensed under the MIT license found in the # LICENSE file in the root directory of this source tree. -import io -import json import logging import os import shutil -import tarfile -import warnings from pathlib import Path -from typing import Dict, Iterable, List, NamedTuple, Optional, Union +from typing import Dict, Iterable, Optional, Union -import fasteners from deprecated.sphinx import deprecated from compiler_gym.datasets.benchmark import Benchmark from compiler_gym.datasets.uri import DATASET_NAME_RE from compiler_gym.util.debug_util import get_logging_level -from compiler_gym.util.download import download class Dataset(object): @@ -352,255 +346,92 @@ class DatasetInitError(OSError): """Base class for errors raised if a dataset fails to initialize.""" -class LegacyDataset(NamedTuple): - """A collection of benchmarks for use by an environment. - .. deprecated:: 0.1.4 - The next release of CompilerGym will introduce a new API for describing - datasets with extended functionality. See - `here `_ for - more information. - """ - - name: str - """The name of the dataset.""" - - license: str - """The license of the dataset.""" - - file_count: int - """The number of files in the unpacked dataset.""" - - size_bytes: int - """The size of the unpacked dataset in bytes.""" - - url: str = "" - """A URL where the dataset can be downloaded from. May be an empty string.""" - - sha256: str = "" - """The sha256 checksum of the dataset archive. If provided, this is used to - verify the contents of the dataset upon download. - """ - - compiler: str = "" - """The name of the compiler that this dataset supports.""" - - description: str = "" - """An optional human-readable description of the dataset.""" - - platforms: List[str] = ["macos", "linux"] - """A list of platforms supported by this dataset. Allowed platforms 'macos' and 'linux'.""" - - deprecated_since: str = "" - """The CompilerGym release in which this dataset was deprecated.""" - - @property - def deprecated(self) -> bool: - """Whether the dataset is deprecated.""" - return bool(self.deprecated_since) - - @classmethod - def from_json_file(cls, path: Path) -> "LegacyDataset": - """Construct a dataset form a JSON metadata file. - :param path: Path of the JSON metadata. - :return: A LegacyDataset instance. - """ - try: - with open(str(path), "rb") as f: - data = json.load(f) - except json.decoder.JSONDecodeError as e: - raise OSError( - f"Failed to read dataset metadata file:\n" - f"Path: {path}\n" - f"Error: {e}" - ) - return cls(**data) - - def to_json_file(self, path: Path) -> Path: - """Write the dataset metadata to a JSON file. - :param path: Path of the file to write. - :return: The path of the written file. - """ - with open(str(path), "wb") as f: - json.dump(self._asdict(), f) - return path - - @deprecated( version="0.1.4", reason=( - "Activating datasets will be removed in v0.1.5. " + "Datasets are now automatically activated. " "`More information `_." ), ) -def activate(env, name: str) -> bool: - """Move a directory from the inactive to active benchmark directory. - :param: The name of a dataset. +def activate(env, dataset: Union[str, Dataset]) -> bool: + """Deprecated function for managing datasets. + + :param dataset: The name of the dataset to download, or a :class:`Dataset` + instance. + :return: :code:`True` if the dataset was activated, else :code:`False` if already active. + :raises ValueError: If there is no dataset with that name. """ - with fasteners.InterProcessLock(env.datasets_site_path / "LOCK"): - if (env.datasets_site_path / name).exists(): - # There is already an active benchmark set with this name. - return False - if not (env.inactive_datasets_site_path / name).exists(): - raise ValueError(f"Inactive dataset not found: {name}") - os.rename(env.inactive_datasets_site_path / name, env.datasets_site_path / name) - os.rename( - env.inactive_datasets_site_path / f"{name}.json", - env.datasets_site_path / f"{name}.json", - ) - return True + return False @deprecated( version="0.1.4", reason=( - "Deleting datasets will be removed in v0.1.5. " + "Please use :meth:`del env.datasets[dataset] `. " "`More information `_." ), ) -def delete(env, name: str) -> bool: - """Delete a directory in the inactive benchmark directory. - :param: The name of a dataset. +def delete(env, dataset: Union[str, Dataset]) -> bool: + """Deprecated function for managing datasets. + + Please use :meth:`del env.datasets[dataset] + `. + + :param dataset: The name of the dataset to download, or a :class:`Dataset` + instance. + :return: :code:`True` if the dataset was deleted, else :code:`False` if already deleted. """ - with fasteners.InterProcessLock(env.datasets_site_path / "LOCK"): - deleted = False - if (env.datasets_site_path / name).exists(): - shutil.rmtree(str(env.datasets_site_path / name)) - os.unlink(str(env.datasets_site_path / f"{name}.json")) - deleted = True - if (env.inactive_datasets_site_path / name).exists(): - shutil.rmtree(str(env.inactive_datasets_site_path / name)) - os.unlink(str(env.inactive_datasets_site_path / f"{name}.json")) - deleted = True - return deleted + del env.datasets[dataset] + return False @deprecated( version="0.1.4", reason=( - "Deactivating datasets will be removed in v0.1.5. " + "Please use :meth:`env.datasets.deactivate() `. " "`More information `_." ), ) -def deactivate(env, name: str) -> bool: - """Move a directory from active to the inactive benchmark directory. - :param: The name of a dataset. +def deactivate(env, dataset: Union[str, Dataset]) -> bool: + """Deprecated function for managing datasets. + + Please use :meth:`del env.datasets[dataset] + `. + + :param dataset: The name of the dataset to download, or a :class:`Dataset` + instance. + :return: :code:`True` if the dataset was deactivated, else :code:`False` if already inactive. """ - with fasteners.InterProcessLock(env.datasets_site_path / "LOCK"): - if not (env.datasets_site_path / name).exists(): - return False - os.rename(env.datasets_site_path / name, env.inactive_datasets_site_path / name) - os.rename( - env.datasets_site_path / f"{name}.json", - env.inactive_datasets_site_path / f"{name}.json", - ) - return True + del env.datasets[dataset] + return False -def require(env, dataset: Union[str, LegacyDataset]) -> bool: - """Require that the given dataset is available to the environment. - This will download and activate the dataset if it is not already installed. - After calling this function, benchmarks from the dataset will be available - to use. - Example usage: - >>> env = gym.make("llvm-v0") - >>> require(env, "blas-v0") - >>> env.reset(benchmark="blas-v0/1") +@deprecated( + version="0.1.7", + reason=( + "Datasets are now installed automatically, there is no need to call :code:`require()`. " + "`More information `_." + ), +) +def require(env, dataset: Union[str, Dataset]) -> bool: + """Deprecated function for managing datasets. + + Datasets are now installed automatically. See :class:`env.datasets + `. + :param env: The environment that this dataset is required for. - :param dataset: The name of the dataset to download, the URL of the dataset, - or a :class:`LegacyDataset` instance. + + :param dataset: The name of the dataset to download, or a :class:`Dataset` + instance. + :return: :code:`True` if the dataset was downloaded, or :code:`False` if the dataset was already available. """ - - def download_and_unpack_archive( - url: str, sha256: Optional[str] = None - ) -> LegacyDataset: - json_files_before = { - f - for f in env.inactive_datasets_site_path.iterdir() - if f.is_file() and f.name.endswith(".json") - } - tar_data = io.BytesIO(download(url, sha256)) - with tarfile.open(fileobj=tar_data, mode="r:bz2") as arc: - arc.extractall(str(env.inactive_datasets_site_path)) - json_files_after = { - f - for f in env.inactive_datasets_site_path.iterdir() - if f.is_file() and f.name.endswith(".json") - } - new_json = json_files_after - json_files_before - if not len(new_json): - raise OSError(f"Downloaded dataset {url} contains no metadata JSON file") - return LegacyDataset.from_json_file(list(new_json)[0]) - - def unpack_local_archive(path: Path) -> LegacyDataset: - if not path.is_file(): - raise FileNotFoundError(f"File not found: {path}") - json_files_before = { - f - for f in env.inactive_datasets_site_path.iterdir() - if f.is_file() and f.name.endswith(".json") - } - with tarfile.open(str(path), "r:bz2") as arc: - arc.extractall(str(env.inactive_datasets_site_path)) - json_files_after = { - f - for f in env.inactive_datasets_site_path.iterdir() - if f.is_file() and f.name.endswith(".json") - } - new_json = json_files_after - json_files_before - if not len(new_json): - raise OSError(f"Downloaded dataset {url} contains no metadata JSON file") - return LegacyDataset.from_json_file(list(new_json)[0]) - - with fasteners.InterProcessLock(env.datasets_site_path / "LOCK"): - # Resolve the name and URL of the dataset. - sha256 = None - if isinstance(dataset, LegacyDataset): - name, url = dataset.name, dataset.url - elif isinstance(dataset, str): - # Check if we have already downloaded the dataset. - if "://" in dataset: - name, url = None, dataset - dataset: Optional[LegacyDataset] = None - else: - try: - dataset: Optional[LegacyDataset] = env.available_datasets[dataset] - except KeyError: - raise ValueError(f"Dataset not found: {dataset}") - name, url, sha256 = dataset.name, dataset.url, dataset.sha256 - else: - raise TypeError( - f"require() called with unsupported type: {type(dataset).__name__}" - ) - - if dataset and dataset.deprecated: - warnings.warn( - f"Dataset '{dataset.name}' is deprecated as of CompilerGym " - f"release {dataset.deprecated_since}, please update to the " - "latest available version", - DeprecationWarning, - ) - - # Check if we have already downloaded the dataset. - if name: - if (env.datasets_site_path / name).is_dir(): - # Dataset is already downloaded and active. - return False - elif not (env.inactive_datasets_site_path / name).is_dir(): - # Dataset is downloaded but inactive. - name = download_and_unpack_archive(url, sha256=sha256).name - elif url.startswith("file:///"): - name = unpack_local_archive(Path(url[len("file:///") :])).name - else: - name = download_and_unpack_archive(url, sha256=sha256).name - - activate(env, name) - return True + return False diff --git a/compiler_gym/envs/compiler_env.py b/compiler_gym/envs/compiler_env.py index 4d2be7217..fe1c5008c 100644 --- a/compiler_gym/envs/compiler_env.py +++ b/compiler_gym/envs/compiler_env.py @@ -5,8 +5,6 @@ """This module defines the OpenAI gym interface for compilers.""" import logging import numbers -import os -import sys import warnings from collections.abc import Iterable as IterableType from copy import deepcopy @@ -15,13 +13,13 @@ from time import time from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, Union -import fasteners import gym import numpy as np +from deprecated.sphinx import deprecated from gym.spaces import Space from compiler_gym.compiler_env_state import CompilerEnvState -from compiler_gym.datasets import Benchmark, Dataset, Datasets, LegacyDataset, require +from compiler_gym.datasets import Benchmark, Dataset, Datasets from compiler_gym.service import ( CompilerGymServiceConnection, ConnectionOpts, @@ -31,14 +29,12 @@ SessionNotFound, observation_t, ) -from compiler_gym.service.proto import AddBenchmarkRequest -from compiler_gym.service.proto import Benchmark as BenchmarkProto from compiler_gym.service.proto import ( + AddBenchmarkRequest, EndSessionReply, EndSessionRequest, ForkSessionReply, ForkSessionRequest, - GetBenchmarksRequest, GetVersionReply, GetVersionRequest, StartSessionRequest, @@ -116,14 +112,6 @@ class CompilerEnv(gym.Env): Default range is (-inf, +inf). :vartype reward_range: Tuple[float, float] - :ivar datasets_site_path: The filesystem path used by the service - to store benchmarks. - :vartype datasets_site_path: Optional[Path] - - :ivar available_datasets: A mapping from dataset name to :class:`LegacyDataset` - objects that are available to download. - :vartype available_datasets: Dict[str, LegacyDataset] - :ivar observation: A view of the available observation spaces that permits on-demand computation of observations. :vartype observation: compiler_gym.views.ObservationView @@ -154,48 +142,57 @@ def __init__( """Construct and initialize a CompilerGym service environment. :param service: The hostname and port of a service that implements the - CompilerGym service interface, or the path of a binary file - which provides the CompilerGym service interface when executed. - See :doc:`/compiler_gym/service` for details. + CompilerGym service interface, or the path of a binary file which + provides the CompilerGym service interface when executed. See + :doc:`/compiler_gym/service` for details. + :param rewards: The reward spaces that this environment supports. - Rewards are typically calculated based on observations generated - by the service. See :class:`Reward ` for + Rewards are typically calculated based on observations generated by + the service. See :class:`Reward ` for details. - :param benchmark: The name of the benchmark to use for this environment. - The choice of benchmark can be deferred by not providing this - argument and instead passing by choosing from the - :code:`CompilerEnv.benchmarks` attribute and passing it to - :func:`reset()` when called. + + :param benchmark: The benchmark to use for this environment. Either a + URI string, or a :class:`Benchmark` instance. If not provided, the + first benchmark as returned by + :code:`next(env.datasets.benchmarks())` will be used as the default. + :param observation_space: Compute and return observations at each :func:`step()` from this space. Accepts a string name or an - :class:`ObservationSpaceSpec `. - If not provided, :func:`step()` returns :code:`None` for the - observation value. Can be set later using - :meth:`env.observation_space `. - For available spaces, see - :class:`env.observation.spaces `. + :class:`ObservationSpaceSpec + `. If not provided, + :func:`step()` returns :code:`None` for the observation value. Can + be set later using :meth:`env.observation_space + `. For available + spaces, see :class:`env.observation.spaces + `. + :param reward_space: Compute and return reward at each :func:`step()` - from this space. Accepts a string name or a - :class:`Reward `. If - not provided, :func:`step()` returns :code:`None` for the reward - value. Can be set later using - :meth:`env.reward_space `. - For available spaces, see - :class:`env.reward.spaces `. + from this space. Accepts a string name or a :class:`Reward + `. If not provided, :func:`step()` + returns :code:`None` for the reward value. Can be set later using + :meth:`env.reward_space + `. For available spaces, + see :class:`env.reward.spaces `. + :param action_space: The name of the action space to use. If not specified, the default action space for this compiler is used. + :param connection_settings: The settings used to establish a connection with the remote service. + :param service_connection: An existing compiler gym service connection to use. + :param logger: The logger to use for this environment. If not provided, a :code:`compiler_gym.envs` logger is used and assigned the - verbosity returned by - :func:`get_logging_level() `. + verbosity returned by :func:`get_logging_level() + `. + :raises FileNotFoundError: If service is a path to a file that is not found. - :raises TimeoutError: If the compiler service fails to initialize - within the parameters provided in :code:`connection_settings`. + + :raises TimeoutError: If the compiler service fails to initialize within + the parameters provided in :code:`connection_settings`. """ self.metadata = {"render.modes": ["human", "ansi"]} @@ -210,8 +207,6 @@ def __init__( self._service_endpoint: Union[str, Path] = service self._connection_settings = connection_settings or ConnectionOpts() - self.datasets_site_path: Optional[Path] = None - self.available_datasets: Dict[str, LegacyDataset] = {} self.action_space_name = action_space @@ -234,17 +229,14 @@ def __init__( ] # The benchmark that is currently being used, and the benchmark that - # the user requested. Those do not always correlate, since the user - # could request a random benchmark. - self._benchmark_in_use_uri: Optional[str] = None - self._user_specified_benchmark_uri: Optional[str] = None - # A map from benchmark URIs to Benchmark messages. We keep track of any - # user-provided custom benchmarks so that we can register them with a - # reset service. - self._custom_benchmarks: Dict[str, BenchmarkProto] = {} + # will be used on the next call to reset(). These are equal except in + # the gap between the user setting the env.benchmark property while in + # an episode and the next call to env.reset(). + self._benchmark_in_use: Optional[Benchmark] = None + self._next_benchmark: Optional[Benchmark] = None # Normally when the benchmark is changed the updated value is not - # reflected until the next call to reset(). We make an exception for - # constructor-time arguments as otherwise the behavior of the benchmark + # reflected until the next call to reset(). We make an exception for the + # constructor-time benchmark as otherwise the behavior of the benchmark # property is counter-intuitive: # # >>> env = gym.make("example-v0", benchmark="foo") @@ -254,10 +246,17 @@ def __init__( # >>> env.benchmark # "foo" # - # By forcing the benchmark-in-use URI at constructor time, the first - # env.benchmark returns the name as expected. - self.benchmark = benchmark - self._benchmark_in_use_uri = self._user_specified_benchmark_uri + # By forcing the _benchmark_in_use URI at constructor time, the first + # env.benchmark above returns the benchmark as expected. + try: + self.benchmark = benchmark or next(self.datasets.benchmarks()) + self._benchmark_in_use = self._next_benchmark + except StopIteration: + # StopIteration raised on next(self.datasets.benchmarks()) if there + # are no benchmarks available. This is to allow CompilerEnv to be + # used without any datasets by setting a benchmark before/during the + # first reset() call. + pass # Process the available action, observation, and reward spaces. self.action_spaces = [ @@ -288,6 +287,18 @@ def __init__( self.observation_space = observation_space self.reward_space = reward_space + @property + @deprecated( + version="0.1.8", + reason=( + "Use :meth:`env.datasets.datasets() ` instead. " + "`More information `_." + ), + ) + def available_datasets(self) -> Dict[str, Dataset]: + """A dictionary of datasets.""" + return {d.name: d for d in self.datasets} + @property def versions(self) -> GetVersionReply: """Get the version numbers from the compiler service.""" @@ -346,23 +357,12 @@ def episode_walltime(self) -> float: def state(self) -> CompilerEnvState: """The tuple representation of the current environment state.""" return CompilerEnvState( - benchmark=self.benchmark, + benchmark=str(self.benchmark) if self.benchmark else None, reward=self.episode_reward, walltime=self.episode_walltime, commandline=self.commandline(), ) - @property - def inactive_datasets_site_path(self) -> Optional[Path]: - """The filesystem path used to store inactive benchmarks.""" - if self.datasets_site_path: - return ( - self.datasets_site_path.parent - / f"{self.datasets_site_path.name}.inactive" - ) - else: - return None - @property def action_space(self) -> NamedDiscrete: """The current action space. @@ -385,73 +385,39 @@ def action_space(self, action_space: Optional[str]): self._action_space: NamedDiscrete = self.action_spaces[index] @property - def benchmark(self) -> Optional[str]: - """Get or set the name of the benchmark to use. - - :getter: Get the name of the current benchmark. Returns :code:`None` if - :func:`__init__` was not provided a benchmark and :func:`reset` has - not yet been called. - :setter: Set the benchmark to use. If :code:`None`, a random benchmark - is selected by the service on each call to :func:`reset`. Else, - the same benchmark is used for every episode. - - By default, a benchmark will be selected randomly by the service - from the available :func:`benchmarks` on a call to :func:`reset`. To - force a specific benchmark to be chosen, set this property (or pass - the benchmark as an argument to :func:`reset`): + def benchmark(self) -> Benchmark: + """Get or set the benchmark to use. - >>> env.benchmark = "benchmark://foo" - >>> env.reset() - >>> env.benchmark - "benchmark://foo" + :getter: Get :class:`Benchmark` that is currently in use. - Once set, all subsequent calls to :func:`reset` will select the same - benchmark. - - >>> env.benchmark = None - >>> env.reset() # random benchmark is chosen + :setter: Set the benchmark to use. Either a :class:`Benchmark` instance, + or the URI of a benchmark as in :meth:`env.datasets.benchmark_uris() + `. .. note:: - Setting a new benchmark has no effect until :func:`~reset()` is - called. - To return to random benchmark selection, set this property to - :code:`None`: + Setting a new benchmark has no effect until + :func:`env.reset() ` is called. """ - return self._benchmark_in_use_uri + return self._benchmark_in_use @benchmark.setter - def benchmark(self, benchmark: Optional[Union[str, Benchmark]]): + def benchmark(self, benchmark: Union[str, Benchmark]): if self.in_episode: warnings.warn( - "Changing the benchmark has no effect until reset() is called." + "Changing the benchmark has no effect until reset() is called" ) - if benchmark is None: - self.logger.debug("Unsetting the forced benchmark") - self._user_specified_benchmark_uri = None - elif isinstance(benchmark, str): - self.logger.debug("Setting benchmark by name: %s", benchmark) - # If the user requested a benchmark by URI, e.g. - # benchmark://cBench-v1/dijkstra, require the dataset (cBench-v1) - # automatically. - if self.datasets_site_path: - components = benchmark.split("://") - if len(components) == 1 or components[0] == "benchmark": - components = components[-1].split("/") - if len(components) > 1: - self.logger.info("Requiring dataset %s", components[0]) - self.require_dataset(components[0]) - self._user_specified_benchmark_uri = benchmark - elif isinstance(benchmark, BenchmarkProto): - self.logger.debug("Setting benchmark data: %s", benchmark.uri) - self._user_specified_benchmark_uri = benchmark.uri - self._add_custom_benchmarks([benchmark]) + if isinstance(benchmark, str): + benchmark_object = self.datasets.benchmark(benchmark) + self.logger.debug("Setting benchmark by name: %s", benchmark_object) + self._next_benchmark = benchmark_object elif isinstance(benchmark, Benchmark): - self.logger.debug("Setting benchmark: %s", benchmark) - self._user_specified_benchmark_uri = benchmark.uri - self._add_custom_benchmarks([benchmark.proto]) + self.logger.debug("Setting benchmark: %s", benchmark.uri) + self._next_benchmark = benchmark else: - raise TypeError(f"Unsupported benchmark type: {type(benchmark).__name__}") + raise TypeError( + f"Expected a Benchmark or str, received: '{type(benchmark).__name__}'" + ) @property def reward_space(self) -> Optional[Reward]: @@ -532,33 +498,30 @@ def fork(self) -> "CompilerEnv": The user must call :meth:`close() ` on the original and new environments. - :meth:`reset() ` must be called - before :code:`fork()`. + If not already in an episode, :meth:`reset() + ` is called. Example usage: - >>> env = gym.make("llvm-v0") - >>> env.reset() - # ... use env - >>> new_env = env.fork() - >>> new_env.state == env.state - True - >>> new_env.step(1) == env.step(1) - True + >>> env = gym.make("llvm-v0") + >>> env.reset() + # ... use env + >>> new_env = env.fork() + >>> new_env.state == env.state + True + >>> new_env.step(1) == env.step(1) + True :return: A new environment instance. """ if not self.in_episode: - if self.actions: - state_to_replay = self.state + if self.actions and not self.in_episode: self.logger.warning( "Parent service of fork() has died, replaying state" ) + self.apply(self.state) else: - state_to_replay = None - self.reset() - if state_to_replay: - self.apply(state_to_replay) + self.reset() request = ForkSessionRequest(session_id=self._session_id) reply: ForkSessionReply = self.service(self.service.stub.ForkSession, request) @@ -575,23 +538,16 @@ def fork(self) -> "CompilerEnv": new_env._session_id = reply.session_id # pylint: disable=protected-access new_env.observation.session_id = reply.session_id - # Re-register any custom benchmarks with the new environment. - if self._custom_benchmarks: - new_env._add_custom_benchmarks( # pylint: disable=protected-access - list(self._custom_benchmarks.values()).copy() - ) - # Now that we have initialized the environment with the current state, # set the benchmark so that calls to new_env.reset() will correctly # revert the environment to the initial benchmark state. - new_env._user_specified_benchmark_uri = ( # pylint: disable=protected-access - self.benchmark - ) + # + # pylint: disable=protected-access + new_env._next_benchmark = self._benchmark_in_use + # Set the "visible" name of the current benchmark to hide the fact that # we loaded from a custom bitcode file. - new_env._benchmark_in_use_uri = ( # pylint: disable=protected-access - self.benchmark - ) + new_env._benchmark_in_use = self._benchmark_in_use # Create copies of the mutable reward and observation spaces. This # is required to correctly calculate incremental updates. @@ -661,19 +617,32 @@ def reset( # pylint: disable=arguments-differ If no benchmark is provided, and no benchmark was provided to :func:`__init___`, the service will randomly select a benchmark to use. + :param action_space: The name of the action space to use. If provided, it overrides any value that set during :func:`__init__`, and - subsequent calls to :code:`reset()` will use this action space. - If no aciton space is provided, the default action space is used. + subsequent calls to :code:`reset()` will use this action space. If + no action space is provided, the default action space is used. + :return: The initial observation. + + :raises BenchmarkInitError: If the benchmark is invalid. In this case, + another benchmark must be used. + + :raises TypeError: If no benchmark has been set, and the environment + does not have a default benchmark to select from. """ + if not self._next_benchmark: + raise TypeError( + "No benchmark set. Set a benchmark using " + "`env.reset(benchmark=benchmark)`. Use `env.datasets` to " + "access the available benchmarks." + ) + # Start a new service if required. if self.service is None: self.service = CompilerGymServiceConnection( self._service_endpoint, self._connection_settings ) - # Re-register the custom benchmarks with the new service. - self._add_custom_benchmarks(self._custom_benchmarks.values()) self.action_space_name = action_space or self.action_space_name @@ -685,30 +654,33 @@ def reset( # pylint: disable=arguments-differ ) self._session_id = None - # Update the user requested benchmark, if provided. NOTE: This means - # that env.reset(benchmark=None) does NOT unset a forced benchmark. + # Update the user requested benchmark, if provided. if benchmark: self.benchmark = benchmark + self._benchmark_in_use = self._next_benchmark + + start_session_request = StartSessionRequest( + benchmark=self._benchmark_in_use.uri, + action_space=( + [a.name for a in self.action_spaces].index(self.action_space_name) + if self.action_space_name + else 0 + ), + observation_space=( + [self.observation_space_spec.index] if self.observation_space else None + ), + ) try: - reply = self.service( - self.service.stub.StartSession, - StartSessionRequest( - benchmark=self._user_specified_benchmark_uri, - action_space=( - [a.name for a in self.action_spaces].index( - self.action_space_name - ) - if self.action_space_name - else 0 - ), - observation_space=( - [self.observation_space_spec.index] - if self.observation_space - else None - ), - ), + reply = self.service(self.service.stub.StartSession, start_session_request) + except FileNotFoundError: + # The benchmark was not found, so try adding it and repeating the + # request. + self.service( + self.service.stub.AddBenchmark, + AddBenchmarkRequest(benchmark=[self._benchmark_in_use.proto]), ) + reply = self.service(self.service.stub.StartSession, start_session_request) except (ServiceError, ServiceTransportError, TimeoutError) as e: # Abort and retry on error. self.logger.warning("%s on reset(): %s", type(e).__name__, e) @@ -728,7 +700,6 @@ def reset( # pylint: disable=arguments-differ retry_count=retry_count + 1, ) - self._benchmark_in_use_uri = reply.benchmark self._session_id = reply.session_id self.observation.session_id = reply.session_id self.reward.get_cost = self.observation.__getitem__ @@ -758,14 +729,19 @@ def step(self, action: Union[int, Iterable[int]]) -> step_t: """Take a step. :param action: An action, or a sequence of actions. When multiple - actions are provided the observation and reward are returned - after running all of the actions. + actions are provided the observation and reward are returned after + running all of the actions. + :return: A tuple of observation, reward, done, and info. Observation and - reward are None if default observation/reward is not set. If done - is True, observation and reward may also be None (e.g. because the + reward are None if default observation/reward is not set. If done is + True, observation and reward may also be None (e.g. because the service failed). + + :raises SessionNotFound: If :meth:`reset() + ` has not been called. """ - assert self.in_episode, "Must call reset() before step()" + if not self.in_episode: + raise SessionNotFound("Must call reset() before step()") actions = action if isinstance(action, IterableType) else [action] observation, reward = None, None @@ -877,10 +853,16 @@ def render( raise ValueError(f"Invalid mode: {mode}") @property - def benchmarks(self) -> List[str]: - """Enumerate the list of available benchmarks.""" - reply = self.service(self.service.stub.GetBenchmarks, GetBenchmarksRequest()) - return list(reply.benchmark) + @deprecated( + version="0.1.8", + reason=( + "Use :meth:`env.datasets.benchmarks() ` instead. " + "`More information `_." + ), + ) + def benchmarks(self) -> Iterable[str]: + """Enumerate a (possible unbounded) list of available benchmarks.""" + return self.datasets.benchmark_uris() def _make_action_space(self, name: str, entries: List[str]) -> Space: """Create an action space from the given values. @@ -910,126 +892,73 @@ def _reward_view_type(self): """ return RewardView - def require_datasets(self, datasets: List[Union[str, LegacyDataset]]) -> bool: - """Require that the given datasets are available to the environment. - - Example usage: - - >>> env = gym.make("llvm-v0") - >>> env.require_dataset(["npb-v0"]) - >>> env.benchmarks - ["npb-v0/1", "npb-v0/2", ...] + @deprecated( + version="0.1.8", + reason=( + "Datasets are now installed automatically, there is no need to call :code:`require()`. " + "`More information `_." + ), + ) + def require_datasets(self, datasets: List[Union[str, Dataset]]) -> bool: + """Deprecated function for managing datasets. - This is equivalent to calling - :meth:`require(self, dataset) ` on - the list of datasets. + Datasets are now installed automatically. See :class:`env.datasets + `. :param datasets: A list of datasets to require. Each dataset is the name of an available dataset, the URL of a dataset to download, or a - :class:`LegacyDataset` instance. + :class:`Dataset` instance. + :return: :code:`True` if one or more datasets were downloaded, or :code:`False` if all datasets were already available. """ - self.logger.debug("Requiring datasets: %s", datasets) - dataset_installed = False - for dataset in datasets: - dataset_installed |= require(self, dataset) - if dataset_installed: - # Signal to the compiler service that the contents of the site data - # directory has changed. - self.logger.debug("Initiating service-side scan of dataset directory") - self.service( - self.service.stub.AddBenchmark, - AddBenchmarkRequest( - benchmark=[BenchmarkProto(uri="service://scan-site-data")] - ), - ) - self.make_manifest_file() - return dataset_installed + return False + + @deprecated( + version="0.1.8", + reason=( + "Use :meth:`env.datasets.require() ` instead. " + "`More information `_." + ), + ) + def require_dataset(self, dataset: Union[str, Dataset]) -> bool: + """Deprecated function for managing datasets. - def require_dataset(self, dataset: Union[str, LegacyDataset]) -> bool: - """Require that the given dataset is available to the environment. + Datasets are now installed automatically. See :class:`env.datasets + `. - Alias for - :meth:`env.require_datasets([dataset]) `. + :param dataset: The name of the dataset to download, the URL of the + dataset, or a :class:`Dataset` instance. - :param dataset: The name of the dataset to download, the URL of the dataset, or a - :class:`LegacyDataset` instance. :return: :code:`True` if the dataset was downloaded, or :code:`False` if the dataset was already available. """ - return self.require_datasets([dataset]) - - def make_manifest_file(self) -> Path: - """Create the MANIFEST file. - - :return: The path of the manifest file. - """ - with fasteners.InterProcessLock(self.datasets_site_path / "LOCK"): - manifest_path = ( - self.datasets_site_path.parent - / f"{self.datasets_site_path.name}.MANIFEST" - ) - with open(str(manifest_path), "w") as f: - for root, _, files in os.walk(self.datasets_site_path): - print( - "\n".join( - [ - f"{root[len(str(self.datasets_site_path)) + 1:]}/{f}" - for f in files - if not f.endswith(".json") and f != "LOCK" - ] - ), - file=f, - ) - return manifest_path - - def register_dataset(self, dataset: LegacyDataset) -> bool: + return False + + @deprecated( + version="0.1.8", + reason=( + "Use :meth:`env.datasets.add() ` instead. " + "`More information `_." + ), + ) + def register_dataset(self, dataset: Dataset) -> bool: """Register a new dataset. - After registering, the dataset name may be used by - :meth:`require_dataset() ` - to install and activate it. - Example usage: - >>> my_dataset = LegacyDataset(name="my-dataset-v0", ...) + >>> my_dataset = Dataset(name="my-dataset-v0", ...) >>> env = gym.make("llvm-v0") >>> env.register_dataset(my_dataset) - >>> env.require_dataset("my-dataset-v0") >>> env.benchmark = "my-dataset-v0/1" - :param dataset: A :class:`LegacyDataset` instance describing the new dataset. + :param dataset: A :class:`Dataset` instance describing the new dataset. + :return: :code:`True` if the dataset was added, else :code:`False`. + :raises ValueError: If a dataset with this name is already registered. """ - platform = {"darwin": "macos"}.get(sys.platform, sys.platform) - if platform not in dataset.platforms: - return False - if dataset.name in self.available_datasets: - raise ValueError(f"Dataset already registered with name: {dataset.name}") - self.available_datasets[dataset.name] = dataset - return True - - def _add_custom_benchmarks(self, benchmarks: List[BenchmarkProto]) -> None: - """Register custom benchmarks with the compiler service. - - Benchmark registration occurs automatically using the - :meth:`env.benchmark ` - property, there is usually no need to call this method yourself. - - :param benchmarks: The benchmarks to register. - """ - if not benchmarks: - return - - for benchmark in benchmarks: - self._custom_benchmarks[benchmark.uri] = benchmark - - self.service( - self.service.stub.AddBenchmark, - AddBenchmarkRequest(benchmark=benchmarks), - ) + return self.datasets.add(dataset) def apply(self, state: CompilerEnvState) -> None: # noqa """Replay this state on the given an environment. @@ -1054,8 +983,21 @@ def apply(self, state: CompilerEnvState) -> None: # noqa ) def validate(self, state: Optional[CompilerEnvState] = None) -> ValidationResult: - in_place = state is not None - state = state or self.state + """Validate an environment's state. + + :param state: A state to environment. If not provided, the current state + is validated. + + :returns: A :class:`ValidationResult`. + """ + if state: + self.reset(benchmark=state.benchmark) + in_place = False + else: + state = self.state + in_place = True + + assert self.in_episode errors: ValidationError = [] validation = { @@ -1123,13 +1065,10 @@ def validate(self, state: Optional[CompilerEnvState] = None) -> ValidationResult ) ) - # TODO(https://github.com/facebookresearch/CompilerGym/issues/45): - # Call the new self.benchmark.validation_callback() method - # once implemented. - validate_semantics = self.get_benchmark_validation_callback() - if validate_semantics: + benchmark = replay_target.benchmark + if benchmark.is_validatable(): validation["benchmark_semantics_validated"] = True - semantics_errors = list(validate_semantics(self)) + semantics_errors = benchmark.validate(replay_target) if semantics_errors: validation["benchmark_semantics_validation_failed"] = True errors += semantics_errors @@ -1145,13 +1084,24 @@ def validate(self, state: Optional[CompilerEnvState] = None) -> ValidationResult **validation, ) + @deprecated( + version="0.1.8", + reason=( + "Use :meth:`env.validate() " + "` instead. " + "`More information `_." + ), + ) def get_benchmark_validation_callback( self, ) -> Optional[Callable[["CompilerEnv"], Iterable[ValidationError]]]: - """Return a callback that validates benchmark semantics, if available. + """Return a callback that validates benchmark semantics, if available.""" - TODO(https://github.com/facebookresearch/CompilerGym/issues/45): This is - a temporary placeholder for what will eventually become a method on a - new Benchmark class. - """ - return None + def composed(env): + for validation_cb in self.benchmark.validation_callbacks(): + errors = validation_cb(env) + if errors: + yield from errors + + if self.benchmark.validation_callbacks(): + return composed diff --git a/compiler_gym/envs/llvm/BUILD b/compiler_gym/envs/llvm/BUILD index bafa6dc89..e819ac523 100644 --- a/compiler_gym/envs/llvm/BUILD +++ b/compiler_gym/envs/llvm/BUILD @@ -31,17 +31,6 @@ py_library( ], ) -py_library( - name = "legacy_datasets", - srcs = ["legacy_datasets.py"], - visibility = ["//tests:__subpackages__"], - deps = [ - "//compiler_gym/datasets", - "//compiler_gym/third_party/llvm", - "//compiler_gym/util", - ], -) - py_library( name = "llvm_env", srcs = ["llvm_env.py"], @@ -49,9 +38,9 @@ py_library( "//compiler_gym/envs/llvm/service/passes:actions_genfiles", ], deps = [ - ":legacy_datasets", ":llvm_benchmark", ":llvm_rewards", + "//compiler_gym/datasets", "//compiler_gym/envs:compiler_env", "//compiler_gym/envs/llvm/datasets", "//compiler_gym/spaces", diff --git a/compiler_gym/envs/llvm/datasets/__init__.py b/compiler_gym/envs/llvm/datasets/__init__.py index 4d221b264..9ef0086ab 100644 --- a/compiler_gym/envs/llvm/datasets/__init__.py +++ b/compiler_gym/envs/llvm/datasets/__init__.py @@ -234,11 +234,11 @@ def get_llvm_datasets(site_data_base: Optional[Path] = None) -> Iterable[Dataset __all__ = [ "AnghaBenchDataset", "BlasDataset", - "CLgenDataset", "CBenchDataset", "CBenchLegacyDataset", - "CsmithDataset", + "CLgenDataset", "CsmithBenchmark", + "CsmithDataset", "get_llvm_datasets", "GitHubDataset", "LinuxDataset", diff --git a/compiler_gym/envs/llvm/llvm_env.py b/compiler_gym/envs/llvm/llvm_env.py index 100a0c59d..21768109b 100644 --- a/compiler_gym/envs/llvm/llvm_env.py +++ b/compiler_gym/envs/llvm/llvm_env.py @@ -7,19 +7,15 @@ import os import shutil from pathlib import Path -from typing import Callable, Iterable, List, Optional, Union, cast +from typing import Iterable, List, Optional, Union, cast import numpy as np from gym.spaces import Box from gym.spaces import Dict as DictSpace -from compiler_gym.datasets import Benchmark, Dataset +from compiler_gym.datasets import Benchmark, BenchmarkInitError, Dataset from compiler_gym.envs.compiler_env import CompilerEnv from compiler_gym.envs.llvm.datasets import get_llvm_datasets -from compiler_gym.envs.llvm.legacy_datasets import ( - LLVM_DATASETS, - get_llvm_benchmark_validation_callback, -) from compiler_gym.envs.llvm.llvm_benchmark import ClangInvocation, make_benchmark from compiler_gym.envs.llvm.llvm_rewards import ( BaselineImprovementNormalizedReward, @@ -31,8 +27,8 @@ from compiler_gym.third_party.inst2vec import Inst2vecEncoder from compiler_gym.third_party.llvm import download_llvm_files from compiler_gym.third_party.llvm.instcount import INST_COUNT_FEATURE_NAMES -from compiler_gym.util.runfiles_path import runfiles_path, site_data_path -from compiler_gym.validation_error import ValidationError +from compiler_gym.util.runfiles_path import runfiles_path + _ACTIONS_LIST = Path( runfiles_path("compiler_gym/envs/llvm/service/passes/actions_list.txt") @@ -95,13 +91,21 @@ class LlvmEnv(CompilerEnv): :vartype actions: List[int] """ - def __init__(self, *args, datasets_site_path: Optional[Path] = None, **kwargs): + def __init__( + self, + *args, + benchmark: Optional[Union[str, Benchmark]] = None, + datasets_site_path: Optional[Path] = None, + **kwargs, + ): # First perform a one-time download of LLVM binaries that are needed by # the LLVM service and are not included by the pip-installed package. download_llvm_files() super().__init__( *args, **kwargs, + # Set a default benchmark for use. + benchmark=benchmark or "cbench-v1/qsort", datasets=_get_llvm_datasets(site_data_base=datasets_site_path), rewards=[ CostFunctionReward( @@ -180,13 +184,6 @@ def __init__(self, *args, datasets_site_path: Optional[Path] = None, **kwargs): ), ], ) - self.datasets_site_path = site_data_path("llvm/10.0.0/bitcode_benchmarks") - - # Register the LLVM datasets. - self.datasets_site_path.mkdir(parents=True, exist_ok=True) - self.inactive_datasets_site_path.mkdir(parents=True, exist_ok=True) - for dataset in LLVM_DATASETS: - self.register_dataset(dataset) self.inst2vec = _INST2VEC_ENCODER @@ -295,22 +292,16 @@ def __init__(self, *args, datasets_site_path: Optional[Path] = None, **kwargs): ) def reset(self, *args, **kwargs): - # The BenchmarkFactory::getBenchmark() method raises an error if there - # are no benchmarks to select from. Install the cBench dataset as a - # fallback. - # - # TODO(github.com/facebookresearch/CompilerGym/issues/45): Remove this - # once the dataset API has been refactored so that service-side datasets - # are no longer an issue. try: return super().reset(*args, **kwargs) - except FileNotFoundError: - self.logger.warning( - "reset() called on servie with no benchmarks available. " - "Installing cBench-v1" - ) - self.require_dataset("cBench-v1") - super().reset(*args, **kwargs) + except ValueError as e: + # Catch and re-raise a compilation error with a more informative + # error type. + if "Failed to compute .text size cost" in str(e): + raise BenchmarkInitError( + f"Failed to initialize benchmark {self._benchmark_in_use.uri}: {e}" + ) from e + raise def make_benchmark( self, @@ -468,7 +459,7 @@ def ir_sha1(self) -> str: Equivalent to: :code:`hashlib.sha1(env.ir.encode("utf-8")).hexdigest()`. - :return: A 40-character hexademical sha1 string. + :return: A 40-character hexadecimal sha1 string. """ # TODO(cummins): Compute this on the service-side and add it as an # observation space. @@ -507,17 +498,3 @@ def render( print(self.ir) else: return super().render(mode) - - def get_benchmark_validation_callback( - self, - ) -> Optional[Callable[[CompilerEnv], Iterable[ValidationError]]]: - """Return a callback for validating a given environment state. - - If there is no valid callback, returns :code:`None`. - - :param env: An :class:`LlvmEnv` instance. - :return: An optional callback that takes an :class:`LlvmEnv` instance as - argument and returns an optional string containing a validation error - message. - """ - return get_llvm_benchmark_validation_callback(self) diff --git a/compiler_gym/envs/llvm/llvm_rewards.py b/compiler_gym/envs/llvm/llvm_rewards.py index 865b77e98..d746b092a 100644 --- a/compiler_gym/envs/llvm/llvm_rewards.py +++ b/compiler_gym/envs/llvm/llvm_rewards.py @@ -5,6 +5,7 @@ """This module defines reward spaces used by the LLVM environment.""" from typing import List, Optional +from compiler_gym.datasets import Benchmark from compiler_gym.service import observation_t from compiler_gym.spaces.reward import Reward from compiler_gym.views.observation import ObservationView @@ -35,7 +36,7 @@ def __init__(self, cost_function: str, init_cost_function: str, **kwargs): self.init_cost_function: str = init_cost_function self.previous_cost: Optional[observation_t] = None - def reset(self, benchmark: str) -> None: + def reset(self, benchmark: Benchmark) -> None: """Called on env.reset(). Reset incremental progress.""" del benchmark # unused self.previous_cost = None @@ -64,7 +65,7 @@ def __init__(self, **kwargs): """Constructor.""" super().__init__(**kwargs) self.cost_norm: Optional[observation_t] = None - self.benchmark = None + self.benchmark: Benchmark = None def reset(self, benchmark: str) -> None: """Called on env.reset(). Reset incremental progress.""" diff --git a/compiler_gym/envs/llvm/service/BUILD b/compiler_gym/envs/llvm/service/BUILD index 8e42a1668..4f08d1dd5 100644 --- a/compiler_gym/envs/llvm/service/BUILD +++ b/compiler_gym/envs/llvm/service/BUILD @@ -104,6 +104,7 @@ cc_library( ], deps = [ ":Benchmark", + ":Cost", "//compiler_gym/util:GrpcStatusMacros", "//compiler_gym/util:RunfilesPath", "//compiler_gym/util:StrLenConstexpr", diff --git a/compiler_gym/envs/llvm/service/Benchmark.cc b/compiler_gym/envs/llvm/service/Benchmark.cc index 8e8395acc..9f136dffc 100644 --- a/compiler_gym/envs/llvm/service/Benchmark.cc +++ b/compiler_gym/envs/llvm/service/Benchmark.cc @@ -22,13 +22,6 @@ namespace compiler_gym::llvm_service { namespace { -BaselineCosts getBaselineCosts(const llvm::Module& unoptimizedModule, - const fs::path& workingDirectory) { - BaselineCosts baselineCosts; - setbaselineCosts(unoptimizedModule, &baselineCosts, workingDirectory); - return baselineCosts; -} - BenchmarkHash getModuleHash(const llvm::Module& module) { BenchmarkHash hash; llvm::SmallVector buffer; @@ -51,8 +44,10 @@ std::unique_ptr makeModuleOrDie(llvm::LLVMContext& context, const } // anonymous namespace Status readBitcodeFile(const fs::path& path, Bitcode* bitcode) { - std::ifstream ifs; - ifs.open(path.string()); + std::ifstream ifs(path.string()); + if (ifs.fail()) { + return Status(StatusCode::NOT_FOUND, fmt::format("File not found: \"{}\"", path.string())); + } ifs.seekg(0, std::ios::end); if (ifs.fail()) { @@ -101,35 +96,30 @@ std::unique_ptr makeModule(llvm::LLVMContext& context, const Bitco // A benchmark is an LLVM module and the LLVM context that owns it. Benchmark::Benchmark(const std::string& name, const Bitcode& bitcode, - const fs::path& workingDirectory, std::optional bitcodePath, - const BaselineCosts* baselineCosts) + const fs::path& workingDirectory, const BaselineCosts& baselineCosts) : context_(std::make_unique()), module_(makeModuleOrDie(*context_, bitcode, name)), - baselineCosts_(baselineCosts ? *baselineCosts : getBaselineCosts(*module_, workingDirectory)), + baselineCosts_(baselineCosts), hash_(getModuleHash(*module_)), name_(name), - bitcodeSize_(bitcode.size()), - bitcodePath_(bitcodePath) {} + bitcodeSize_(bitcode.size()) {} Benchmark::Benchmark(const std::string& name, std::unique_ptr context, std::unique_ptr module, size_t bitcodeSize, - const fs::path& workingDirectory, std::optional bitcodePath, - const BaselineCosts* baselineCosts) + const fs::path& workingDirectory, const BaselineCosts& baselineCosts) : context_(std::move(context)), module_(std::move(module)), - baselineCosts_(baselineCosts ? *baselineCosts : getBaselineCosts(*module_, workingDirectory)), + baselineCosts_(baselineCosts), hash_(getModuleHash(*module_)), name_(name), - bitcodeSize_(bitcodeSize), - bitcodePath_(bitcodePath) {} + bitcodeSize_(bitcodeSize) {} std::unique_ptr Benchmark::clone(const fs::path& workingDirectory) const { Bitcode bitcode; llvm::raw_svector_ostream ostream(bitcode); llvm::WriteBitcodeToFile(module(), ostream); - return std::make_unique(name(), bitcode, workingDirectory, bitcodePath(), - &baselineCosts()); + return std::make_unique(name(), bitcode, workingDirectory, baselineCosts()); } } // namespace compiler_gym::llvm_service diff --git a/compiler_gym/envs/llvm/service/Benchmark.h b/compiler_gym/envs/llvm/service/Benchmark.h index 7c979a79c..713c65b99 100644 --- a/compiler_gym/envs/llvm/service/Benchmark.h +++ b/compiler_gym/envs/llvm/service/Benchmark.h @@ -38,23 +38,17 @@ std::unique_ptr makeModule(llvm::LLVMContext& context, const Bitco class Benchmark { public: Benchmark(const std::string& name, const Bitcode& bitcode, - const boost::filesystem::path& workingDirectory, - std::optional bitcodePath = std::nullopt, - const BaselineCosts* baselineCosts = nullptr); + const boost::filesystem::path& workingDirectory, const BaselineCosts& baselineCosts); Benchmark(const std::string& name, std::unique_ptr context, std::unique_ptr module, size_t bitcodeSize, - const boost::filesystem::path& workingDirectory, - std::optional bitcodePath = std::nullopt, - const BaselineCosts* baselineCosts = nullptr); + const boost::filesystem::path& workingDirectory, const BaselineCosts& baselineCosts); // Make a copy of the benchmark. std::unique_ptr clone(const boost::filesystem::path& workingDirectory) const; inline const std::string& name() const { return name_; } - inline const std::optional bitcodePath() const { return bitcodePath_; } - inline const size_t bitcodeSize() const { return bitcodeSize_; } inline llvm::Module& module() { return *module_; } @@ -91,9 +85,6 @@ class Benchmark { const std::string name_; // The length of the bitcode string for this benchmark. const size_t bitcodeSize_; - // The path of the bitcode file for this benchmark. This is optional - - // benchmarks do not have to be backed by a file. - const std::optional bitcodePath_; }; } // namespace compiler_gym::llvm_service diff --git a/compiler_gym/envs/llvm/service/BenchmarkFactory.cc b/compiler_gym/envs/llvm/service/BenchmarkFactory.cc index 0ef0584c8..73509654c 100644 --- a/compiler_gym/envs/llvm/service/BenchmarkFactory.cc +++ b/compiler_gym/envs/llvm/service/BenchmarkFactory.cc @@ -11,6 +11,7 @@ #include #include +#include "compiler_gym/envs/llvm/service/Cost.h" #include "compiler_gym/util/GrpcStatusMacros.h" #include "compiler_gym/util/RunfilesPath.h" #include "compiler_gym/util/StrLenConstexpr.h" @@ -24,10 +25,6 @@ using grpc::StatusCode; namespace compiler_gym::llvm_service { -static const std::string kExpectedExtension = ".bc"; - -static const fs::path kSiteBenchmarksDir = util::getSiteDataPath("llvm/10.0.0/bitcode_benchmarks"); - BenchmarkFactory::BenchmarkFactory(const boost::filesystem::path& workingDirectory, std::optional rand, size_t maxLoadedBenchmarkSize) @@ -35,18 +32,22 @@ BenchmarkFactory::BenchmarkFactory(const boost::filesystem::path& workingDirecto rand_(rand.has_value() ? *rand : std::mt19937_64(std::random_device()())), loadedBenchmarksSize_(0), maxLoadedBenchmarkSize_(maxLoadedBenchmarkSize) { - // Register all benchmarks from the site data directory. - if (fs::is_directory(kSiteBenchmarksDir)) { - CRASH_IF_ERROR(scanSiteDataDirectory()); - } else { - LOG(INFO) << "LLVM site benchmark directory not found: " << kSiteBenchmarksDir.string(); + VLOG(2) << "BenchmarkFactory initialized"; +} + +Status BenchmarkFactory::getBenchmark(const std::string& uri, + std::unique_ptr* benchmark) { + // Check if the benchmark has already been loaded into memory. + auto loaded = benchmarks_.find(uri); + if (loaded != benchmarks_.end()) { + *benchmark = loaded->second.clone(workingDirectory_); + return Status::OK; } - VLOG(2) << "BenchmarkFactory initialized with " << numBenchmarks() << " benchmarks"; + return Status(StatusCode::NOT_FOUND, "Benchmark not found"); } -Status BenchmarkFactory::addBitcode(const std::string& uri, const Bitcode& bitcode, - std::optional bitcodePath) { +Status BenchmarkFactory::addBitcode(const std::string& uri, const Bitcode& bitcode) { Status status; std::unique_ptr context = std::make_unique(); std::unique_ptr module = makeModule(*context, bitcode, uri, &status); @@ -59,34 +60,17 @@ Status BenchmarkFactory::addBitcode(const std::string& uri, const Bitcode& bitco << " exceeds maximum in-memory cache capacity " << maxLoadedBenchmarkSize_ << ", " << benchmarks_.size() << " bitcodes"; int evicted = 0; - // Evict benchmarks until we have reduced capacity below 50%. Use a - // bounded for loop to prevent infinite loop if we get "unlucky" and - // have no valid candidates to unload. + // Evict benchmarks until we have reduced capacity below 50%. const size_t targetCapacity = maxLoadedBenchmarkSize_ / 2; - for (size_t i = 0; i < benchmarks_.size() * 2; ++i) { - // We have run out of benchmarks to evict, or have freed up - // enough capacity. - if (!benchmarks_.size() || loadedBenchmarksSize_ < targetCapacity) { - break; - } - + while (benchmarks_.size() && loadedBenchmarksSize_ > targetCapacity) { // Select a cached benchmark randomly. std::uniform_int_distribution distribution(0, benchmarks_.size() - 1); size_t index = distribution(rand_); auto iterator = std::next(std::begin(benchmarks_), index); - // Check that the benchmark has an on-disk bitcode file which - // can be loaded to re-cache this bitcode. If not, we cannot - // evict it. - if (!iterator->second.bitcodePath().has_value()) { - continue; - } - - // Evict the benchmark: add it to the pool of unloaded benchmarks and - // delete it from the pool of loaded benchmarks. + // Evict the benchmark from the pool of loaded benchmarks. ++evicted; loadedBenchmarksSize_ -= iterator->second.bitcodeSize(); - unloadedBitcodePaths_.insert({iterator->first, *iterator->second.bitcodePath()}); benchmarks_.erase(iterator); } @@ -94,241 +78,22 @@ Status BenchmarkFactory::addBitcode(const std::string& uri, const Bitcode& bitco << loadedBenchmarksSize_ << ", " << benchmarks_.size() << " bitcodes"; } + BaselineCosts baselineCosts; + RETURN_IF_ERROR(setBaselineCosts(*module, &baselineCosts, workingDirectory_)); + benchmarks_.insert({uri, Benchmark(uri, std::move(context), std::move(module), bitcodeSize, - workingDirectory_, bitcodePath)}); + workingDirectory_, baselineCosts)}); loadedBenchmarksSize_ += bitcodeSize; return Status::OK; } -Status BenchmarkFactory::addBitcodeFile(const std::string& uri, - const boost::filesystem::path& path) { - if (!fs::exists(path)) { - return Status(StatusCode::NOT_FOUND, fmt::format("File not found: \"{}\"", path.string())); - } - unloadedBitcodePaths_[uri] = path; - return Status::OK; -} - -Status BenchmarkFactory::addBitcodeUriAlias(const std::string& src, const std::string& dst) { - // TODO(github.com/facebookresearch/CompilerGym/issues/2): Add support - // for additional protocols, e.g. http://. - if (dst.rfind("file:////", 0) != 0) { - return Status(StatusCode::INVALID_ARGUMENT, - fmt::format("Unsupported benchmark URI protocol: \"{}\"", dst)); - } - - // Resolve path from file:/// protocol URI. - const boost::filesystem::path path{dst.substr(util::strLen("file:///"))}; - return addBitcodeFile(src, path); -} - -namespace { - -bool endsWith(const std::string& str, const std::string& suffix) { - return str.size() >= suffix.size() && - str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0; -} - -} // anonymous namespace - -Status BenchmarkFactory::addDirectoryOfBitcodes(const boost::filesystem::path& root) { - VLOG(3) << "addDirectoryOfBitcodes(" << root.string() << ")"; - if (!fs::is_directory(root)) { - return Status(StatusCode::INVALID_ARGUMENT, - fmt::format("Directory not found: \"{}\"", root.string())); - } - - // Check if there is a manifest file that we can read, rather than having to - // enumerate the directory ourselves. - const auto manifestPath = fs::path(root.string() + ".MANIFEST"); - if (fs::is_regular_file(manifestPath)) { - VLOG(3) << "Reading manifest file: " << manifestPath; - return addDirectoryOfBitcodes(root, manifestPath); - } - - const auto rootPathSize = root.string().size(); - for (auto it : fs::recursive_directory_iterator(root, fs::symlink_option::recurse)) { - if (!fs::is_regular_file(it)) { - continue; - } - const std::string& path = it.path().string(); - - if (!endsWith(path, kExpectedExtension)) { - continue; - } - - // The name of the benchmark is path, relative to the root, without the - // file extension. - const std::string name = - path.substr(rootPathSize + 1, path.size() - rootPathSize - kExpectedExtension.size() - 1); - const std::string uri = fmt::format("benchmark://{}", name); - - RETURN_IF_ERROR(addBitcodeFile(uri, path)); - } - - return Status::OK; -} - -Status BenchmarkFactory::addDirectoryOfBitcodes(const boost::filesystem::path& root, - const boost::filesystem::path& manifestPath) { - std::ifstream infile(manifestPath.string()); - std::string relPath; - while (std::getline(infile, relPath)) { - if (!endsWith(relPath, kExpectedExtension)) { - continue; - } - - const fs::path path = root / relPath; - const std::string name = relPath.substr(0, relPath.size() - kExpectedExtension.size()); - const std::string uri = fmt::format("benchmark://{}", name); - - RETURN_IF_ERROR(addBitcodeFile(uri, path)); - } - - return Status::OK; -} - -Status BenchmarkFactory::getBenchmark(std::unique_ptr* benchmark) { - if (!benchmarks_.size() && !unloadedBitcodePaths_.size()) { - return Status(StatusCode::NOT_FOUND, - fmt::format("No benchmarks registered. Site data directory: `{}`", - kSiteBenchmarksDir.string())); - } - - const size_t unloadedBenchmarkCount = unloadedBitcodePaths_.size(); - const size_t loadedBenchmarkCount = benchmarks_.size(); - - const size_t benchmarkCount = unloadedBenchmarkCount + loadedBenchmarkCount; - - std::uniform_int_distribution distribution(0, benchmarkCount - 1); - size_t index = distribution(rand_); - - if (index < unloadedBenchmarkCount) { - // Select a random unloaded benchmark to load and move to the loaded - // benchmark collection. - auto unloadedBenchmark = std::next(std::begin(unloadedBitcodePaths_), index); - CHECK(unloadedBenchmark != unloadedBitcodePaths_.end()); - RETURN_IF_ERROR(loadBenchmark(unloadedBenchmark, benchmark)); - } else { - auto loadedBenchmark = std::next(std::begin(benchmarks_), index - unloadedBenchmarkCount); - CHECK(loadedBenchmark != benchmarks_.end()); - *benchmark = loadedBenchmark->second.clone(workingDirectory_); - } - - return Status::OK; -} - -Status BenchmarkFactory::getBenchmark(const std::string& uri, - std::unique_ptr* benchmark) { - std::string resolvedUri = uri; - // Prepend benchmark:// protocol if not specified. E.g. "foo/bar" resolves to - // "benchmark://foo/bar", but "file:///foo/bar" is not changed. - if (uri.find("://") == std::string::npos) { - resolvedUri = fmt::format("benchmark://{}", uri); - } - - auto loaded = benchmarks_.find(resolvedUri); - if (loaded != benchmarks_.end()) { - *benchmark = loaded->second.clone(workingDirectory_); - return Status::OK; - } - - auto unloaded = unloadedBitcodePaths_.find(resolvedUri); - if (unloaded != unloadedBitcodePaths_.end()) { - RETURN_IF_ERROR(loadBenchmark(unloaded, benchmark)); - return Status::OK; - } - - // No exact name match - attempt to match the URI prefix. - return getBenchmarkByUriPrefix(uri, resolvedUri, benchmark); -} - -Status BenchmarkFactory::getBenchmarkByUriPrefix(const std::string& uriPrefix, - const std::string& resolvedUriPrefix, - std::unique_ptr* benchmark) { - // Make a list of all of the known benchmarks which match this prefix. - std::vector candidateBenchmarks; - for (const auto& it : unloadedBitcodePaths_) { - const std::string& uri = it.first; - if (uri.rfind(resolvedUriPrefix, 0) == 0) { - candidateBenchmarks.push_back(uri.c_str()); - } - } - for (const auto& it : benchmarks_) { - const std::string& uri = it.first; - if (uri.rfind(resolvedUriPrefix, 0) == 0) { - candidateBenchmarks.push_back(uri.c_str()); - } - } - - const size_t candidatesCount = candidateBenchmarks.size(); - if (!candidatesCount) { - return Status(StatusCode::INVALID_ARGUMENT, fmt::format("Unknown benchmark \"{}\"", uriPrefix)); - } - - // Select randomly from the list of candidates. - std::uniform_int_distribution distribution(0, candidatesCount - 1); - size_t index = distribution(rand_); - return getBenchmark(candidateBenchmarks[index], benchmark); -} - -std::vector BenchmarkFactory::getBenchmarkNames() const { - std::vector names; - names.reserve(unloadedBitcodePaths_.size() + benchmarks_.size()); - for (const auto& it : unloadedBitcodePaths_) { - names.push_back(it.first); - } - for (const auto& it : benchmarks_) { - names.push_back(it.first); - } - return names; -} - -Status BenchmarkFactory::loadBenchmark( - std::unordered_map::const_iterator iterator, - std::unique_ptr* benchmark) { - const std::string uri = iterator->first; - const char* path = iterator->second.string().c_str(); - - VLOG(2) << "loadBenchmark(" << path << ")"; +Status BenchmarkFactory::addBitcode(const std::string& uri, const fs::path& path) { + VLOG(2) << "addBitcode(" << path.string() << ")"; Bitcode bitcode; - std::ifstream ifs(path); - if (ifs.fail()) { - return Status(StatusCode::NOT_FOUND, fmt::format("File not found: \"{}\"", path)); - } - - ifs.seekg(0, std::ios::end); - if (ifs.fail()) { - return Status(StatusCode::NOT_FOUND, fmt::format("Error reading file: \"{}\"", path)); - } - - std::streampos fileSize = ifs.tellg(); - if (!fileSize) { - return Status(StatusCode::INVALID_ARGUMENT, fmt::format("File is empty: \"{}\"", path)); - } - - bitcode.resize(fileSize); - ifs.seekg(0); - ifs.read(&bitcode[0], bitcode.size()); - if (ifs.fail()) { - return Status(StatusCode::NOT_FOUND, fmt::format("Error reading file: \"{}\"", path)); - } - - RETURN_IF_ERROR(addBitcode(uri, bitcode, fs::path(path))); - - unloadedBitcodePaths_.erase(iterator); - *benchmark = benchmarks_.find(uri)->second.clone(workingDirectory_); - return Status::OK; -} - -size_t BenchmarkFactory::numBenchmarks() const { - return benchmarks_.size() + unloadedBitcodePaths_.size(); -} - -Status BenchmarkFactory::scanSiteDataDirectory() { - return addDirectoryOfBitcodes(kSiteBenchmarksDir); + RETURN_IF_ERROR(readBitcodeFile(path, &bitcode)); + return addBitcode(uri, bitcode); } } // namespace compiler_gym::llvm_service diff --git a/compiler_gym/envs/llvm/service/BenchmarkFactory.h b/compiler_gym/envs/llvm/service/BenchmarkFactory.h index 11ecf7148..8aef66dbd 100644 --- a/compiler_gym/envs/llvm/service/BenchmarkFactory.h +++ b/compiler_gym/envs/llvm/service/BenchmarkFactory.h @@ -31,10 +31,8 @@ constexpr size_t kMaxLoadedBenchmarkSize = 512 * 1024 * 1024; // sessions. Example usage: // // BenchmarkFactory factory; -// for (int i = 0; i < 10; ++i) { -// auto benchmark = factory.getBenchmark(); -// // ... do fun stuff -// } +// auto benchmark = factory.getBenchmark("file:////tmp/my_bitcode.bc"); +// // ... do fun stuff class BenchmarkFactory { public: // Construct a benchmark factory. rand is a random seed used to control the @@ -46,69 +44,16 @@ class BenchmarkFactory { std::optional rand = std::nullopt, size_t maxLoadedBenchmarkSize = kMaxLoadedBenchmarkSize); - // Add a new bitcode. bitcodePath is optional. If provided, it allows the - // newly added benchmark to be evicted from the in-memory cache. - [[nodiscard]] grpc::Status addBitcode( - const std::string& uri, const Bitcode& bitcode, - std::optional bitcodePath = std::nullopt); - - // Add a bitcode URI alias. For example, - // addBitcodeFile("benchmark://foo", "file:///tmp/foo.bc") - // adds a new benchmark "benchmark://foo" which resolves to the path - // "/tmp/foo.bc". - [[nodiscard]] grpc::Status addBitcodeUriAlias(const std::string& src, const std::string& dst); - - // Add a directory of bitcode files. The format for added benchmark URIs is - // `benchmark://`, where relStem is the path of the file, relative - // to the root of the directory, without the file extension. - // - // Note that if any of the bitcodes are invalid, this error will be latent - // until a call to getBenchmark() attempts to load it. - [[nodiscard]] grpc::Status addDirectoryOfBitcodes(const boost::filesystem::path& path); - - // Get a random benchmark. - [[nodiscard]] grpc::Status getBenchmark(std::unique_ptr* benchmark); - // Get the requested named benchmark. [[nodiscard]] grpc::Status getBenchmark(const std::string& uri, std::unique_ptr* benchmark); - // Enumerate the list of available benchmark names that can be - // passed to getBenchmark(). - [[nodiscard]] std::vector getBenchmarkNames() const; - - // Scan the site data directory for new files. This is used to indicate that - // the directory has changed. - [[nodiscard]] grpc::Status scanSiteDataDirectory(); + [[nodiscard]] grpc::Status addBitcode(const std::string& uri, const Bitcode& bitcode); - size_t numBenchmarks() const; - - // Register the path of a new bitcode file using the given URI. If the URI - // already exists, it is replaced. - [[nodiscard]] grpc::Status addBitcodeFile(const std::string& uri, - const boost::filesystem::path& path); + [[nodiscard]] grpc::Status addBitcode(const std::string& uri, + const boost::filesystem::path& path); private: - // Add a directory of bitcode files by reading a MANIFEST file. The manifest - // file must consist of a single relative path per line. - [[nodiscard]] grpc::Status addDirectoryOfBitcodes(const boost::filesystem::path& path, - const boost::filesystem::path& manifestPath); - - // Fetch a random benchmark matching a given URI prefix. - [[nodiscard]] grpc::Status getBenchmarkByUriPrefix(const std::string& uriPrefix, - const std::string& resolvedUriPrefix, - std::unique_ptr* benchmark); - - [[nodiscard]] grpc::Status loadBenchmark( - std::unordered_map::const_iterator iterator, - std::unique_ptr* benchmark); - - // A map from benchmark name to the path of a bitcode file. This is used to - // store the paths of benchmarks w - // hich have not yet been loaded into memory. - // Once loaded, they are removed from this map and replaced by an entry in - // benchmarks_. - std::unordered_map unloadedBitcodePaths_; // A mapping from URI to benchmarks which have been loaded into memory. std::unordered_map benchmarks_; diff --git a/compiler_gym/envs/llvm/service/Cost.cc b/compiler_gym/envs/llvm/service/Cost.cc index 390e8e673..54c785389 100644 --- a/compiler_gym/envs/llvm/service/Cost.cc +++ b/compiler_gym/envs/llvm/service/Cost.cc @@ -97,7 +97,8 @@ Status getTextSizeInBytes(llvm::Module& module, int64_t* value, const fs::path& if (clang.retcode()) { fs::remove(tmpFile); const std::string error(clangOutput.second.buf.begin(), clangOutput.second.buf.end()); - return Status(StatusCode::INTERNAL, error); + return Status(StatusCode::INVALID_ARGUMENT, + fmt::format("Failed to compute .text size cost.\nError from clang:\n{}", error)); } auto llvmSize = @@ -107,7 +108,9 @@ Status getTextSizeInBytes(llvm::Module& module, int64_t* value, const fs::path& fs::remove(tmpFile); if (llvmSize.retcode()) { const std::string error(sizeOutput.second.buf.begin(), sizeOutput.second.buf.end()); - return Status(StatusCode::INTERNAL, error); + return Status( + StatusCode::INVALID_ARGUMENT, + fmt::format("Failed to compute .text size cost.\nError from llvm-size:\n{}", error)); } // The output of llvm-size is in berkley format, e.g.: @@ -141,20 +144,22 @@ inline size_t getBaselineCostIndex(LlvmBaselinePolicy policy, LlvmCostFunction c } // anonymous namespace -double getCost(const LlvmCostFunction& cost, llvm::Module& module, - const fs::path& workingDirectory) { - switch (cost) { - case LlvmCostFunction::IR_INSTRUCTION_COUNT: - return static_cast(module.getInstructionCount()); +Status setCost(const LlvmCostFunction& costFunction, llvm::Module& module, + const fs::path& workingDirectory, double* cost) { + switch (costFunction) { + case LlvmCostFunction::IR_INSTRUCTION_COUNT: { + *cost = static_cast(module.getInstructionCount()); + break; + } case LlvmCostFunction::OBJECT_TEXT_SIZE_BYTES: { int64_t size; #ifdef COMPILER_GYM_EXPERIMENTAL_TEXT_SIZE_COST - const auto status = getTextSizeInBytes(module, &size, {"-c"}, workingDirectory); + RETURN_IF_ERROR(getTextSizeInBytes(module, &size, {"-c"}, workingDirectory)); #else - const auto status = getTextSizeInBytes(module, &size, workingDirectory); + RETURN_IF_ERROR(getTextSizeInBytes(module, &size, workingDirectory)); #endif - CHECK(status.ok()) << status.error_message(); - return static_cast(size); + *cost = static_cast(size); + break; } #ifdef COMPILER_GYM_EXPERIMENTAL_TEXT_SIZE_COST @@ -167,14 +172,15 @@ double getCost(const LlvmCostFunction& cost, llvm::Module& module, #endif case LlvmCostFunction::TEXT_SIZE_BYTES: { int64_t size; - const auto status = getTextSizeInBytes(module, &size, {SYSTEM_LIBRARIES}, workingDirectory); - CHECK(status.ok()) << status.error_message(); - return static_cast(size); + RETURN_IF_ERROR(getTextSizeInBytes(module, &size, {SYSTEM_LIBRARIES}, workingDirectory)); + *cost = static_cast(size); + break; } #endif + default: + UNREACHABLE(fmt::format("Unhandled cost function: {}", costFunction)); } - - UNREACHABLE("Unhandled cost"); + return Status::OK; } double getBaselineCost(const BaselineCosts& baselineCosts, LlvmBaselinePolicy policy, @@ -182,12 +188,12 @@ double getBaselineCost(const BaselineCosts& baselineCosts, LlvmBaselinePolicy po return baselineCosts[getBaselineCostIndex(policy, cost)]; } -void setbaselineCosts(const llvm::Module& unoptimizedModule, BaselineCosts* baselineCosts, - const fs::path& workingDirectory) { +Status setBaselineCosts(llvm::Module& unoptimizedModule, BaselineCosts* baselineCosts, + const fs::path& workingDirectory) { + llvm::Module* moduleO0 = &unoptimizedModule; + // Create a copy of the unoptimized module and apply the default set of LLVM // optimizations. - std::unique_ptr moduleO0 = llvm::CloneModule(unoptimizedModule); - std::unique_ptr moduleOz = llvm::CloneModule(unoptimizedModule); applyBaselineOptimizations(moduleOz.get(), /*optLevel=*/2, /*sizeLevel=*/2); @@ -199,7 +205,7 @@ void setbaselineCosts(const llvm::Module& unoptimizedModule, BaselineCosts* base llvm::Module* baselineModule{nullptr}; switch (policy) { case LlvmBaselinePolicy::O0: - baselineModule = moduleO0.get(); + baselineModule = moduleO0; break; case LlvmBaselinePolicy::O3: baselineModule = moduleO3.get(); @@ -207,16 +213,19 @@ void setbaselineCosts(const llvm::Module& unoptimizedModule, BaselineCosts* base case LlvmBaselinePolicy::Oz: baselineModule = moduleOz.get(); break; + default: + UNREACHABLE("Unknown baseline policy"); } DCHECK(baselineModule); // Compute and set the baseline costs. for (const auto cost : magic_enum::enum_values()) { const auto idx = getBaselineCostIndex(policy, cost); - const auto cc = getCost(cost, *baselineModule, workingDirectory); - (*baselineCosts)[idx] = cc; + RETURN_IF_ERROR(setCost(cost, *baselineModule, workingDirectory, &(*baselineCosts)[idx])); } } + + return Status::OK; } } // namespace compiler_gym::llvm_service diff --git a/compiler_gym/envs/llvm/service/Cost.h b/compiler_gym/envs/llvm/service/Cost.h index f6c60cffa..4b520cc97 100644 --- a/compiler_gym/envs/llvm/service/Cost.h +++ b/compiler_gym/envs/llvm/service/Cost.h @@ -4,6 +4,8 @@ // LICENSE file in the root directory of this source tree. #pragma once +#include + #include #include @@ -40,15 +42,18 @@ using PreviousCosts = std::array, numCosts>; // by returning a grpc::Status. // Compute the cost using a given cost function. A lower cost is better. -double getCost(const LlvmCostFunction& cost, llvm::Module& module, - const boost::filesystem::path& workingDirectory); +[[nodiscard]] grpc::Status setCost(const LlvmCostFunction& costFunction, llvm::Module& module, + const boost::filesystem::path& workingDirectory, double* cost); // Return a baseline cost. double getBaselineCost(const BaselineCosts& baselineCosts, LlvmBaselinePolicy policy, LlvmCostFunction cost); -// Compute the costs of baseline policies. -void setbaselineCosts(const llvm::Module& unoptimizedModule, BaselineCosts* baselineCosts, - const boost::filesystem::path& workingDirectory); +// Compute the costs of baseline policies. The unoptimizedModule parameter is +// unmodified, but is not const because various LLVM API calls require a mutable +// reference. +[[nodiscard]] grpc::Status setBaselineCosts(llvm::Module& unoptimizedModule, + BaselineCosts* baselineCosts, + const boost::filesystem::path& workingDirectory); } // namespace compiler_gym::llvm_service diff --git a/compiler_gym/envs/llvm/service/LlvmService.cc b/compiler_gym/envs/llvm/service/LlvmService.cc index 52f39d9fb..5627deb8b 100644 --- a/compiler_gym/envs/llvm/service/LlvmService.cc +++ b/compiler_gym/envs/llvm/service/LlvmService.cc @@ -14,6 +14,7 @@ #include "compiler_gym/service/proto/compiler_gym_service.pb.h" #include "compiler_gym/util/EnumUtil.h" #include "compiler_gym/util/GrpcStatusMacros.h" +#include "compiler_gym/util/StrLenConstexpr.h" #include "compiler_gym/util/Version.h" #include "llvm/ADT/Triple.h" #include "llvm/Config/llvm-config.h" @@ -53,13 +54,13 @@ Status LlvmService::StartSession(ServerContext* /* unused */, const StartSession StartSessionReply* reply) { const std::lock_guard lock(sessionsMutex_); - std::unique_ptr benchmark; - if (request->benchmark().size()) { - RETURN_IF_ERROR(benchmarkFactory_.getBenchmark(request->benchmark(), &benchmark)); - } else { - RETURN_IF_ERROR(benchmarkFactory_.getBenchmark(&benchmark)); + if (!request->benchmark().size()) { + return Status(StatusCode::INVALID_ARGUMENT, "No benchmark URI set for StartSession()"); } + std::unique_ptr benchmark; + RETURN_IF_ERROR(benchmarkFactory_.getBenchmark(request->benchmark(), &benchmark)); + reply->set_benchmark(benchmark->name()); VLOG(1) << "StartSession(" << benchmark->name() << "), [" << nextSessionId_ << "]"; @@ -148,19 +149,23 @@ Status LlvmService::addBenchmark(const ::compiler_gym::Benchmark& request) { return Status(StatusCode::INVALID_ARGUMENT, "Benchmark must have a URI"); } - if (uri == "service://scan-site-data") { - return benchmarkFactory_.scanSiteDataDirectory(); - } - const auto& programFile = request.program(); switch (programFile.data_case()) { case ::compiler_gym::File::DataCase::kContents: - RETURN_IF_ERROR(benchmarkFactory_.addBitcode( - uri, llvm::SmallString<0>(programFile.contents().begin(), programFile.contents().end()))); - break; - case ::compiler_gym::File::DataCase::kUri: - RETURN_IF_ERROR(benchmarkFactory_.addBitcodeUriAlias(uri, programFile.uri())); - break; + return benchmarkFactory_.addBitcode( + uri, llvm::SmallString<0>(programFile.contents().begin(), programFile.contents().end())); + case ::compiler_gym::File::DataCase::kUri: { + // Check that protocol of the benmchmark URI. + if (programFile.uri().find("file:///") != 0) { + return Status(StatusCode::INVALID_ARGUMENT, + fmt::format("Invalid benchmark data URI. " + "Only the file:/// protocol is supported: \"{}\"", + programFile.uri())); + } + + const fs::path path(programFile.uri().substr(util::strLen("file:///"), std::string::npos)); + return benchmarkFactory_.addBitcode(uri, path); + } case ::compiler_gym::File::DataCase::DATA_NOT_SET: return Status(StatusCode::INVALID_ARGUMENT, "No program set"); } @@ -168,16 +173,6 @@ Status LlvmService::addBenchmark(const ::compiler_gym::Benchmark& request) { return Status::OK; } -Status LlvmService::GetBenchmarks(ServerContext* /* unused */, - const GetBenchmarksRequest* /* unused */, - GetBenchmarksReply* reply) { - for (const auto& benchmark : benchmarkFactory_.getBenchmarkNames()) { - reply->add_benchmark(benchmark); - } - - return Status::OK; -} - Status LlvmService::session(uint64_t id, LlvmSession** environment) { auto it = sessions_.find(id); if (it == sessions_.end()) { diff --git a/compiler_gym/envs/llvm/service/LlvmService.h b/compiler_gym/envs/llvm/service/LlvmService.h index 3f85a438b..4e321e1f9 100644 --- a/compiler_gym/envs/llvm/service/LlvmService.h +++ b/compiler_gym/envs/llvm/service/LlvmService.h @@ -48,9 +48,6 @@ class LlvmService final : public CompilerGymService::Service { grpc::Status AddBenchmark(grpc::ServerContext* context, const AddBenchmarkRequest* request, AddBenchmarkReply* reply) final override; - grpc::Status GetBenchmarks(grpc::ServerContext* context, const GetBenchmarksRequest* request, - GetBenchmarksReply* reply) final override; - protected: grpc::Status session(uint64_t id, LlvmSession** environment); grpc::Status session(uint64_t id, const LlvmSession** environment) const; diff --git a/compiler_gym/envs/llvm/service/LlvmSession.cc b/compiler_gym/envs/llvm/service/LlvmSession.cc index d1325894c..5a1c281f3 100644 --- a/compiler_gym/envs/llvm/service/LlvmSession.cc +++ b/compiler_gym/envs/llvm/service/LlvmSession.cc @@ -331,8 +331,9 @@ Status LlvmSession::getObservation(LlvmObservationSpace space, Observation* repl break; } case LlvmObservationSpace::IR_INSTRUCTION_COUNT: { - const auto cost = - getCost(LlvmCostFunction::IR_INSTRUCTION_COUNT, benchmark().module(), workingDirectory_); + double cost; + RETURN_IF_ERROR(setCost(LlvmCostFunction::IR_INSTRUCTION_COUNT, benchmark().module(), + workingDirectory_, &cost)); reply->set_scalar_int64(static_cast(cost)); break; } @@ -355,8 +356,9 @@ Status LlvmSession::getObservation(LlvmObservationSpace space, Observation* repl break; } case LlvmObservationSpace::OBJECT_TEXT_SIZE_BYTES: { - const auto cost = getCost(LlvmCostFunction::OBJECT_TEXT_SIZE_BYTES, benchmark().module(), - workingDirectory_); + double cost; + RETURN_IF_ERROR(setCost(LlvmCostFunction::OBJECT_TEXT_SIZE_BYTES, benchmark().module(), + workingDirectory_, &cost)); reply->set_scalar_int64(static_cast(cost)); break; } @@ -380,8 +382,9 @@ Status LlvmSession::getObservation(LlvmObservationSpace space, Observation* repl } #ifdef COMPILER_GYM_EXPERIMENTAL_TEXT_SIZE_COST case LlvmObservationSpace::TEXT_SIZE_BYTES: { - const auto cost = - getCost(LlvmCostFunction::TEXT_SIZE_BYTES, benchmark().module(), workingDirectory_); + double cost; + RETURN_IF_ERROR(setCost(LlvmCostFunction::TEXT_SIZE_BYTES, benchmark().module(), + workingDirectory_, &cost)); reply->set_scalar_int64(static_cast(cost)); break; } diff --git a/compiler_gym/leaderboard/llvm_instcount.py b/compiler_gym/leaderboard/llvm_instcount.py index 638fe129a..3da104727 100644 --- a/compiler_gym/leaderboard/llvm_instcount.py +++ b/compiler_gym/leaderboard/llvm_instcount.py @@ -28,6 +28,7 @@ automatically evaluate their agent on the test set. """ import logging +from itertools import islice from pathlib import Path from threading import Thread from time import sleep @@ -64,7 +65,7 @@ flags.DEFINE_integer( "n", 10, "The number of repetitions of the search to run for each benchmark." ) -flags.DEFINE_string("test_dataset", "cBench-v1", "The dataset to use for the search.") +flags.DEFINE_string("test_dataset", "cbench-v1", "The dataset to use for the search.") flags.DEFINE_boolean("validate", True, "Run validation on the results.") flags.DEFINE_boolean( "resume", @@ -106,7 +107,7 @@ def run(self): # Sanity check that the policy didn't change the expected # experimental setup. assert self.env.in_episode, "Environment is no longer in an episode" - assert ( + assert self.env.benchmark and ( self.env.benchmark == benchmark ), "Policy changed environment benchmark" assert self.env.reward_space, "Policy unset environment reward space" @@ -225,12 +226,11 @@ def main(argv): print(f"Writing logs to {FLAGS.leaderboard_logfile}") try: - # Install the required dataset and build the list of benchmarks to - # evaluate. - env.require_dataset(FLAGS.test_dataset) - benchmarks = sorted([b for b in env.benchmarks if FLAGS.test_dataset in b]) + # Build the list of benchmarks to evaluate. + benchmarks = env.datasets[FLAGS.test_dataset].benchmark_uris() if FLAGS.max_benchmarks: - benchmarks = benchmarks[: FLAGS.max_benchmarks] + benchmarks = islice(benchmarks, FLAGS.max_benchmarks) + benchmarks = list(benchmarks) # Repeat the searches for the requested number of iterations. benchmarks *= FLAGS.n diff --git a/compiler_gym/random_search.py b/compiler_gym/random_search.py index bdc51f872..87c60d6de 100644 --- a/compiler_gym/random_search.py +++ b/compiler_gym/random_search.py @@ -121,10 +121,10 @@ def random_search( f"random_search() requires CompilerEnv. Called with: {type(env).__name__}" ) - benchmark_name = env.benchmark + benchmark_uri = env.benchmark.uri if not outdir: - sanitized_benchmark_name = "/".join(benchmark_name.split("/")[-2:]) - outdir = create_logging_dir(f"random/{sanitized_benchmark_name}") + sanitized_benchmark_uri = "/".join(benchmark_uri.split("/")[-2:]) + outdir = create_logging_dir(f"random/{sanitized_benchmark_uri}") outdir = Path(outdir) if not env.reward_space: @@ -145,7 +145,7 @@ def random_search( # Write a metadata file. metadata = { "env": env.spec.id if env.spec else "", - "benchmark": benchmark_name, + "benchmark": benchmark_uri, "reward": reward_space_name, "patience": patience, } diff --git a/compiler_gym/service/proto/__init__.py b/compiler_gym/service/proto/__init__.py index a7d22620f..2db9c7f91 100644 --- a/compiler_gym/service/proto/__init__.py +++ b/compiler_gym/service/proto/__init__.py @@ -13,8 +13,6 @@ File, ForkSessionReply, ForkSessionRequest, - GetBenchmarksReply, - GetBenchmarksRequest, GetSpacesReply, GetSpacesRequest, GetVersionReply, @@ -50,8 +48,6 @@ "File", "ForkSessionReply", "ForkSessionRequest", - "GetBenchmarksReply", - "GetBenchmarksRequest", "GetSpacesReply", "GetSpacesRequest", "GetVersionReply", diff --git a/compiler_gym/service/proto/compiler_gym_service.proto b/compiler_gym/service/proto/compiler_gym_service.proto index cbeb0ec2e..7916af741 100644 --- a/compiler_gym/service/proto/compiler_gym_service.proto +++ b/compiler_gym/service/proto/compiler_gym_service.proto @@ -23,7 +23,8 @@ service CompilerGymService { rpc GetSpaces(GetSpacesRequest) returns (GetSpacesReply); // Start a new CompilerGym service session. This allocates a new session on // the service and returns a session ID. To terminate the session, call - // EndSession() once done. + // EndSession() once done. Raises grpc::StatusCode::NOT_FOUND if the requested + // benchmark URI is not found. rpc StartSession(StartSessionRequest) returns (StartSessionReply); // Fork a session. This creates a new session in exactly the same state. The // new session must be terminated with EndSession() once done. This returns @@ -38,12 +39,6 @@ service CompilerGymService { // are queried using GetSpaces(). This returns an error if the requested // session does not exist. rpc Step(StepRequest) returns (StepReply); - // Enumerate the list of available benchmarks. - // - // DEPRECATED(https://github.com/facebookresearch/CompilerGym/issues/45): The - // GetBenchmarks() operation is deprecated as of CompilerGym v0.1.4 and will - // be removed in CompilerGym v0.1.9. - rpc GetBenchmarks(GetBenchmarksRequest) returns (GetBenchmarksReply); // Register a new benchmark. rpc AddBenchmark(AddBenchmarkRequest) returns (AddBenchmarkReply); } @@ -252,16 +247,6 @@ message GetSpacesReply { repeated ObservationSpace observation_space_list = 2; } -// =========================================================================== -// GetBenchmarks(). - -message GetBenchmarksRequest {} - -message GetBenchmarksReply { - // A list of URIs of available benchmarks. - repeated string benchmark = 1; -} - // =========================================================================== // AddBenchmark(). diff --git a/compiler_gym/spaces/__init__.py b/compiler_gym/spaces/__init__.py index 6b06ba1a4..72dc9fc4f 100644 --- a/compiler_gym/spaces/__init__.py +++ b/compiler_gym/spaces/__init__.py @@ -9,11 +9,11 @@ from compiler_gym.spaces.sequence import Sequence __all__ = [ - "Commandline", - "CommandlineFlag", "DefaultRewardFromObservation", - "NamedDiscrete", - "Reward", "Scalar", "Sequence", + "NamedDiscrete", + "Commandline", + "CommandlineFlag", + "Reward", ] diff --git a/compiler_gym/spaces/reward.py b/compiler_gym/spaces/reward.py index 732701694..2518a3971 100644 --- a/compiler_gym/spaces/reward.py +++ b/compiler_gym/spaces/reward.py @@ -98,7 +98,10 @@ def reset(self, benchmark: str) -> None: pass def update( - self, action: int, observations: List[observation_t], observation_view + self, + action: int, + observations: List[observation_t], + observation_view: "compiler_gym.views.ObservationView", # noqa: F821 ) -> float: """Calculate a reward for the given action. diff --git a/compiler_gym/third_party/cBench/benchmarks.txt b/compiler_gym/third_party/cBench/benchmarks.txt deleted file mode 100644 index d39dbc09b..000000000 --- a/compiler_gym/third_party/cBench/benchmarks.txt +++ /dev/null @@ -1,23 +0,0 @@ -benchmark://cBench-v1/adpcm -benchmark://cBench-v1/bitcount -benchmark://cBench-v1/blowfish -benchmark://cBench-v1/bzip2 -benchmark://cBench-v1/crc32 -benchmark://cBench-v1/dijkstra -benchmark://cBench-v1/ghostscript -benchmark://cBench-v1/gsm -benchmark://cBench-v1/ispell -benchmark://cBench-v1/jpeg-c -benchmark://cBench-v1/jpeg-d -benchmark://cBench-v1/lame -benchmark://cBench-v1/patricia -benchmark://cBench-v1/qsort -benchmark://cBench-v1/rijndael -benchmark://cBench-v1/sha -benchmark://cBench-v1/stringsearch -benchmark://cBench-v1/stringsearch2 -benchmark://cBench-v1/susan -benchmark://cBench-v1/tiff2bw -benchmark://cBench-v1/tiff2rgba -benchmark://cBench-v1/tiffdither -benchmark://cBench-v1/tiffmedian diff --git a/compiler_gym/third_party/cBench/cBench-v1-linux.json b/compiler_gym/third_party/cBench/cBench-v1-linux.json deleted file mode 100644 index 2c551fd32..000000000 --- a/compiler_gym/third_party/cBench/cBench-v1-linux.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "compiler": "llvm-10.0.0", - "description": "https://github.com/ctuning/ctuning-programs", - "file_count": 23, - "license": "BSD 3-Clause", - "name": "cBench-v1", - "platforms": [ - "linux" - ], - "size_bytes": 10075608, - "url": "" -} diff --git a/compiler_gym/third_party/cBench/cBench-v1-macos.json b/compiler_gym/third_party/cBench/cBench-v1-macos.json deleted file mode 100644 index b016eb596..000000000 --- a/compiler_gym/third_party/cBench/cBench-v1-macos.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "compiler": "llvm-10.0.0", - "description": "https://github.com/ctuning/ctuning-programs", - "file_count": 23, - "license": "BSD 3-Clause", - "name": "cBench-v1", - "platforms": [ - "macos" - ], - "size_bytes": 10292032, - "url": "" -} diff --git a/compiler_gym/third_party/cBench/BUILD b/compiler_gym/third_party/cbench/BUILD similarity index 87% rename from compiler_gym/third_party/cBench/BUILD rename to compiler_gym/third_party/cbench/BUILD index 3e5331760..4b4aa2cb2 100644 --- a/compiler_gym/third_party/cBench/BUILD +++ b/compiler_gym/third_party/cbench/BUILD @@ -5,25 +5,15 @@ load("@rules_python//python:defs.bzl", "py_binary") genrule( - name = "cBench_tar", - srcs = [":cBench"] + select({ - "@llvm//:darwin": [ - "cBench-v1-macos.json", - ], - "//conditions:default": [ - "cBench-v1-linux.json", - ], - }), - outs = ["llvm_bitcodes-10.0.0-cBench-v1.tar.bz2"], - cmd = select({ - "@llvm//:darwin": "mv $(location cBench-v1-macos.json) $(@D)/cBench-v1.json", - "//conditions:default": "mv $(location cBench-v1-linux.json) $(@D)/cBench-v1.json", - }) + " && tar cjfh $@ -C $(@D) cBench-v1 cBench-v1.json", + name = "cbench_tar", + srcs = [":cbench"], + outs = ["llvm_bitcodes-10.0.0-cbench-v1.tar.bz2"], + cmd = "tar cjfh $@ -C $(@D) cbench-v1", visibility = ["//visibility:public"], ) filegroup( - name = "cBench", + name = "cbench", srcs = [ ":adpcm", ":bitcount", @@ -104,7 +94,7 @@ genrule( "@cBench//:all", "@cBench//:readme", ], - outs = ["cBench-v1/crc32.bc"], + outs = ["cbench-v1/crc32.bc"], cmd = "mkdir -p $(@D) && $(location :make_llvm_module) $$(dirname $(location @cBench//:readme))/telecom_CRC32 $@", tools = [":make_llvm_module"], visibility = ["//visibility:public"], @@ -116,7 +106,7 @@ genrule( "@ctuning-ai//:all", "@ctuning-ai//:readme", ], - outs = ["cBench-v1/jpeg-c.bc"], + outs = ["cbench-v1/jpeg-c.bc"], cmd = "mkdir -p $(@D) && $(location :make_llvm_module) $$(dirname $(location @ctuning-ai//:readme))/program/cbench-consumer-jpeg-c $@", tools = [ ":make_llvm_module", @@ -129,7 +119,7 @@ genrule( "@ctuning-ai//:all", "@ctuning-ai//:readme", ], - outs = ["cBench-v1/jpeg-d.bc"], + outs = ["cbench-v1/jpeg-d.bc"], cmd = "mkdir -p $(@D) && $(location :make_llvm_module) $$(dirname $(location @ctuning-ai//:readme))/program/cbench-consumer-jpeg-d $@", tools = [ ":make_llvm_module", @@ -142,7 +132,7 @@ genrule( "@ctuning-ai//:all", "@ctuning-ai//:readme", ], - outs = ["cBench-v1/stringsearch2.bc"], + outs = ["cbench-v1/stringsearch2.bc"], cmd = "mkdir -p $(@D) && $(location :make_llvm_module) $$(dirname $(location @ctuning-ai//:readme))/program/cbench-office-stringsearch2 $@", tools = [ ":make_llvm_module", @@ -155,7 +145,7 @@ genrule( "@cBench//:all", "@cBench//:readme", ], - outs = ["cBench-v1/adpcm.bc"], + outs = ["cbench-v1/adpcm.bc"], cmd = "mkdir -p $(@D) && $(location :make_llvm_module) $$(dirname $(location @cBench//:readme))/telecom_adpcm_c $@", tools = [":make_llvm_module"], visibility = ["//visibility:public"], @@ -167,7 +157,7 @@ genrule( "@cBench//:all", "@cBench//:readme", ], - outs = ["cBench-v1/bitcount.bc"], + outs = ["cbench-v1/bitcount.bc"], cmd = "mkdir -p $(@D) && $(location :make_llvm_module) $$(dirname $(location @cBench//:readme))/automotive_bitcount $@", tools = [":make_llvm_module"], ) @@ -178,7 +168,7 @@ genrule( "@cBench//:all", "@cBench//:readme", ], - outs = ["cBench-v1/blowfish.bc"], + outs = ["cbench-v1/blowfish.bc"], cmd = "mkdir -p $(@D) && $(location :make_llvm_module) $$(dirname $(location @cBench//:readme))/security_blowfish_d $@", tools = [":make_llvm_module"], ) @@ -189,7 +179,7 @@ genrule( "@cBench//:all", "@cBench//:readme", ], - outs = ["cBench-v1/bzip2.bc"], + outs = ["cbench-v1/bzip2.bc"], cmd = "mkdir -p $(@D) && $(location :make_llvm_module) $$(dirname $(location @cBench//:readme))/bzip2d $@", tools = [":make_llvm_module"], ) @@ -200,7 +190,7 @@ genrule( "@cBench//:all", "@cBench//:readme", ], - outs = ["cBench-v1/dijkstra.bc"], + outs = ["cbench-v1/dijkstra.bc"], cmd = "mkdir -p $(@D) && $(location :make_llvm_module) $$(dirname $(location @cBench//:readme))/network_dijkstra $@", tools = [":make_llvm_module"], ) @@ -213,7 +203,7 @@ genrule( "cBench-ghostscript-std.h.patch", "cBench-ghostscript-idebug.c.patch", ], - outs = ["cBench-v1/ghostscript.bc"], + outs = ["cbench-v1/ghostscript.bc"], cmd = ( "mkdir -p $(@D) && rsync -rL $$(dirname $(location @cBench//:readme))/office_ghostscript/ $(@D)/office_ghostscript_src/ &&" + "patch --quiet --forward $(@D)/office_ghostscript_src/src/idebug.c < $(location cBench-ghostscript-idebug.c.patch);" + @@ -230,7 +220,7 @@ genrule( "@cBench//:readme", "cBench-gsm-add.c.patch", ], - outs = ["cBench-v1/gsm.bc"], + outs = ["cbench-v1/gsm.bc"], cmd = ( "mkdir -p $(@D) &&rsync -rL $$(dirname $(location @cBench//:readme))/telecom_gsm/ $(@D)/telecom_gsm_src/ &&" + "patch --quiet --forward $(@D)/telecom_gsm_src/src/add.c < $(location cBench-gsm-add.c.patch);" + @@ -246,7 +236,7 @@ genrule( "@cBench//:readme", "cBench-ispell-correct.c.patch", ], - outs = ["cBench-v1/ispell.bc"], + outs = ["cbench-v1/ispell.bc"], cmd = ( "mkdir -p $(@D) &&rsync -rL $$(dirname $(location @cBench//:readme))/office_ispell/ $(@D)/office_ispell_src/ &&" + "patch --quiet --forward $(@D)/office_ispell_src/src/correct.c < $(location cBench-ispell-correct.c.patch);" + @@ -261,7 +251,7 @@ genrule( "@cBench//:all", "@cBench//:readme", ], - outs = ["cBench-v1/lame.bc"], + outs = ["cbench-v1/lame.bc"], cmd = "mkdir -p $(@D) && $(location :make_llvm_module) $$(dirname $(location @cBench//:readme))/consumer_lame $@ -DLAMESNDFILE -DHAVEMPGLIB -DLAMEPARSE", tools = [":make_llvm_module"], ) @@ -272,7 +262,7 @@ genrule( "@cBench//:all", "@cBench//:readme", ], - outs = ["cBench-v1/patricia.bc"], + outs = ["cbench-v1/patricia.bc"], cmd = ( "mkdir -p $(@D) && $(location :make_llvm_module) $$(dirname $(location @cBench//:readme))/network_patricia/ $@" ), @@ -285,7 +275,7 @@ genrule( "@cBench//:all", "@cBench//:readme", ], - outs = ["cBench-v1/qsort.bc"], + outs = ["cbench-v1/qsort.bc"], cmd = "mkdir -p $(@D) && $(location :make_llvm_module) $$(dirname $(location @cBench//:readme))/automotive_qsort1 $@", tools = [":make_llvm_module"], ) @@ -296,7 +286,7 @@ genrule( "@cBench//:all", "@cBench//:readme", ], - outs = ["cBench-v1/rijndael.bc"], + outs = ["cbench-v1/rijndael.bc"], cmd = "mkdir -p $(@D) && $(location :make_llvm_module) $$(dirname $(location @cBench//:readme))/security_rijndael_d $@", tools = [":make_llvm_module"], ) @@ -307,7 +297,7 @@ genrule( "@cBench//:all", "@cBench//:readme", ], - outs = ["cBench-v1/sha.bc"], + outs = ["cbench-v1/sha.bc"], cmd = "mkdir -p $(@D) && $(location :make_llvm_module) $$(dirname $(location @cBench//:readme))/security_sha $@", tools = [":make_llvm_module"], ) @@ -318,7 +308,7 @@ genrule( "@cBench//:all", "@cBench//:readme", ], - outs = ["cBench-v1/stringsearch.bc"], + outs = ["cbench-v1/stringsearch.bc"], cmd = "mkdir -p $(@D) && $(location :make_llvm_module) $$(dirname $(location @cBench//:readme))/office_stringsearch1 $@", tools = [":make_llvm_module"], ) @@ -329,7 +319,7 @@ genrule( "@cBench//:all", "@cBench//:readme", ], - outs = ["cBench-v1/susan.bc"], + outs = ["cbench-v1/susan.bc"], cmd = "mkdir -p $(@D) && $(location :make_llvm_module) $$(dirname $(location @cBench//:readme))/automotive_susan_c $@", tools = [":make_llvm_module"], ) @@ -340,7 +330,7 @@ genrule( "@cBench//:all", "@cBench//:readme", ], - outs = ["cBench-v1/tiff2bw.bc"], + outs = ["cbench-v1/tiff2bw.bc"], cmd = "mkdir -p $(@D) && $(location :make_llvm_module) $$(dirname $(location @cBench//:readme))/consumer_tiff2bw $@", tools = [":make_llvm_module"], ) @@ -351,7 +341,7 @@ genrule( "@cBench//:all", "@cBench//:readme", ], - outs = ["cBench-v1/tiff2rgba.bc"], + outs = ["cbench-v1/tiff2rgba.bc"], cmd = "mkdir -p $(@D) && $(location :make_llvm_module) $$(dirname $(location @cBench//:readme))/consumer_tiff2rgba $@", tools = [":make_llvm_module"], ) @@ -362,7 +352,7 @@ genrule( "@cBench//:all", "@cBench//:readme", ], - outs = ["cBench-v1/tiffdither.bc"], + outs = ["cbench-v1/tiffdither.bc"], cmd = "mkdir -p $(@D) && $(location :make_llvm_module) $$(dirname $(location @cBench//:readme))/consumer_tiffdither $@", tools = [":make_llvm_module"], ) @@ -373,7 +363,7 @@ genrule( "@cBench//:all", "@cBench//:readme", ], - outs = ["cBench-v1/tiffmedian.bc"], + outs = ["cbench-v1/tiffmedian.bc"], cmd = "mkdir -p $(@D) && $(location :make_llvm_module) $$(dirname $(location @cBench//:readme))/consumer_tiffmedian $@", tools = [":make_llvm_module"], visibility = ["//visibility:public"], diff --git a/compiler_gym/third_party/cBench/README-cBench-V1.1.txt b/compiler_gym/third_party/cbench/README-cBench-V1.1.txt similarity index 100% rename from compiler_gym/third_party/cBench/README-cBench-V1.1.txt rename to compiler_gym/third_party/cbench/README-cBench-V1.1.txt diff --git a/compiler_gym/third_party/cBench/README.txt b/compiler_gym/third_party/cbench/README.txt similarity index 100% rename from compiler_gym/third_party/cBench/README.txt rename to compiler_gym/third_party/cbench/README.txt diff --git a/compiler_gym/third_party/cbench/benchmarks.txt b/compiler_gym/third_party/cbench/benchmarks.txt new file mode 100644 index 000000000..060143288 --- /dev/null +++ b/compiler_gym/third_party/cbench/benchmarks.txt @@ -0,0 +1,23 @@ +benchmark://cbench-v1/adpcm +benchmark://cbench-v1/bitcount +benchmark://cbench-v1/blowfish +benchmark://cbench-v1/bzip2 +benchmark://cbench-v1/crc32 +benchmark://cbench-v1/dijkstra +benchmark://cbench-v1/ghostscript +benchmark://cbench-v1/gsm +benchmark://cbench-v1/ispell +benchmark://cbench-v1/jpeg-c +benchmark://cbench-v1/jpeg-d +benchmark://cbench-v1/lame +benchmark://cbench-v1/patricia +benchmark://cbench-v1/qsort +benchmark://cbench-v1/rijndael +benchmark://cbench-v1/sha +benchmark://cbench-v1/stringsearch +benchmark://cbench-v1/stringsearch2 +benchmark://cbench-v1/susan +benchmark://cbench-v1/tiff2bw +benchmark://cbench-v1/tiff2rgba +benchmark://cbench-v1/tiffdither +benchmark://cbench-v1/tiffmedian diff --git a/compiler_gym/third_party/cBench/cBench-ghostscript-idebug.c.patch b/compiler_gym/third_party/cbench/cBench-ghostscript-idebug.c.patch similarity index 100% rename from compiler_gym/third_party/cBench/cBench-ghostscript-idebug.c.patch rename to compiler_gym/third_party/cbench/cBench-ghostscript-idebug.c.patch diff --git a/compiler_gym/third_party/cBench/cBench-ghostscript-std.h.patch b/compiler_gym/third_party/cbench/cBench-ghostscript-std.h.patch similarity index 100% rename from compiler_gym/third_party/cBench/cBench-ghostscript-std.h.patch rename to compiler_gym/third_party/cbench/cBench-ghostscript-std.h.patch diff --git a/compiler_gym/third_party/cBench/cBench-gsm-add.c.patch b/compiler_gym/third_party/cbench/cBench-gsm-add.c.patch similarity index 100% rename from compiler_gym/third_party/cBench/cBench-gsm-add.c.patch rename to compiler_gym/third_party/cbench/cBench-gsm-add.c.patch diff --git a/compiler_gym/third_party/cBench/cBench-ispell-correct.c.patch b/compiler_gym/third_party/cbench/cBench-ispell-correct.c.patch similarity index 100% rename from compiler_gym/third_party/cBench/cBench-ispell-correct.c.patch rename to compiler_gym/third_party/cbench/cBench-ispell-correct.c.patch diff --git a/compiler_gym/third_party/cBench/make_llvm_module.py b/compiler_gym/third_party/cbench/make_llvm_module.py similarity index 100% rename from compiler_gym/third_party/cBench/make_llvm_module.py rename to compiler_gym/third_party/cbench/make_llvm_module.py diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/acctest.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/acctest.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/acctest.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/acctest.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/align.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/align.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/align.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/align.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/bdftops.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/bdftops.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/bdftops.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/bdftops.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/caption.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/caption.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/caption.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/caption.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/decrypt.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/decrypt.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/decrypt.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/decrypt.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/docie.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/docie.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/docie.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/docie.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/font2c.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/font2c.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/font2c.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/font2c.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_btokn.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_btokn.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_btokn.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_btokn.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_ccfnt.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_ccfnt.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_ccfnt.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_ccfnt.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_cff.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_cff.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_cff.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_cff.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_cidfn.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_cidfn.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_cidfn.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_cidfn.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_cmap.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_cmap.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_cmap.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_cmap.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_dbt_e.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_dbt_e.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_dbt_e.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_dbt_e.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_diskf.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_diskf.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_diskf.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_diskf.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_dpnxt.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_dpnxt.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_dpnxt.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_dpnxt.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_dps1.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_dps1.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_dps1.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_dps1.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_dps2.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_dps2.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_dps2.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_dps2.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_epsf.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_epsf.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_epsf.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_epsf.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_fonts.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_fonts.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_fonts.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_fonts.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_init.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_init.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_init.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_init.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_iso_e.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_iso_e.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_iso_e.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_iso_e.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_kanji.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_kanji.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_kanji.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_kanji.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_ksb_e.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_ksb_e.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_ksb_e.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_ksb_e.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_l2img.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_l2img.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_l2img.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_l2img.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_lev2.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_lev2.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_lev2.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_lev2.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_mex_e.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_mex_e.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_mex_e.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_mex_e.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_mro_e.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_mro_e.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_mro_e.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_mro_e.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_pdf.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_pdf.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_pdf.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_pdf.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_pdf_e.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_pdf_e.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_pdf_e.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_pdf_e.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_pdfwr.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_pdfwr.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_pdfwr.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_pdfwr.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_pfile.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_pfile.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_pfile.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_pfile.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_res.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_res.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_res.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_res.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_setpd.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_setpd.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_setpd.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_setpd.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_statd.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_statd.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_statd.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_statd.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_std_e.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_std_e.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_std_e.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_std_e.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_sym_e.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_sym_e.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_sym_e.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_sym_e.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_ttf.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_ttf.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_ttf.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_ttf.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_typ42.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_typ42.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_typ42.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_typ42.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_type1.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_type1.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_type1.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_type1.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_wan_e.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_wan_e.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gs_wan_e.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gs_wan_e.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/gslp.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/gslp.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/gslp.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/gslp.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/impath.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/impath.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/impath.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/impath.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/landscap.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/landscap.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/landscap.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/landscap.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/level1.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/level1.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/level1.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/level1.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/lines.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/lines.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/lines.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/lines.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/markhint.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/markhint.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/markhint.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/markhint.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/markpath.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/markpath.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/markpath.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/markpath.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/packfile.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/packfile.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/packfile.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/packfile.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/pcharstr.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/pcharstr.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/pcharstr.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/pcharstr.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/pdf2dsc.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/pdf2dsc.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/pdf2dsc.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/pdf2dsc.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/pdf_2ps.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/pdf_2ps.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/pdf_2ps.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/pdf_2ps.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/pdf_base.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/pdf_base.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/pdf_base.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/pdf_base.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/pdf_draw.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/pdf_draw.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/pdf_draw.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/pdf_draw.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/pdf_font.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/pdf_font.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/pdf_font.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/pdf_font.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/pdf_main.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/pdf_main.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/pdf_main.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/pdf_main.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/pdf_sec.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/pdf_sec.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/pdf_sec.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/pdf_sec.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/pfbtogs.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/pfbtogs.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/pfbtogs.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/pfbtogs.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/ppath.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/ppath.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/ppath.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/ppath.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/prfont.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/prfont.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/prfont.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/prfont.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/printafm.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/printafm.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/printafm.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/printafm.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/ps2ai.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/ps2ai.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/ps2ai.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/ps2ai.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/ps2ascii.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/ps2ascii.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/ps2ascii.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/ps2ascii.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/ps2epsi.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/ps2epsi.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/ps2epsi.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/ps2epsi.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/ps2image.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/ps2image.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/ps2image.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/ps2image.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/quit.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/quit.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/quit.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/quit.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/showchar.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/showchar.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/showchar.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/showchar.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/showpage.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/showpage.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/showpage.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/showpage.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/stcinfo.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/stcinfo.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/stcinfo.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/stcinfo.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/stcolor.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/stcolor.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/stcolor.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/stcolor.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/traceimg.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/traceimg.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/traceimg.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/traceimg.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/traceop.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/traceop.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/traceop.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/traceop.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/type1enc.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/type1enc.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/type1enc.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/type1enc.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/type1ops.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/type1ops.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/type1ops.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/type1ops.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/uninfo.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/uninfo.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/uninfo.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/uninfo.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/unprot.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/unprot.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/unprot.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/unprot.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/viewcmyk.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/viewcmyk.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/viewcmyk.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/viewcmyk.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/viewgif.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/viewgif.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/viewgif.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/viewgif.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/viewjpeg.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/viewjpeg.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/viewjpeg.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/viewjpeg.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/viewpbm.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/viewpbm.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/viewpbm.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/viewpbm.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/viewpcx.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/viewpcx.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/viewpcx.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/viewpcx.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/viewps2a.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/viewps2a.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/viewps2a.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/viewps2a.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/wftopfa.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/wftopfa.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/wftopfa.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/wftopfa.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/winmaps.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/winmaps.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/winmaps.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/winmaps.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/wrfont.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/wrfont.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/wrfont.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/wrfont.ps diff --git a/compiler_gym/third_party/cBench/runtime_data/ghostscript/zeroline.ps b/compiler_gym/third_party/cbench/runtime_data/ghostscript/zeroline.ps similarity index 100% rename from compiler_gym/third_party/cBench/runtime_data/ghostscript/zeroline.ps rename to compiler_gym/third_party/cbench/runtime_data/ghostscript/zeroline.ps diff --git a/compiler_gym/third_party/llvm/BUILD b/compiler_gym/third_party/llvm/BUILD index 29fd91f51..544aa9034 100644 --- a/compiler_gym/third_party/llvm/BUILD +++ b/compiler_gym/third_party/llvm/BUILD @@ -2,6 +2,7 @@ # # This source code is licensed under the MIT license found in the # LICENSE file in the root directory of this source tree. +load("@rules_python//python:defs.bzl", "py_library") py_library( name = "llvm", diff --git a/compiler_gym/util/minimize_trajectory.py b/compiler_gym/util/minimize_trajectory.py index 2c8dcf620..face9be21 100644 --- a/compiler_gym/util/minimize_trajectory.py +++ b/compiler_gym/util/minimize_trajectory.py @@ -15,7 +15,6 @@ from math import ceil, log from typing import Callable, Iterable -from compiler_gym.envs import CompilerEnv from compiler_gym.util.truncate import truncate @@ -25,10 +24,10 @@ class MinimizationError(OSError): # A hypothesis is a callback that accepts as input an enivornment in a given # state returns true if a particular hypothesis holds, else false. -Hypothesis = Callable[[CompilerEnv], bool] +Hypothesis = Callable[["CompilerEnv"], bool] # noqa: F821 -def environment_validation_fails(env: CompilerEnv) -> bool: +def environment_validation_fails(env: "CompilerEnv") -> bool: # noqa: F821 """A hypothesis that holds true if environment validation fails.""" validation_result = env.validate() logging.debug(truncate(str(validation_result), max_lines=1, max_line_len=120)) @@ -52,11 +51,11 @@ def _apply_and_test(env, actions, hypothesis, flakiness) -> bool: def bisect_trajectory( - env: CompilerEnv, + env: "CompilerEnv", # noqa: F821 hypothesis: Hypothesis = environment_validation_fails, reverse: bool = False, flakiness: int = 1, -) -> Iterable[CompilerEnv]: +) -> Iterable["CompilerEnv"]: # noqa: F821 """Run a binary search to remove the suffix or prefix of a trjectory. Requires worst-case O(log n) evaluation rounds, where n is the length of the @@ -152,14 +151,14 @@ def apply_and_test(actions): def random_minimization( - env: CompilerEnv, + env: "CompilerEnv", # noqa: F821 hypothesis: Hypothesis = environment_validation_fails, num_steps_ratio_multiplier: float = 5, init_discard_ratio: float = 0.75, discard_ratio_decay: float = 0.75, min_trajectory_len: int = 5, flakiness: int = 1, -) -> Iterable[CompilerEnv]: +) -> Iterable["CompilerEnv"]: # noqa: F821 """Run an iterative process of randomly removing actions to minimize a trajectory. @@ -245,10 +244,10 @@ def apply_and_test(actions): def minimize_trajectory_iteratively( - env: CompilerEnv, + env: "CompilerEnv", # noqa: F821 hypothesis: Hypothesis = environment_validation_fails, flakiness: int = 1, -) -> Iterable[CompilerEnv]: +) -> Iterable["CompilerEnv"]: # noqa: F821 """Minimize a trajectory by remove actions, one at a time, until a minimal trajectory is reached. diff --git a/compiler_gym/validate.py b/compiler_gym/validate.py index 45728e877..9a8ed5b8d 100644 --- a/compiler_gym/validate.py +++ b/compiler_gym/validate.py @@ -5,7 +5,7 @@ """Validate environment states.""" import random from concurrent.futures import as_completed -from typing import Callable, Iterable, List, Optional +from typing import Callable, Iterable, Optional from compiler_gym.compiler_env_state import CompilerEnvState from compiler_gym.envs.compiler_env import CompilerEnv @@ -27,7 +27,6 @@ def _validate_states_worker( def validate_states( make_env: Callable[[], CompilerEnv], states: Iterable[CompilerEnvState], - datasets: Optional[List[str]] = None, nproc: Optional[int] = None, inorder: bool = False, ) -> Iterable[ValidationResult]: @@ -37,21 +36,12 @@ def validate_states( :param make_env: A callback which instantiates a compiler environment. :param states: A sequence of compiler environment states to validate. - :param datasets: An optional list of datasets that are required. :param nproc: The number of parallel worker processes to run. :param inorder: Whether to return results in the order they were provided, or in the order that they are available. :return: An iterator over validation results. The order of results may differ from the input states. """ - # Ensure that the required datasets are available. - if datasets: - env = make_env() - try: - env.require_datasets(datasets) - finally: - env.close() - executor = thread_pool.get_thread_pool_executor() if nproc == 1: diff --git a/compiler_gym/views/BUILD b/compiler_gym/views/BUILD index d27c5b92e..a92311bb1 100644 --- a/compiler_gym/views/BUILD +++ b/compiler_gym/views/BUILD @@ -40,6 +40,7 @@ py_library( visibility = ["//compiler_gym:__subpackages__"], deps = [ ":observation", + "//compiler_gym/datasets", "//compiler_gym/service", "//compiler_gym/service/proto", "//compiler_gym/spaces", diff --git a/compiler_gym/views/observation.py b/compiler_gym/views/observation.py index 7ae540362..c7de881b2 100644 --- a/compiler_gym/views/observation.py +++ b/compiler_gym/views/observation.py @@ -14,16 +14,16 @@ class ObservationView(object): Example usage: - >>> env = gym.make("llvm-v0") - >>> env.reset() - >>> env.observation.spaces.keys() - ["Autophase", "Ir"] - >>> env.observation.spaces["Autophase"].space - Box(56,) - >>> env.observation["Autophase"] - [0, 1, ..., 2] - >>> observation["Ir"] - int main() {...} + >>> env = gym.make("llvm-v0") + >>> env.reset() + >>> env.observation.spaces.keys() + ["Autophase", "Ir"] + >>> env.observation.spaces["Autophase"].space + Box(56,) + >>> env.observation["Autophase"] + [0, 1, ..., 2] + >>> observation["Ir"] + int main() {...} """ def __init__( @@ -45,8 +45,13 @@ def __getitem__(self, observation_space: str) -> observation_t: """Request an observation from the given space. :param observation_space: The observation space to query. + :return: An observation. + :raises KeyError: If the requested observation space does not exist. + + :raises SessionNotFound: If :meth:`env.reset() + ` has not been called. """ space = self.spaces[observation_space] request = StepRequest( @@ -75,26 +80,29 @@ def add_derived_space( base_id: str, **kwargs, ) -> None: - """Alias to - :func:`ObservationSpaceSpec.make_derived_space() ` - that adds the derived space to the observation view. + """Alias to :func:`ObservationSpaceSpec.make_derived_space() + ` that adds + the derived space to the observation view. Example usage: - >>> env.observation.add_derived_space( - id="src_len", - base_id="src", - translate=lambda src: np.array([len(src)], dtype=np.int32), - shape=Box(shape=(1,), dtype=np.int32), - ) - >>> env.observation["src_len"] - 1029 + >>> env.observation.add_derived_space( + id="src_len", + base_id="src", + translate=lambda src: np.array([len(src)], dtype=np.int32), + shape=Box(shape=(1,), dtype=np.int32), + ) + >>> env.observation["src_len"] + 1029 :param id: The name of the new observation space. + :param base_id: The name of the observation space that this is derived from. + :param \\**kwargs: Arguments passed to - :func:`ObservationSpaceSpec.make_derived_space `. + :func:`ObservationSpaceSpec.make_derived_space + `. """ base_space = self.spaces[base_id] self._add_space(base_space.make_derived_space(id=id, **kwargs)) diff --git a/compiler_gym/views/reward.py b/compiler_gym/views/reward.py index 2753f2d72..7f3f78c6f 100644 --- a/compiler_gym/views/reward.py +++ b/compiler_gym/views/reward.py @@ -5,6 +5,7 @@ import warnings from typing import Dict, List +from compiler_gym.datasets import Benchmark from compiler_gym.spaces.reward import Reward from compiler_gym.views.observation import ObservationView @@ -14,14 +15,15 @@ class RewardView(object): Example usage: - >>> env = gym.make("llvm-v0") - >>> env.reset() - >>> env.reward.spaces["codesize"].range - (-np.inf, 0) - >>> env.reward["codesize"] - -1243 + >>> env = gym.make("llvm-v0") + >>> env.reset() + >>> env.reward.spaces["codesize"].range + (-np.inf, 0) + >>> env.reward["codesize"] + -1243 :ivar spaces: Specifications of available reward spaces. + :vartype spaces: Dict[str, Reward] """ @@ -41,11 +43,16 @@ def __getitem__(self, reward_space: str) -> float: """Request an observation from the given space. :param reward_space: The reward space to query. + :return: A reward. + :raises KeyError: If the requested reward space does not exist. + + :raises SessionNotFound: If :meth:`env.reset() + ` has not been called. """ # TODO(cummins): Since reward is a function from (state, action) -> r - # it would be better to make the list of reward to evaluate an argument + # it would be better to make the list of rewards to evaluate an argument # to env.step() rather than using this lazy view. if not self.spaces: raise ValueError("No reward spaces") @@ -53,12 +60,11 @@ def __getitem__(self, reward_space: str) -> float: observations = [self._observation_view[obs] for obs in space.observation_spaces] return space.update(self.previous_action, observations, self._observation_view) - def reset(self, benchmark: str) -> None: + def reset(self, benchmark: Benchmark) -> None: """Reset the rewards space view. This is called on :meth:`env.reset() `. - :param benchmark: The URI of the benchmark that is used for this - episode. + :param benchmark: The benchmark that is used for this episode. """ self.previous_action = None for space in self.spaces.values(): diff --git a/docs/source/cli.rst b/docs/source/cli.rst index 5ee1f2dba..1e0b5893a 100644 --- a/docs/source/cli.rst +++ b/docs/source/cli.rst @@ -13,11 +13,6 @@ compiler_gym.bin.service .. automodule:: compiler_gym.bin.service -compiler_gym.bin.datasets -------------------------- - -.. automodule:: compiler_gym.bin.datasets - compiler_gym.bin.manual_env --------------------------- diff --git a/examples/RandomSearch.cc b/examples/RandomSearch.cc index 7202283b4..d07e3cda9 100644 --- a/examples/RandomSearch.cc +++ b/examples/RandomSearch.cc @@ -25,7 +25,7 @@ #include "compiler_gym/envs/llvm/service/ObservationSpaces.h" #include "compiler_gym/util/GrpcStatusMacros.h" -DEFINE_string(benchmark, "benchmark://cBench-v1/crc32", "The benchmark to use."); +DEFINE_string(benchmark, "benchmark://cbench-v1/crc32", "The benchmark to use."); DEFINE_int32(step_count, 100, "The number of steps to run for each random search"); DEFINE_int32(nproc, std::max(1u, std::thread::hardware_concurrency()), "The number of parallel search threads to use"); diff --git a/examples/actor_critic.py b/examples/actor_critic.py index cc09e22ac..8102755b3 100644 --- a/examples/actor_critic.py +++ b/examples/actor_critic.py @@ -58,7 +58,7 @@ "List of optimizatins to explore.", ) flags.DEFINE_string("reward", "IrInstructionCount", "The reward function to optimize.") -flags.DEFINE_string("benchmark", "cBench-v1/dijkstra", "Benchmark to optimize.") +flags.DEFINE_string("benchmark", "cbench-v1/dijkstra", "Benchmark to optimize.") flags.DEFINE_integer("episode_len", 5, "Number of transitions per episode.") flags.DEFINE_integer("hidden_size", 64, "Latent vector size.") flags.DEFINE_integer("episodes", 1000, "Number of episodes to run and train on.") @@ -119,7 +119,6 @@ class CustomEnv: def __init__(self): self._env = gym.make("llvm-v0", reward_space=FLAGS.reward) try: - self._env.require_dataset("cBench-v1") self._env.reset(benchmark=FLAGS.benchmark) # Project onto the subset of transformations that have diff --git a/examples/actor_critic_test.py b/examples/actor_critic_test.py index 8a11cb489..bc2407f13 100644 --- a/examples/actor_critic_test.py +++ b/examples/actor_critic_test.py @@ -21,7 +21,7 @@ def test_run_actor_critic_smoke_test(): "--episode_len=2", "--episodes=10", "--log_interval=5", - "--benchmark=cBench-v1/crc32", + "--benchmark=cbench-v1/crc32", ] ) with capture_output() as out: diff --git a/examples/brute_force.py b/examples/brute_force.py index 276346f5a..c967e81ca 100644 --- a/examples/brute_force.py +++ b/examples/brute_force.py @@ -10,10 +10,10 @@ Example usage: $ $ python -m compiler_gym.bin.brute_force \ - --env=llvm-ic-v0 --benchmark=cBench-v1/dijkstra \ + --env=llvm-ic-v0 --benchmark=cbench-v1/dijkstra \ --episode_length=10 --actions=-sroa,-mem2reg,-newgvn - Enumerating all episodes of 3 actions × 10 steps - Started 24 brute force workers for benchmark cBench-v1/dijkstra using reward IrInstructionCountOz. + Enumerating all episodes of 3 actions x 10 steps + Started 24 brute force workers for benchmark cbench-v1/dijkstra using reward IrInstructionCountOz. === Running 59,049 trials === Runtime: 3 minutes. Progress: 100.00%. Best reward found: 101.1905%. Ending jobs ... completed 59,049 of 59,049 trials (100.000%) @@ -84,11 +84,8 @@ def __init__( self.alive = True # Set this to False to signal the thread to stop. def run(self): - for i, chunk in enumerate( - grouper( - itertools.product(*[self.actions] * self.episode_length), self.chunksize - ), - start=1, + for chunk in grouper( + itertools.product(*[self.actions] * self.episode_length), self.chunksize ): if not self.alive: break @@ -108,13 +105,13 @@ class BruteForceWorker(Thread): def __init__( self, - id: int, + worker_id: int, in_q: Queue, out_q: Queue, env: CompilerEnv, ): super().__init__() - self.id = id + self.id = worker_id self.in_q = in_q self.out_q = out_q self.env = env @@ -185,12 +182,12 @@ def run_brute_force( reward_space_name = env.reward_space.id actions = [env.action_space.names.index(a) for a in action_names] - benchmark_name = env.benchmark + benchmark_uri = env.benchmark.uri meta = { "env": env.spec.id, "action_names": action_names, - "benchmark": benchmark_name, + "benchmark": benchmark_uri, "reward": reward_space_name, "init_reward": env.reward[reward_space_name], "episode_length": episode_length, @@ -220,7 +217,7 @@ def run_brute_force( # Worker threads that will consume the action sequences and produce rewards. workers = [ - BruteForceWorker(id=i, env=make_env(), in_q=in_q, out_q=out_q) + BruteForceWorker(worker_id=i, env=make_env(), in_q=in_q, out_q=out_q) for i in range(1, nproc + 1) ] for worker in workers: @@ -235,11 +232,11 @@ def run_brute_force( best_reward = -float("inf") best_action_sequence = [] print( - f"Enumerating all episodes of {len(actions)} actions × {episode_length} steps" + f"Enumerating all episodes of {len(actions)} actions x {episode_length} steps" ) print( f"Started {len(workers)} brute force workers for benchmark " - f"{benchmark_name} using reward {reward_space_name}." + f"{benchmark_uri} using reward {reward_space_name}." ) print(f"=== Running {humanize.intcomma(expected_trial_count)} trials ===") try: @@ -315,11 +312,10 @@ def main(argv): env = env_from_flags(benchmark) env.reset() benchmark = env.benchmark - sanitized_benchmark_name = "/".join(benchmark.split("/")[-2:]) + sanitized_benchmark_uri = "/".join(benchmark.split("/")[-2:]) env.close() logs_dir = Path( - FLAGS.output_dir - or create_logging_dir(f"brute_force/{sanitized_benchmark_name}") + FLAGS.output_dir or create_logging_dir(f"brute_force/{sanitized_benchmark_uri}") ) run_brute_force( diff --git a/examples/brute_force_test.py b/examples/brute_force_test.py index 0dfd1fb5f..7a559908e 100644 --- a/examples/brute_force_test.py +++ b/examples/brute_force_test.py @@ -16,7 +16,7 @@ def test_run_brute_force_smoke_test(): with tempfile.TemporaryDirectory() as tmp: outdir = Path(tmp) run_brute_force( - make_env=lambda: gym.make("llvm-ic-v0"), + make_env=lambda: gym.make("llvm-ic-v0", benchmark="cbench-v1/crc32"), action_names=["-sroa", "-mem2reg"], episode_length=2, outdir=outdir, @@ -29,4 +29,4 @@ def test_run_brute_force_smoke_test(): if __name__ == "__main__": - main() + main(extra_pytest_args=["-s"], debug_level=2) # Don't capture stdout/stderr. diff --git a/examples/example_compiler_gym_service/BUILD b/examples/example_compiler_gym_service/BUILD index 0f8600c86..f6cc2e193 100644 --- a/examples/example_compiler_gym_service/BUILD +++ b/examples/example_compiler_gym_service/BUILD @@ -11,6 +11,7 @@ py_library( "//examples/example_compiler_gym_service/service_cc:compiler_gym-example-service-cc", "//examples/example_compiler_gym_service/service_py:compiler_gym-example-service-py", ], + visibility = ["//visibility:public"], deps = [ "//compiler_gym/util", ], diff --git a/examples/example_compiler_gym_service/README.md b/examples/example_compiler_gym_service/README.md index 640d6f889..cade0209e 100644 --- a/examples/example_compiler_gym_service/README.md +++ b/examples/example_compiler_gym_service/README.md @@ -17,7 +17,8 @@ Features: * Enforces the service contract, e.g. `StartSession()` must be called before `EndSession()`, list indices must be in-bounds, etc. * Implements all of the RPC endpoints. -* It has two programs "foo" and "bar". +* It has a single dataset "benchmark://example-v0" with two programs "foo" and + "bar". * It has a static action space with three items: `["a", "b", "c"]`. The action space never changes. Actions never end the episode. * There are two observation spaces: diff --git a/examples/example_compiler_gym_service/__init__.py b/examples/example_compiler_gym_service/__init__.py index 991bf3bd8..f9c44bc34 100644 --- a/examples/example_compiler_gym_service/__init__.py +++ b/examples/example_compiler_gym_service/__init__.py @@ -3,9 +3,21 @@ # This source code is licensed under the MIT license found in the # LICENSE file in the root directory of this source tree. """This module demonstrates how to """ +from pathlib import Path +from typing import Iterable + +from compiler_gym.datasets import Benchmark, Dataset from compiler_gym.spaces import Reward from compiler_gym.util.registration import register -from compiler_gym.util.runfiles_path import runfiles_path +from compiler_gym.util.runfiles_path import runfiles_path, site_data_path + +EXAMPLE_CC_SERVICE_BINARY: Path = runfiles_path( + "examples/example_compiler_gym_service/service_cc/compiler_gym-example-service-cc" +) + +EXAMPLE_PY_SERVICE_BINARY: Path = runfiles_path( + "examples/example_compiler_gym_service/service_py/compiler_gym-example-service-py" +) class RuntimeReward(Reward): @@ -40,16 +52,42 @@ def update(self, action, observations, observation_view): return reward +class ExampleDataset(Dataset): + def __init__(self, *args, **kwargs): + super().__init__( + name="benchmark://example-v0", + license="MIT", + description="An example dataset", + site_data_base=site_data_path("example_dataset"), + ) + self._benchmarks = { + "benchmark://example-v0/foo": Benchmark.from_file_contents( + "benchmark://example-v0/foo", "Ir data".encode("utf-8") + ), + "benchmark://example-v0/bar": Benchmark.from_file_contents( + "benchmark://example-v0/bar", "Ir data".encode("utf-8") + ), + } + + def benchmark_uris(self) -> Iterable[str]: + yield from self._benchmarks.keys() + + def benchmark(self, uri: str) -> Benchmark: + if uri in self._benchmarks: + return self._benchmarks[uri] + else: + raise LookupError("Unknown program name") + + # Register the example service on module import. After importing this module, # the example-v0 environment will be available to gym.make(...). register( id="example-cc-v0", entry_point="compiler_gym.envs:CompilerEnv", kwargs={ - "service": runfiles_path( - "examples/example_compiler_gym_service/service_cc/compiler_gym-example-service-cc" - ), + "service": EXAMPLE_CC_SERVICE_BINARY, "rewards": [RuntimeReward()], + "datasets": [ExampleDataset()], }, ) @@ -57,9 +95,8 @@ def update(self, action, observations, observation_view): id="example-py-v0", entry_point="compiler_gym.envs:CompilerEnv", kwargs={ - "service": runfiles_path( - "examples/example_compiler_gym_service/service_py/compiler_gym-example-service-py" - ), + "service": EXAMPLE_PY_SERVICE_BINARY, "rewards": [RuntimeReward()], + "datasets": [ExampleDataset()], }, ) diff --git a/examples/example_compiler_gym_service/env_tests.py b/examples/example_compiler_gym_service/env_tests.py index ba0e713c5..6196ef4cf 100644 --- a/examples/example_compiler_gym_service/env_tests.py +++ b/examples/example_compiler_gym_service/env_tests.py @@ -86,8 +86,8 @@ def test_reward_before_reset(env: CompilerEnv): def test_reset_invalid_benchmark(env: CompilerEnv): """Test requesting a specific benchmark.""" - with pytest.raises(ValueError) as ctx: - env.reset(benchmark="foobar") + with pytest.raises(LookupError) as ctx: + env.reset(benchmark="example-v0/foobar") assert str(ctx.value) == "Unknown program name" @@ -167,7 +167,10 @@ def test_rewards(env: CompilerEnv): def test_benchmarks(env: CompilerEnv): - assert env.benchmarks == ["foo", "bar"] + assert list(env.datasets.benchmark_uris()) == [ + "benchmark://example-v0/foo", + "benchmark://example-v0/bar", + ] if __name__ == "__main__": diff --git a/examples/example_compiler_gym_service/service_cc/ExampleService.cc b/examples/example_compiler_gym_service/service_cc/ExampleService.cc index eff0d975d..876338102 100644 --- a/examples/example_compiler_gym_service/service_cc/ExampleService.cc +++ b/examples/example_compiler_gym_service/service_cc/ExampleService.cc @@ -29,7 +29,9 @@ template return Status::OK; } -std::vector getBenchmarks() { return {"foo", "bar"}; } +std::vector getBenchmarkUris() { + return {"benchmark://example-v0/foo", "benchmark://example-v0/bar"}; +} std::vector getActionSpaces() { ActionSpace space; @@ -97,7 +99,7 @@ Status ExampleService::StartSession(ServerContext* /* unused*/, const StartSessi // Determine the benchmark to use. std::string benchmark = request->benchmark(); - const auto benchmarks = getBenchmarks(); + const auto benchmarks = getBenchmarkUris(); if (!benchmark.empty() && std::find(benchmarks.begin(), benchmarks.end(), benchmark) == benchmarks.end()) { return Status(StatusCode::INVALID_ARGUMENT, "Unknown program name"); @@ -150,14 +152,6 @@ Status ExampleService::Step(ServerContext* /* unused*/, const StepRequest* reque return sess->Step(request, reply); } -Status ExampleService::GetBenchmarks(grpc::ServerContext* /*unused*/, - const GetBenchmarksRequest* /*unused*/, - GetBenchmarksReply* reply) { - const auto benchmarks = getBenchmarks(); - *reply->mutable_benchmark() = {benchmarks.begin(), benchmarks.end()}; - return Status::OK; -} - Status ExampleService::session(uint64_t id, ExampleCompilationSession** sess) { auto it = sessions_.find(id); if (it == sessions_.end()) { diff --git a/examples/example_compiler_gym_service/service_cc/ExampleService.h b/examples/example_compiler_gym_service/service_cc/ExampleService.h index 8a4b63479..0477e6aa6 100644 --- a/examples/example_compiler_gym_service/service_cc/ExampleService.h +++ b/examples/example_compiler_gym_service/service_cc/ExampleService.h @@ -42,9 +42,6 @@ class ExampleService final : public CompilerGymService::Service { grpc::Status Step(grpc::ServerContext* context, const StepRequest* request, StepReply* reply) final override; - grpc::Status GetBenchmarks(grpc::ServerContext* context, const GetBenchmarksRequest* request, - GetBenchmarksReply* reply) final override; - private: [[nodiscard]] grpc::Status session(uint64_t id, ExampleCompilationSession** environment); diff --git a/examples/example_compiler_gym_service/service_py/example_service.py b/examples/example_compiler_gym_service/service_py/example_service.py index 065262598..0335b8db1 100755 --- a/examples/example_compiler_gym_service/service_py/example_service.py +++ b/examples/example_compiler_gym_service/service_py/example_service.py @@ -34,7 +34,7 @@ logging.basicConfig(level=logging.DEBUG) # The names of the benchmarks that are supported -BENCHMARKS = ["foo", "bar"] +BENCHMARKS = ["benchmark://example-v0/foo", "benchmark://example-v0/bar"] # The list of actions that are supported by this service. This example uses a # static (unchanging) action space, but this could be extended to support a @@ -153,14 +153,6 @@ def GetSpaces( observation_space_list=OBSERVATION_SPACES, ) - def GetBenchmarks( - self, request: proto.GetBenchmarksRequest, context - ) -> proto.GetBenchmarksReply: - del context # Unused - # Report the available benchmarks to the user. - logging.debug("GetBenchmarks()") - return proto.GetBenchmarksReply(benchmark=BENCHMARKS) - def StartSession( self, request: proto.StartSessionRequest, context ) -> proto.StartSessionReply: diff --git a/examples/explore.py b/examples/explore.py index adbc8c84c..0a94db4f1 100644 --- a/examples/explore.py +++ b/examples/explore.py @@ -11,7 +11,7 @@ Example usage: - $ python explore.py --env=llvm-ic-v0 --benchmark=cBench-v1/dijkstra \ + $ python explore.py --env=llvm-ic-v0 --benchmark=cbench-v1/dijkstra \ --episode_length=10 --actions=-simplifycfg,-instcombine,-mem2reg,-newgvn Use --help to list the configurable options. diff --git a/examples/explore_test.py b/examples/explore_test.py index 51646b55e..759a81ac4 100644 --- a/examples/explore_test.py +++ b/examples/explore_test.py @@ -11,7 +11,7 @@ def test_run_explore_smoke_test(capsys): [ "explore", "--env=llvm-ic-v0", - "--benchmark=cBench-v1/dijkstra", + "--benchmark=cbench-v1/dijkstra", "--episode_length=2", "--actions=-newgvn,-instcombine,-mem2reg", "--nproc=2", diff --git a/examples/random_walk.py b/examples/random_walk.py index e9f9492e1..965d968e1 100644 --- a/examples/random_walk.py +++ b/examples/random_walk.py @@ -8,7 +8,7 @@ # Run a random walk on cBench example program using instruction count reward. $ python3 examples/random_walk.py --env=llvm-v0 --step_min=100 --step_max=100 \ - --benchmark=cBench-v1/dijkstra --reward=IrInstructionCount + --benchmark=cbench-v1/dijkstra --reward=IrInstructionCount """ import random diff --git a/examples/random_walk_test.py b/examples/random_walk_test.py index 53ebca235..d810ab12d 100644 --- a/examples/random_walk_test.py +++ b/examples/random_walk_test.py @@ -13,7 +13,7 @@ def test_run_random_walk_smoke_test(): flags.FLAGS(["argv0"]) env = gym.make("llvm-autophase-ic-v0") - env.benchmark = "cBench-v1/crc32" + env.benchmark = "cbench-v1/crc32" try: run_random_walk(env=env, step_count=5) finally: diff --git a/examples/sensitivity_analysis/action_sensitivity_analysis.py b/examples/sensitivity_analysis/action_sensitivity_analysis.py index 8e17fa70c..868e1f743 100644 --- a/examples/sensitivity_analysis/action_sensitivity_analysis.py +++ b/examples/sensitivity_analysis/action_sensitivity_analysis.py @@ -17,7 +17,7 @@ $ bazel run -c opt //compiler_gym/bin:action_sensitivity_analysis -- \ --env=llvm-v0 --reward=IrInstructionCountO3 \ - --benchmark=cBench-v1/crc32 --num_trials=100 \ + --benchmark=cbench-v1/crc32 --num_trials=100 \ --action=AddDiscriminatorsPass,AggressiveDcepass,AggressiveInstCombinerPass Evaluate the single-step reward delta of all actions on LLVM codesize: diff --git a/examples/sensitivity_analysis/action_sensitivity_analysis_test.py b/examples/sensitivity_analysis/action_sensitivity_analysis_test.py index 3a4a74651..66d0d874d 100644 --- a/examples/sensitivity_analysis/action_sensitivity_analysis_test.py +++ b/examples/sensitivity_analysis/action_sensitivity_analysis_test.py @@ -21,7 +21,7 @@ def test_run_action_sensitivity_analysis(): actions = [0, 1] env = "llvm-v0" reward = "IrInstructionCountO3" - benchmark = "cBench-v1/crc32" + benchmark = "cbench-v1/crc32" set_command_line_flags(["argv0", f"--env={env}", f"--benchmark={benchmark}"]) diff --git a/examples/sensitivity_analysis/benchmark_sensitivity_analysis.py b/examples/sensitivity_analysis/benchmark_sensitivity_analysis.py index 31ffbb1fb..628d2286a 100644 --- a/examples/sensitivity_analysis/benchmark_sensitivity_analysis.py +++ b/examples/sensitivity_analysis/benchmark_sensitivity_analysis.py @@ -27,6 +27,7 @@ """ import random from concurrent.futures import ThreadPoolExecutor +from itertools import islice from multiprocessing import cpu_count from pathlib import Path from typing import List, Optional, Union @@ -173,7 +174,7 @@ def main(argv): benchmarks = [benchmark] else: with env_session_from_flags() as env: - benchmarks = env.benchmarks + benchmarks = islice(env.benchmarks, 100) logs_dir = Path( FLAGS.output_dir or create_logging_dir("benchmark_sensitivity_analysis") diff --git a/examples/sensitivity_analysis/benchmark_sensitivity_analysis_test.py b/examples/sensitivity_analysis/benchmark_sensitivity_analysis_test.py index e80ea923f..8d8d35e81 100644 --- a/examples/sensitivity_analysis/benchmark_sensitivity_analysis_test.py +++ b/examples/sensitivity_analysis/benchmark_sensitivity_analysis_test.py @@ -20,7 +20,7 @@ def test_run_benchmark_sensitivity_analysis(): env = "llvm-v0" reward = "IrInstructionCountO3" - benchmarks = ["cBench-v1/crc32"] + benchmarks = ["cbench-v1/crc32"] set_command_line_flags(["argv0", f"--env={env}"]) diff --git a/examples/tabular_q_test.py b/examples/tabular_q_test.py index fbcccd470..4d7f951a1 100644 --- a/examples/tabular_q_test.py +++ b/examples/tabular_q_test.py @@ -20,7 +20,7 @@ def test_run_tabular_q_smoke_test(): "--episode_length=5", "--episodes=10", "--log_every=2", - "--benchmark=cBench-v1/crc32", + "--benchmark=cbench-v1/crc32", ] ) with capture_output() as out: diff --git a/leaderboard/llvm_instcount/e_greedy/e_greedy_test.py b/leaderboard/llvm_instcount/e_greedy/e_greedy_test.py index 1b6dda647..ff637e918 100644 --- a/leaderboard/llvm_instcount/e_greedy/e_greedy_test.py +++ b/leaderboard/llvm_instcount/e_greedy/e_greedy_test.py @@ -38,7 +38,7 @@ def test_select_best_action_closed_environment(env: LlvmEnv): """Test that select_best_action() recovers from an environment whose service has closed.""" env.reward_space = "IrInstructionCount" - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") with ThreadPoolExecutor() as executor: best_a = select_best_action(env, executor) env.close() diff --git a/leaderboard/llvm_instcount/e_greedy/results_e0.csv b/leaderboard/llvm_instcount/e_greedy/results_e0.csv index a0affb0d7..b321ef28a 100644 --- a/leaderboard/llvm_instcount/e_greedy/results_e0.csv +++ b/leaderboard/llvm_instcount/e_greedy/results_e0.csv @@ -1,231 +1,231 @@ benchmark,reward,walltime,commandline -benchmark://cBench-v1/adpcm,0.9748603351955308,2.6167967319488525,opt -sroa -simplifycfg -early-cse-memssa -jump-threading -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/adpcm,0.9748603351955308,2.6323108673095703,opt -sroa -simplifycfg -early-cse-memssa -jump-threading -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/adpcm,0.9748603351955308,2.632906675338745,opt -sroa -simplifycfg -early-cse-memssa -jump-threading -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/adpcm,0.9748603351955308,2.6446733474731445,opt -sroa -simplifycfg -early-cse-memssa -jump-threading -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/adpcm,0.9748603351955308,2.65216326713562,opt -sroa -simplifycfg -early-cse-memssa -jump-threading -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/adpcm,0.9748603351955308,2.656970739364624,opt -sroa -simplifycfg -early-cse-memssa -jump-threading -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/adpcm,0.9748603351955308,2.661275625228882,opt -sroa -simplifycfg -early-cse-memssa -jump-threading -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/adpcm,0.9748603351955308,2.6938230991363525,opt -sroa -simplifycfg -early-cse-memssa -jump-threading -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/adpcm,0.9748603351955308,3.050021171569824,opt -sroa -simplifycfg -early-cse-memssa -jump-threading -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/adpcm,0.9748603351955308,3.102595806121826,opt -sroa -simplifycfg -early-cse-memssa -jump-threading -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.0132743362831858,4.658697843551636,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -elim-avail-extern -tailcallelim input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.0132743362831858,4.6678147315979,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -elim-avail-extern -tailcallelim input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.0132743362831858,4.669229984283447,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -elim-avail-extern -tailcallelim input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.0132743362831858,4.674164533615112,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -elim-avail-extern -tailcallelim input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.0132743362831858,4.675281047821045,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -elim-avail-extern -tailcallelim input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.0132743362831858,4.692632436752319,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -elim-avail-extern -tailcallelim input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.0132743362831858,4.72410249710083,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -elim-avail-extern -tailcallelim input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.0132743362831858,4.738322973251343,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -elim-avail-extern -tailcallelim input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.0132743362831858,5.429574012756348,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -elim-avail-extern -tailcallelim input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.0132743362831858,5.552142143249512,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -elim-avail-extern -tailcallelim input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0305343511450382,8.000561714172363,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0305343511450382,8.013018369674683,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0305343511450382,8.015228033065796,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0305343511450382,8.043203353881836,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0305343511450382,8.049434900283813,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0305343511450382,8.072939395904541,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0305343511450382,8.140095472335815,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0305343511450382,8.566433668136597,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0305343511450382,8.841854333877563,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0305343511450382,9.593023538589478,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.2088736134978917,74.5777907371521,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -ipsccp -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -elim-avail-extern -prune-eh -simplifycfg -mldst-motion -instcombine -tailcallelim -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.2088736134978917,74.68991255760193,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -ipsccp -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -elim-avail-extern -prune-eh -simplifycfg -mldst-motion -instcombine -tailcallelim -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.2088736134978917,75.3055009841919,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -ipsccp -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -elim-avail-extern -prune-eh -simplifycfg -mldst-motion -instcombine -tailcallelim -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.2088736134978917,75.61981582641602,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -ipsccp -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -elim-avail-extern -prune-eh -simplifycfg -mldst-motion -instcombine -tailcallelim -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.2088736134978917,75.74971032142639,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -ipsccp -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -elim-avail-extern -prune-eh -simplifycfg -mldst-motion -instcombine -tailcallelim -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.2088736134978917,75.85093307495117,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -ipsccp -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -elim-avail-extern -prune-eh -simplifycfg -mldst-motion -instcombine -tailcallelim -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.2088736134978917,75.92890071868896,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -ipsccp -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -elim-avail-extern -prune-eh -simplifycfg -mldst-motion -instcombine -tailcallelim -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.2088736134978917,76.07783126831055,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -ipsccp -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -elim-avail-extern -prune-eh -simplifycfg -mldst-motion -instcombine -tailcallelim -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.2088736134978917,76.28789138793945,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -ipsccp -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -elim-avail-extern -prune-eh -simplifycfg -mldst-motion -instcombine -tailcallelim -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.2088736134978917,89.29922342300415,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -ipsccp -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -elim-avail-extern -prune-eh -simplifycfg -mldst-motion -instcombine -tailcallelim -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,2.061441421508789,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,2.063772678375244,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,2.0638957023620605,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,2.069030284881592,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,2.0694191455841064,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,2.10876202583313,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,2.418781042098999,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,2.4249207973480225,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,2.430199146270752,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,2.4578709602355957,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.979591836734694,2.81844162940979,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.979591836734694,2.826531410217285,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.979591836734694,2.827880382537842,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.979591836734694,2.8283395767211914,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.979591836734694,2.8406713008880615,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.979591836734694,2.865175485610962,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.979591836734694,3.1737499237060547,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.979591836734694,3.198945999145508,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.979591836734694,3.204514265060425,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.979591836734694,3.337878942489624,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/ghostscript,1.0217193660340413,2140.6080310344696,opt -sroa -gvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -instcombine -simplifycfg -mergefunc -ipsccp -mldst-motion -newgvn -instcombine -simplifycfg -memcpyopt -bdce -dse -instcombine -nary-reassociate -ipsccp -newgvn -globaldce -gvn-hoist -mem2reg -mldst-motion -simplifycfg -dse -prune-eh -instcombine -simplifycfg -early-cse-memssa -mldst-motion -elim-avail-extern -slsr -newgvn -mldst-motion input.bc -o output.bc -benchmark://cBench-v1/ghostscript,1.0217193660340413,2146.9346401691437,opt -sroa -gvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -instcombine -simplifycfg -mergefunc -ipsccp -mldst-motion -newgvn -instcombine -simplifycfg -memcpyopt -bdce -dse -instcombine -nary-reassociate -ipsccp -newgvn -globaldce -gvn-hoist -mem2reg -mldst-motion -simplifycfg -dse -prune-eh -instcombine -simplifycfg -early-cse-memssa -mldst-motion -elim-avail-extern -slsr -newgvn -mldst-motion input.bc -o output.bc -benchmark://cBench-v1/ghostscript,1.0217193660340413,2152.0892202854156,opt -sroa -gvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -instcombine -simplifycfg -mergefunc -ipsccp -mldst-motion -newgvn -instcombine -simplifycfg -memcpyopt -bdce -dse -instcombine -nary-reassociate -ipsccp -newgvn -globaldce -gvn-hoist -mem2reg -mldst-motion -simplifycfg -dse -prune-eh -instcombine -simplifycfg -early-cse-memssa -mldst-motion -elim-avail-extern -slsr -newgvn -mldst-motion input.bc -o output.bc -benchmark://cBench-v1/ghostscript,1.0217193660340413,2159.1251413822174,opt -sroa -gvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -instcombine -simplifycfg -mergefunc -ipsccp -mldst-motion -newgvn -instcombine -simplifycfg -memcpyopt -bdce -dse -instcombine -nary-reassociate -ipsccp -newgvn -globaldce -gvn-hoist -mem2reg -mldst-motion -simplifycfg -dse -prune-eh -instcombine -simplifycfg -early-cse-memssa -mldst-motion -elim-avail-extern -slsr -newgvn -mldst-motion input.bc -o output.bc -benchmark://cBench-v1/ghostscript,1.0217193660340413,2161.40825343132,opt -sroa -gvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -instcombine -simplifycfg -mergefunc -ipsccp -mldst-motion -newgvn -instcombine -simplifycfg -memcpyopt -bdce -dse -instcombine -nary-reassociate -ipsccp -newgvn -globaldce -gvn-hoist -mem2reg -mldst-motion -simplifycfg -dse -prune-eh -instcombine -simplifycfg -early-cse-memssa -mldst-motion -elim-avail-extern -slsr -newgvn -mldst-motion input.bc -o output.bc -benchmark://cBench-v1/ghostscript,1.0217193660340413,2165.3180038928986,opt -sroa -gvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -instcombine -simplifycfg -mergefunc -ipsccp -mldst-motion -newgvn -instcombine -simplifycfg -memcpyopt -bdce -dse -instcombine -nary-reassociate -ipsccp -newgvn -globaldce -gvn-hoist -mem2reg -mldst-motion -simplifycfg -dse -prune-eh -instcombine -simplifycfg -early-cse-memssa -mldst-motion -elim-avail-extern -slsr -newgvn -mldst-motion input.bc -o output.bc -benchmark://cBench-v1/ghostscript,1.0217193660340413,2186.7724907398224,opt -sroa -gvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -instcombine -simplifycfg -mergefunc -ipsccp -mldst-motion -newgvn -instcombine -simplifycfg -memcpyopt -bdce -dse -instcombine -nary-reassociate -ipsccp -newgvn -globaldce -gvn-hoist -mem2reg -mldst-motion -simplifycfg -dse -prune-eh -instcombine -simplifycfg -early-cse-memssa -mldst-motion -elim-avail-extern -slsr -newgvn -mldst-motion input.bc -o output.bc -benchmark://cBench-v1/ghostscript,1.0217193660340413,2207.689845561981,opt -sroa -gvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -instcombine -simplifycfg -mergefunc -ipsccp -mldst-motion -newgvn -instcombine -simplifycfg -memcpyopt -bdce -dse -instcombine -nary-reassociate -ipsccp -newgvn -globaldce -gvn-hoist -mem2reg -mldst-motion -simplifycfg -dse -prune-eh -instcombine -simplifycfg -early-cse-memssa -mldst-motion -elim-avail-extern -slsr -newgvn -mldst-motion input.bc -o output.bc -benchmark://cBench-v1/ghostscript,1.0217193660340413,2208.390825986862,opt -sroa -gvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -instcombine -simplifycfg -mergefunc -ipsccp -mldst-motion -newgvn -instcombine -simplifycfg -memcpyopt -bdce -dse -instcombine -nary-reassociate -ipsccp -newgvn -globaldce -gvn-hoist -mem2reg -mldst-motion -simplifycfg -dse -prune-eh -instcombine -simplifycfg -early-cse-memssa -mldst-motion -elim-avail-extern -slsr -newgvn -mldst-motion input.bc -o output.bc -benchmark://cBench-v1/ghostscript,1.0217193660340413,2371.4824783802032,opt -sroa -gvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -instcombine -simplifycfg -mergefunc -ipsccp -mldst-motion -newgvn -instcombine -simplifycfg -memcpyopt -bdce -dse -instcombine -nary-reassociate -ipsccp -newgvn -globaldce -gvn-hoist -mem2reg -mldst-motion -simplifycfg -dse -prune-eh -instcombine -simplifycfg -early-cse-memssa -mldst-motion -elim-avail-extern -slsr -newgvn -mldst-motion input.bc -o output.bc -benchmark://cBench-v1/gsm,1.106947211155379,40.79212260246277,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -elim-avail-extern -nary-reassociate -ipsccp -gvn-hoist -instcombine -simplifycfg -prune-eh input.bc -o output.bc -benchmark://cBench-v1/gsm,1.106947211155379,40.92847776412964,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -elim-avail-extern -nary-reassociate -ipsccp -gvn-hoist -instcombine -simplifycfg -prune-eh input.bc -o output.bc -benchmark://cBench-v1/gsm,1.106947211155379,41.038567543029785,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -elim-avail-extern -nary-reassociate -ipsccp -gvn-hoist -instcombine -simplifycfg -prune-eh input.bc -o output.bc -benchmark://cBench-v1/gsm,1.106947211155379,41.05518436431885,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -elim-avail-extern -nary-reassociate -ipsccp -gvn-hoist -instcombine -simplifycfg -prune-eh input.bc -o output.bc -benchmark://cBench-v1/gsm,1.106947211155379,41.592167139053345,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -elim-avail-extern -nary-reassociate -ipsccp -gvn-hoist -instcombine -simplifycfg -prune-eh input.bc -o output.bc -benchmark://cBench-v1/gsm,1.106947211155379,41.628905057907104,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -elim-avail-extern -nary-reassociate -ipsccp -gvn-hoist -instcombine -simplifycfg -prune-eh input.bc -o output.bc -benchmark://cBench-v1/gsm,1.106947211155379,42.249706983566284,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -elim-avail-extern -nary-reassociate -ipsccp -gvn-hoist -instcombine -simplifycfg -prune-eh input.bc -o output.bc -benchmark://cBench-v1/gsm,1.106947211155379,42.33488631248474,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -elim-avail-extern -nary-reassociate -ipsccp -gvn-hoist -instcombine -simplifycfg -prune-eh input.bc -o output.bc -benchmark://cBench-v1/gsm,1.106947211155379,43.1302855014801,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -elim-avail-extern -nary-reassociate -ipsccp -gvn-hoist -instcombine -simplifycfg -prune-eh input.bc -o output.bc -benchmark://cBench-v1/gsm,1.106947211155379,49.03903365135193,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -elim-avail-extern -nary-reassociate -ipsccp -gvn-hoist -instcombine -simplifycfg -prune-eh input.bc -o output.bc -benchmark://cBench-v1/ispell,1.019985925404645,68.98562455177307,opt -sroa -newgvn -simplifycfg -instcombine -newgvn -simplifycfg -elim-avail-extern -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -newgvn -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -prune-eh -newgvn -simplifycfg -mldst-motion -jump-threading input.bc -o output.bc -benchmark://cBench-v1/ispell,1.019985925404645,69.6540629863739,opt -sroa -newgvn -simplifycfg -instcombine -newgvn -simplifycfg -elim-avail-extern -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -newgvn -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -prune-eh -newgvn -simplifycfg -mldst-motion -jump-threading input.bc -o output.bc -benchmark://cBench-v1/ispell,1.019985925404645,69.68867444992065,opt -sroa -newgvn -simplifycfg -instcombine -newgvn -simplifycfg -elim-avail-extern -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -newgvn -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -prune-eh -newgvn -simplifycfg -mldst-motion -jump-threading input.bc -o output.bc -benchmark://cBench-v1/ispell,1.019985925404645,70.07287931442261,opt -sroa -newgvn -simplifycfg -instcombine -newgvn -simplifycfg -elim-avail-extern -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -newgvn -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -prune-eh -newgvn -simplifycfg -mldst-motion -jump-threading input.bc -o output.bc -benchmark://cBench-v1/ispell,1.019985925404645,70.29381346702576,opt -sroa -newgvn -simplifycfg -instcombine -newgvn -simplifycfg -elim-avail-extern -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -newgvn -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -prune-eh -newgvn -simplifycfg -mldst-motion -jump-threading input.bc -o output.bc -benchmark://cBench-v1/ispell,1.019985925404645,70.60475730895996,opt -sroa -newgvn -simplifycfg -instcombine -newgvn -simplifycfg -elim-avail-extern -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -newgvn -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -prune-eh -newgvn -simplifycfg -mldst-motion -jump-threading input.bc -o output.bc -benchmark://cBench-v1/ispell,1.019985925404645,70.69765996932983,opt -sroa -newgvn -simplifycfg -instcombine -newgvn -simplifycfg -elim-avail-extern -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -newgvn -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -prune-eh -newgvn -simplifycfg -mldst-motion -jump-threading input.bc -o output.bc -benchmark://cBench-v1/ispell,1.019985925404645,70.92285132408142,opt -sroa -newgvn -simplifycfg -instcombine -newgvn -simplifycfg -elim-avail-extern -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -newgvn -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -prune-eh -newgvn -simplifycfg -mldst-motion -jump-threading input.bc -o output.bc -benchmark://cBench-v1/ispell,1.019985925404645,71.1001365184784,opt -sroa -newgvn -simplifycfg -instcombine -newgvn -simplifycfg -elim-avail-extern -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -newgvn -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -prune-eh -newgvn -simplifycfg -mldst-motion -jump-threading input.bc -o output.bc -benchmark://cBench-v1/ispell,1.019985925404645,80.4593243598938,opt -sroa -newgvn -simplifycfg -instcombine -newgvn -simplifycfg -elim-avail-extern -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -newgvn -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -prune-eh -newgvn -simplifycfg -mldst-motion -jump-threading input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.0374492358247827,231.60082149505615,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -elim-avail-extern -mldst-motion -lower-constant-intrinsics -mldst-motion -ipsccp -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -correlated-propagation -newgvn -slsr -newgvn -globaldce -gvn-hoist -newgvn -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.0374492358247827,231.77300357818604,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -elim-avail-extern -mldst-motion -lower-constant-intrinsics -mldst-motion -ipsccp -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -correlated-propagation -newgvn -slsr -newgvn -globaldce -gvn-hoist -newgvn -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.0374492358247827,238.08568453788757,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -elim-avail-extern -mldst-motion -lower-constant-intrinsics -mldst-motion -ipsccp -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -correlated-propagation -newgvn -slsr -newgvn -globaldce -gvn-hoist -newgvn -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.0374492358247827,238.2811233997345,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -elim-avail-extern -mldst-motion -lower-constant-intrinsics -mldst-motion -ipsccp -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -correlated-propagation -newgvn -slsr -newgvn -globaldce -gvn-hoist -newgvn -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.0374492358247827,240.15624928474426,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -elim-avail-extern -mldst-motion -lower-constant-intrinsics -mldst-motion -ipsccp -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -correlated-propagation -newgvn -slsr -newgvn -globaldce -gvn-hoist -newgvn -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.0374492358247827,240.99767327308655,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -elim-avail-extern -mldst-motion -lower-constant-intrinsics -mldst-motion -ipsccp -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -correlated-propagation -newgvn -slsr -newgvn -globaldce -gvn-hoist -newgvn -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.0374492358247827,242.14424967765808,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -elim-avail-extern -mldst-motion -lower-constant-intrinsics -mldst-motion -ipsccp -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -correlated-propagation -newgvn -slsr -newgvn -globaldce -gvn-hoist -newgvn -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.0374492358247827,242.46206092834473,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -elim-avail-extern -mldst-motion -lower-constant-intrinsics -mldst-motion -ipsccp -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -correlated-propagation -newgvn -slsr -newgvn -globaldce -gvn-hoist -newgvn -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.0374492358247827,242.51537442207336,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -elim-avail-extern -mldst-motion -lower-constant-intrinsics -mldst-motion -ipsccp -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -correlated-propagation -newgvn -slsr -newgvn -globaldce -gvn-hoist -newgvn -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.0374492358247827,275.1627869606018,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -elim-avail-extern -mldst-motion -lower-constant-intrinsics -mldst-motion -ipsccp -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -correlated-propagation -newgvn -slsr -newgvn -globaldce -gvn-hoist -newgvn -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.0388615216201431,197.58089399337769,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -simplifycfg -instcombine -mergefunc -nary-reassociate -memcpyopt -newgvn -elim-avail-extern -mldst-motion -mldst-motion -lower-constant-intrinsics -simplifycfg -mldst-motion -ipsccp -newgvn -mldst-motion -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.0388615216201431,201.74994444847107,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -simplifycfg -instcombine -mergefunc -nary-reassociate -memcpyopt -newgvn -elim-avail-extern -mldst-motion -mldst-motion -lower-constant-intrinsics -simplifycfg -mldst-motion -ipsccp -newgvn -mldst-motion -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.0388615216201431,202.76921606063843,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -simplifycfg -instcombine -mergefunc -nary-reassociate -memcpyopt -newgvn -elim-avail-extern -mldst-motion -mldst-motion -lower-constant-intrinsics -simplifycfg -mldst-motion -ipsccp -newgvn -mldst-motion -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.0388615216201431,203.09221363067627,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -simplifycfg -instcombine -mergefunc -nary-reassociate -memcpyopt -newgvn -elim-avail-extern -mldst-motion -mldst-motion -lower-constant-intrinsics -simplifycfg -mldst-motion -ipsccp -newgvn -mldst-motion -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.0388615216201431,203.26621675491333,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -simplifycfg -instcombine -mergefunc -nary-reassociate -memcpyopt -newgvn -elim-avail-extern -mldst-motion -mldst-motion -lower-constant-intrinsics -simplifycfg -mldst-motion -ipsccp -newgvn -mldst-motion -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.0388615216201431,204.81071066856384,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -simplifycfg -instcombine -mergefunc -nary-reassociate -memcpyopt -newgvn -elim-avail-extern -mldst-motion -mldst-motion -lower-constant-intrinsics -simplifycfg -mldst-motion -ipsccp -newgvn -mldst-motion -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.0388615216201431,205.38714623451233,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -simplifycfg -instcombine -mergefunc -nary-reassociate -memcpyopt -newgvn -elim-avail-extern -mldst-motion -mldst-motion -lower-constant-intrinsics -simplifycfg -mldst-motion -ipsccp -newgvn -mldst-motion -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.0388615216201431,206.71245503425598,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -simplifycfg -instcombine -mergefunc -nary-reassociate -memcpyopt -newgvn -elim-avail-extern -mldst-motion -mldst-motion -lower-constant-intrinsics -simplifycfg -mldst-motion -ipsccp -newgvn -mldst-motion -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.0388615216201431,207.26565623283386,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -simplifycfg -instcombine -mergefunc -nary-reassociate -memcpyopt -newgvn -elim-avail-extern -mldst-motion -mldst-motion -lower-constant-intrinsics -simplifycfg -mldst-motion -ipsccp -newgvn -mldst-motion -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.0388615216201431,236.7751350402832,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -simplifycfg -instcombine -mergefunc -nary-reassociate -memcpyopt -newgvn -elim-avail-extern -mldst-motion -mldst-motion -lower-constant-intrinsics -simplifycfg -mldst-motion -ipsccp -newgvn -mldst-motion -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/lame,1.0658164427237529,181.06120204925537,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -nary-reassociate -gvn-hoist -bdce -jump-threading -instcombine -ipsccp -memcpyopt -newgvn -dse -simplifycfg -mldst-motion -globalopt -instcombine -simplifycfg -newgvn -elim-avail-extern -prune-eh -mergefunc -instsimplify -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc -benchmark://cBench-v1/lame,1.0658164427237529,184.7970871925354,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -nary-reassociate -gvn-hoist -bdce -jump-threading -instcombine -ipsccp -memcpyopt -newgvn -dse -simplifycfg -mldst-motion -globalopt -instcombine -simplifycfg -newgvn -elim-avail-extern -prune-eh -mergefunc -instsimplify -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc -benchmark://cBench-v1/lame,1.0658164427237529,187.30368876457214,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -nary-reassociate -gvn-hoist -bdce -jump-threading -instcombine -ipsccp -memcpyopt -newgvn -dse -simplifycfg -mldst-motion -globalopt -instcombine -simplifycfg -newgvn -elim-avail-extern -prune-eh -mergefunc -instsimplify -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc -benchmark://cBench-v1/lame,1.0658164427237529,188.11193895339966,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -nary-reassociate -gvn-hoist -bdce -jump-threading -instcombine -ipsccp -memcpyopt -newgvn -dse -simplifycfg -mldst-motion -globalopt -instcombine -simplifycfg -newgvn -elim-avail-extern -prune-eh -mergefunc -instsimplify -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc -benchmark://cBench-v1/lame,1.0658164427237529,188.78753519058228,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -nary-reassociate -gvn-hoist -bdce -jump-threading -instcombine -ipsccp -memcpyopt -newgvn -dse -simplifycfg -mldst-motion -globalopt -instcombine -simplifycfg -newgvn -elim-avail-extern -prune-eh -mergefunc -instsimplify -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc -benchmark://cBench-v1/lame,1.0658164427237529,189.2517716884613,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -nary-reassociate -gvn-hoist -bdce -jump-threading -instcombine -ipsccp -memcpyopt -newgvn -dse -simplifycfg -mldst-motion -globalopt -instcombine -simplifycfg -newgvn -elim-avail-extern -prune-eh -mergefunc -instsimplify -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc -benchmark://cBench-v1/lame,1.0658164427237529,190.45842099189758,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -nary-reassociate -gvn-hoist -bdce -jump-threading -instcombine -ipsccp -memcpyopt -newgvn -dse -simplifycfg -mldst-motion -globalopt -instcombine -simplifycfg -newgvn -elim-avail-extern -prune-eh -mergefunc -instsimplify -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc -benchmark://cBench-v1/lame,1.0658164427237529,190.51102375984192,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -nary-reassociate -gvn-hoist -bdce -jump-threading -instcombine -ipsccp -memcpyopt -newgvn -dse -simplifycfg -mldst-motion -globalopt -instcombine -simplifycfg -newgvn -elim-avail-extern -prune-eh -mergefunc -instsimplify -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc -benchmark://cBench-v1/lame,1.0658164427237529,191.6278738975525,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -nary-reassociate -gvn-hoist -bdce -jump-threading -instcombine -ipsccp -memcpyopt -newgvn -dse -simplifycfg -mldst-motion -globalopt -instcombine -simplifycfg -newgvn -elim-avail-extern -prune-eh -mergefunc -instsimplify -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc -benchmark://cBench-v1/lame,1.0658164427237529,217.91625666618347,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -nary-reassociate -gvn-hoist -bdce -jump-threading -instcombine -ipsccp -memcpyopt -newgvn -dse -simplifycfg -mldst-motion -globalopt -instcombine -simplifycfg -newgvn -elim-avail-extern -prune-eh -mergefunc -instsimplify -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9799777530589544,4.072362661361694,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9799777530589544,4.12520170211792,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9799777530589544,4.162842273712158,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9799777530589544,4.674448251724243,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9799777530589544,4.691532135009766,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9799777530589544,4.693127632141113,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9799777530589544,4.700468063354492,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9799777530589544,4.735736131668091,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9799777530589544,4.784304857254028,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9799777530589544,5.011373996734619,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc -benchmark://cBench-v1/qsort,1.1362229102167183,3.617689371109009,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/qsort,1.1362229102167183,3.627746105194092,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/qsort,1.1362229102167183,3.6945436000823975,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/qsort,1.1362229102167183,4.168741226196289,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/qsort,1.1362229102167183,4.213088274002075,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/qsort,1.1362229102167183,4.214311599731445,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/qsort,1.1362229102167183,4.229600191116333,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/qsort,1.1362229102167183,4.246491432189941,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/qsort,1.1362229102167183,4.304184913635254,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/qsort,1.1362229102167183,4.322846174240112,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.1050210808738983,10.104260921478271,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.1050210808738983,10.33758807182312,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.1050210808738983,10.37963604927063,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.1050210808738983,10.791464805603027,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.1050210808738983,10.793577432632446,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.1050210808738983,10.801882028579712,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.1050210808738983,10.809131860733032,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.1050210808738983,10.939861059188843,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.1050210808738983,11.007495880126953,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.1050210808738983,12.216138124465942,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc -benchmark://cBench-v1/sha,1.4749163879598661,3.296888589859009,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc -benchmark://cBench-v1/sha,1.4749163879598661,3.339097023010254,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc -benchmark://cBench-v1/sha,1.4749163879598661,3.3705661296844482,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc -benchmark://cBench-v1/sha,1.4749163879598661,3.7465083599090576,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc -benchmark://cBench-v1/sha,1.4749163879598661,3.784933090209961,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc -benchmark://cBench-v1/sha,1.4749163879598661,3.785313606262207,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc -benchmark://cBench-v1/sha,1.4749163879598661,3.794675827026367,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc -benchmark://cBench-v1/sha,1.4749163879598661,3.796710968017578,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc -benchmark://cBench-v1/sha,1.4749163879598661,3.8460588455200195,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc -benchmark://cBench-v1/sha,1.4749163879598661,3.9928929805755615,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc -benchmark://cBench-v1/stringsearch,1.0109289617486337,6.248675346374512,opt -sroa -newgvn -simplifycfg -instcombine -elim-avail-extern -jump-threading -lower-constant-intrinsics -gvn -gvn-hoist -newgvn input.bc -o output.bc -benchmark://cBench-v1/stringsearch,1.0109289617486337,6.2487945556640625,opt -sroa -newgvn -simplifycfg -instcombine -elim-avail-extern -jump-threading -lower-constant-intrinsics -gvn -gvn-hoist -newgvn input.bc -o output.bc -benchmark://cBench-v1/stringsearch,1.0109289617486337,6.303280591964722,opt -sroa -newgvn -simplifycfg -instcombine -elim-avail-extern -jump-threading -lower-constant-intrinsics -gvn -gvn-hoist -newgvn input.bc -o output.bc -benchmark://cBench-v1/stringsearch,1.0109289617486337,7.014445543289185,opt -sroa -newgvn -simplifycfg -instcombine -elim-avail-extern -jump-threading -lower-constant-intrinsics -gvn -gvn-hoist -newgvn input.bc -o output.bc -benchmark://cBench-v1/stringsearch,1.0109289617486337,7.057801961898804,opt -sroa -newgvn -simplifycfg -instcombine -elim-avail-extern -jump-threading -lower-constant-intrinsics -gvn -gvn-hoist -newgvn input.bc -o output.bc -benchmark://cBench-v1/stringsearch,1.0109289617486337,7.113065242767334,opt -sroa -newgvn -simplifycfg -instcombine -elim-avail-extern -jump-threading -lower-constant-intrinsics -gvn -gvn-hoist -newgvn input.bc -o output.bc -benchmark://cBench-v1/stringsearch,1.0109289617486337,7.117478609085083,opt -sroa -newgvn -simplifycfg -instcombine -elim-avail-extern -jump-threading -lower-constant-intrinsics -gvn -gvn-hoist -newgvn input.bc -o output.bc -benchmark://cBench-v1/stringsearch,1.0109289617486337,7.162009954452515,opt -sroa -newgvn -simplifycfg -instcombine -elim-avail-extern -jump-threading -lower-constant-intrinsics -gvn -gvn-hoist -newgvn input.bc -o output.bc -benchmark://cBench-v1/stringsearch,1.0109289617486337,7.254070997238159,opt -sroa -newgvn -simplifycfg -instcombine -elim-avail-extern -jump-threading -lower-constant-intrinsics -gvn -gvn-hoist -newgvn input.bc -o output.bc -benchmark://cBench-v1/stringsearch,1.0109289617486337,7.473099708557129,opt -sroa -newgvn -simplifycfg -instcombine -elim-avail-extern -jump-threading -lower-constant-intrinsics -gvn -gvn-hoist -newgvn input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9813432835820897,2.699200391769409,opt -sroa -gvn -simplifycfg -instcombine -elim-avail-extern input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9813432835820897,2.7258427143096924,opt -sroa -gvn -simplifycfg -instcombine -elim-avail-extern input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9813432835820897,2.727332353591919,opt -sroa -gvn -simplifycfg -instcombine -elim-avail-extern input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9813432835820897,2.7604801654815674,opt -sroa -gvn -simplifycfg -instcombine -elim-avail-extern input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9813432835820897,3.0859103202819824,opt -sroa -gvn -simplifycfg -instcombine -elim-avail-extern input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9813432835820897,3.139512777328491,opt -sroa -gvn -simplifycfg -instcombine -elim-avail-extern input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9813432835820897,3.140896797180176,opt -sroa -gvn -simplifycfg -instcombine -elim-avail-extern input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9813432835820897,3.1499648094177246,opt -sroa -gvn -simplifycfg -instcombine -elim-avail-extern input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9813432835820897,3.163114070892334,opt -sroa -gvn -simplifycfg -instcombine -elim-avail-extern input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9813432835820897,3.185732364654541,opt -sroa -gvn -simplifycfg -instcombine -elim-avail-extern input.bc -o output.bc -benchmark://cBench-v1/susan,1.0053749680061435,24.814565896987915,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -elim-avail-extern -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/susan,1.0053749680061435,24.859406232833862,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -elim-avail-extern -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/susan,1.0053749680061435,24.87987756729126,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -elim-avail-extern -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/susan,1.0053749680061435,24.94978094100952,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -elim-avail-extern -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/susan,1.0053749680061435,25.079646348953247,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -elim-avail-extern -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/susan,1.0053749680061435,25.262638092041016,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -elim-avail-extern -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/susan,1.0053749680061435,25.379810571670532,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -elim-avail-extern -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/susan,1.0053749680061435,25.38713812828064,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -elim-avail-extern -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/susan,1.0053749680061435,25.631547212600708,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -elim-avail-extern -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/susan,1.0053749680061435,28.82014751434326,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -elim-avail-extern -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.0423725778143924,206.9493591785431,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading -gvn -jump-threading -newgvn input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.0423725778143924,207.85546779632568,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading -gvn -jump-threading -newgvn input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.0423725778143924,210.78826022148132,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading -gvn -jump-threading -newgvn input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.0423725778143924,212.0816934108734,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading -gvn -jump-threading -newgvn input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.0423725778143924,212.3042595386505,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading -gvn -jump-threading -newgvn input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.0423725778143924,212.96886539459229,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading -gvn -jump-threading -newgvn input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.0423725778143924,217.08278965950012,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading -gvn -jump-threading -newgvn input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.0423725778143924,221.63971638679504,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading -gvn -jump-threading -newgvn input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.0423725778143924,225.90823554992676,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading -gvn -jump-threading -newgvn input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.0423725778143924,246.46919798851013,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading -gvn -jump-threading -newgvn input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.042007755277897,175.83224821090698,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.042007755277897,176.67274570465088,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.042007755277897,179.36724948883057,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.042007755277897,180.25492811203003,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.042007755277897,181.93450570106506,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.042007755277897,182.94887852668762,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.042007755277897,183.34534311294556,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.042007755277897,183.8355176448822,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.042007755277897,186.5927677154541,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.042007755277897,207.1995928287506,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.042784025374856,185.1347677707672,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.042784025374856,185.2738618850708,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.042784025374856,185.6893789768219,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.042784025374856,187.23632884025574,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.042784025374856,187.24578022956848,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.042784025374856,187.73672819137573,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.042784025374856,188.05836939811707,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.042784025374856,188.25418829917908,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.042784025374856,188.62760400772095,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.042784025374856,222.01096987724304,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.0399576517195448,193.30142498016357,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.0399576517195448,194.35608434677124,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.0399576517195448,195.15333223342896,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.0399576517195448,195.2966709136963,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.0399576517195448,195.76737356185913,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.0399576517195448,195.93066239356995,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.0399576517195448,200.3739206790924,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.0399576517195448,201.457839012146,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.0399576517195448,202.99476194381714,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.0399576517195448,228.2633593082428,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9748603351955308,2.6167967319488525,opt -sroa -simplifycfg -early-cse-memssa -jump-threading -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9748603351955308,2.6323108673095703,opt -sroa -simplifycfg -early-cse-memssa -jump-threading -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9748603351955308,2.632906675338745,opt -sroa -simplifycfg -early-cse-memssa -jump-threading -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9748603351955308,2.6446733474731445,opt -sroa -simplifycfg -early-cse-memssa -jump-threading -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9748603351955308,2.65216326713562,opt -sroa -simplifycfg -early-cse-memssa -jump-threading -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9748603351955308,2.656970739364624,opt -sroa -simplifycfg -early-cse-memssa -jump-threading -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9748603351955308,2.661275625228882,opt -sroa -simplifycfg -early-cse-memssa -jump-threading -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9748603351955308,2.6938230991363525,opt -sroa -simplifycfg -early-cse-memssa -jump-threading -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9748603351955308,3.050021171569824,opt -sroa -simplifycfg -early-cse-memssa -jump-threading -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9748603351955308,3.102595806121826,opt -sroa -simplifycfg -early-cse-memssa -jump-threading -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0132743362831858,4.658697843551636,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -elim-avail-extern -tailcallelim input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0132743362831858,4.6678147315979,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -elim-avail-extern -tailcallelim input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0132743362831858,4.669229984283447,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -elim-avail-extern -tailcallelim input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0132743362831858,4.674164533615112,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -elim-avail-extern -tailcallelim input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0132743362831858,4.675281047821045,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -elim-avail-extern -tailcallelim input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0132743362831858,4.692632436752319,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -elim-avail-extern -tailcallelim input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0132743362831858,4.72410249710083,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -elim-avail-extern -tailcallelim input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0132743362831858,4.738322973251343,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -elim-avail-extern -tailcallelim input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0132743362831858,5.429574012756348,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -elim-avail-extern -tailcallelim input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0132743362831858,5.552142143249512,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -elim-avail-extern -tailcallelim input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0305343511450382,8.000561714172363,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0305343511450382,8.013018369674683,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0305343511450382,8.015228033065796,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0305343511450382,8.043203353881836,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0305343511450382,8.049434900283813,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0305343511450382,8.072939395904541,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0305343511450382,8.140095472335815,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0305343511450382,8.566433668136597,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0305343511450382,8.841854333877563,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0305343511450382,9.593023538589478,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.2088736134978917,74.5777907371521,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -ipsccp -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -elim-avail-extern -prune-eh -simplifycfg -mldst-motion -instcombine -tailcallelim -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.2088736134978917,74.68991255760193,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -ipsccp -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -elim-avail-extern -prune-eh -simplifycfg -mldst-motion -instcombine -tailcallelim -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.2088736134978917,75.3055009841919,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -ipsccp -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -elim-avail-extern -prune-eh -simplifycfg -mldst-motion -instcombine -tailcallelim -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.2088736134978917,75.61981582641602,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -ipsccp -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -elim-avail-extern -prune-eh -simplifycfg -mldst-motion -instcombine -tailcallelim -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.2088736134978917,75.74971032142639,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -ipsccp -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -elim-avail-extern -prune-eh -simplifycfg -mldst-motion -instcombine -tailcallelim -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.2088736134978917,75.85093307495117,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -ipsccp -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -elim-avail-extern -prune-eh -simplifycfg -mldst-motion -instcombine -tailcallelim -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.2088736134978917,75.92890071868896,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -ipsccp -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -elim-avail-extern -prune-eh -simplifycfg -mldst-motion -instcombine -tailcallelim -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.2088736134978917,76.07783126831055,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -ipsccp -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -elim-avail-extern -prune-eh -simplifycfg -mldst-motion -instcombine -tailcallelim -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.2088736134978917,76.28789138793945,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -ipsccp -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -elim-avail-extern -prune-eh -simplifycfg -mldst-motion -instcombine -tailcallelim -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.2088736134978917,89.29922342300415,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -ipsccp -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -elim-avail-extern -prune-eh -simplifycfg -mldst-motion -instcombine -tailcallelim -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,2.061441421508789,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,2.063772678375244,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,2.0638957023620605,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,2.069030284881592,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,2.0694191455841064,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,2.10876202583313,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,2.418781042098999,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,2.4249207973480225,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,2.430199146270752,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,2.4578709602355957,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.979591836734694,2.81844162940979,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.979591836734694,2.826531410217285,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.979591836734694,2.827880382537842,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.979591836734694,2.8283395767211914,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.979591836734694,2.8406713008880615,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.979591836734694,2.865175485610962,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.979591836734694,3.1737499237060547,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.979591836734694,3.198945999145508,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.979591836734694,3.204514265060425,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.979591836734694,3.337878942489624,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/ghostscript,1.0217193660340413,2140.6080310344696,opt -sroa -gvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -instcombine -simplifycfg -mergefunc -ipsccp -mldst-motion -newgvn -instcombine -simplifycfg -memcpyopt -bdce -dse -instcombine -nary-reassociate -ipsccp -newgvn -globaldce -gvn-hoist -mem2reg -mldst-motion -simplifycfg -dse -prune-eh -instcombine -simplifycfg -early-cse-memssa -mldst-motion -elim-avail-extern -slsr -newgvn -mldst-motion input.bc -o output.bc +benchmark://cbench-v1/ghostscript,1.0217193660340413,2146.9346401691437,opt -sroa -gvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -instcombine -simplifycfg -mergefunc -ipsccp -mldst-motion -newgvn -instcombine -simplifycfg -memcpyopt -bdce -dse -instcombine -nary-reassociate -ipsccp -newgvn -globaldce -gvn-hoist -mem2reg -mldst-motion -simplifycfg -dse -prune-eh -instcombine -simplifycfg -early-cse-memssa -mldst-motion -elim-avail-extern -slsr -newgvn -mldst-motion input.bc -o output.bc +benchmark://cbench-v1/ghostscript,1.0217193660340413,2152.0892202854156,opt -sroa -gvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -instcombine -simplifycfg -mergefunc -ipsccp -mldst-motion -newgvn -instcombine -simplifycfg -memcpyopt -bdce -dse -instcombine -nary-reassociate -ipsccp -newgvn -globaldce -gvn-hoist -mem2reg -mldst-motion -simplifycfg -dse -prune-eh -instcombine -simplifycfg -early-cse-memssa -mldst-motion -elim-avail-extern -slsr -newgvn -mldst-motion input.bc -o output.bc +benchmark://cbench-v1/ghostscript,1.0217193660340413,2159.1251413822174,opt -sroa -gvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -instcombine -simplifycfg -mergefunc -ipsccp -mldst-motion -newgvn -instcombine -simplifycfg -memcpyopt -bdce -dse -instcombine -nary-reassociate -ipsccp -newgvn -globaldce -gvn-hoist -mem2reg -mldst-motion -simplifycfg -dse -prune-eh -instcombine -simplifycfg -early-cse-memssa -mldst-motion -elim-avail-extern -slsr -newgvn -mldst-motion input.bc -o output.bc +benchmark://cbench-v1/ghostscript,1.0217193660340413,2161.40825343132,opt -sroa -gvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -instcombine -simplifycfg -mergefunc -ipsccp -mldst-motion -newgvn -instcombine -simplifycfg -memcpyopt -bdce -dse -instcombine -nary-reassociate -ipsccp -newgvn -globaldce -gvn-hoist -mem2reg -mldst-motion -simplifycfg -dse -prune-eh -instcombine -simplifycfg -early-cse-memssa -mldst-motion -elim-avail-extern -slsr -newgvn -mldst-motion input.bc -o output.bc +benchmark://cbench-v1/ghostscript,1.0217193660340413,2165.3180038928986,opt -sroa -gvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -instcombine -simplifycfg -mergefunc -ipsccp -mldst-motion -newgvn -instcombine -simplifycfg -memcpyopt -bdce -dse -instcombine -nary-reassociate -ipsccp -newgvn -globaldce -gvn-hoist -mem2reg -mldst-motion -simplifycfg -dse -prune-eh -instcombine -simplifycfg -early-cse-memssa -mldst-motion -elim-avail-extern -slsr -newgvn -mldst-motion input.bc -o output.bc +benchmark://cbench-v1/ghostscript,1.0217193660340413,2186.7724907398224,opt -sroa -gvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -instcombine -simplifycfg -mergefunc -ipsccp -mldst-motion -newgvn -instcombine -simplifycfg -memcpyopt -bdce -dse -instcombine -nary-reassociate -ipsccp -newgvn -globaldce -gvn-hoist -mem2reg -mldst-motion -simplifycfg -dse -prune-eh -instcombine -simplifycfg -early-cse-memssa -mldst-motion -elim-avail-extern -slsr -newgvn -mldst-motion input.bc -o output.bc +benchmark://cbench-v1/ghostscript,1.0217193660340413,2207.689845561981,opt -sroa -gvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -instcombine -simplifycfg -mergefunc -ipsccp -mldst-motion -newgvn -instcombine -simplifycfg -memcpyopt -bdce -dse -instcombine -nary-reassociate -ipsccp -newgvn -globaldce -gvn-hoist -mem2reg -mldst-motion -simplifycfg -dse -prune-eh -instcombine -simplifycfg -early-cse-memssa -mldst-motion -elim-avail-extern -slsr -newgvn -mldst-motion input.bc -o output.bc +benchmark://cbench-v1/ghostscript,1.0217193660340413,2208.390825986862,opt -sroa -gvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -instcombine -simplifycfg -mergefunc -ipsccp -mldst-motion -newgvn -instcombine -simplifycfg -memcpyopt -bdce -dse -instcombine -nary-reassociate -ipsccp -newgvn -globaldce -gvn-hoist -mem2reg -mldst-motion -simplifycfg -dse -prune-eh -instcombine -simplifycfg -early-cse-memssa -mldst-motion -elim-avail-extern -slsr -newgvn -mldst-motion input.bc -o output.bc +benchmark://cbench-v1/ghostscript,1.0217193660340413,2371.4824783802032,opt -sroa -gvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -instcombine -simplifycfg -mergefunc -ipsccp -mldst-motion -newgvn -instcombine -simplifycfg -memcpyopt -bdce -dse -instcombine -nary-reassociate -ipsccp -newgvn -globaldce -gvn-hoist -mem2reg -mldst-motion -simplifycfg -dse -prune-eh -instcombine -simplifycfg -early-cse-memssa -mldst-motion -elim-avail-extern -slsr -newgvn -mldst-motion input.bc -o output.bc +benchmark://cbench-v1/gsm,1.106947211155379,40.79212260246277,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -elim-avail-extern -nary-reassociate -ipsccp -gvn-hoist -instcombine -simplifycfg -prune-eh input.bc -o output.bc +benchmark://cbench-v1/gsm,1.106947211155379,40.92847776412964,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -elim-avail-extern -nary-reassociate -ipsccp -gvn-hoist -instcombine -simplifycfg -prune-eh input.bc -o output.bc +benchmark://cbench-v1/gsm,1.106947211155379,41.038567543029785,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -elim-avail-extern -nary-reassociate -ipsccp -gvn-hoist -instcombine -simplifycfg -prune-eh input.bc -o output.bc +benchmark://cbench-v1/gsm,1.106947211155379,41.05518436431885,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -elim-avail-extern -nary-reassociate -ipsccp -gvn-hoist -instcombine -simplifycfg -prune-eh input.bc -o output.bc +benchmark://cbench-v1/gsm,1.106947211155379,41.592167139053345,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -elim-avail-extern -nary-reassociate -ipsccp -gvn-hoist -instcombine -simplifycfg -prune-eh input.bc -o output.bc +benchmark://cbench-v1/gsm,1.106947211155379,41.628905057907104,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -elim-avail-extern -nary-reassociate -ipsccp -gvn-hoist -instcombine -simplifycfg -prune-eh input.bc -o output.bc +benchmark://cbench-v1/gsm,1.106947211155379,42.249706983566284,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -elim-avail-extern -nary-reassociate -ipsccp -gvn-hoist -instcombine -simplifycfg -prune-eh input.bc -o output.bc +benchmark://cbench-v1/gsm,1.106947211155379,42.33488631248474,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -elim-avail-extern -nary-reassociate -ipsccp -gvn-hoist -instcombine -simplifycfg -prune-eh input.bc -o output.bc +benchmark://cbench-v1/gsm,1.106947211155379,43.1302855014801,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -elim-avail-extern -nary-reassociate -ipsccp -gvn-hoist -instcombine -simplifycfg -prune-eh input.bc -o output.bc +benchmark://cbench-v1/gsm,1.106947211155379,49.03903365135193,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -elim-avail-extern -nary-reassociate -ipsccp -gvn-hoist -instcombine -simplifycfg -prune-eh input.bc -o output.bc +benchmark://cbench-v1/ispell,1.019985925404645,68.98562455177307,opt -sroa -newgvn -simplifycfg -instcombine -newgvn -simplifycfg -elim-avail-extern -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -newgvn -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -prune-eh -newgvn -simplifycfg -mldst-motion -jump-threading input.bc -o output.bc +benchmark://cbench-v1/ispell,1.019985925404645,69.6540629863739,opt -sroa -newgvn -simplifycfg -instcombine -newgvn -simplifycfg -elim-avail-extern -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -newgvn -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -prune-eh -newgvn -simplifycfg -mldst-motion -jump-threading input.bc -o output.bc +benchmark://cbench-v1/ispell,1.019985925404645,69.68867444992065,opt -sroa -newgvn -simplifycfg -instcombine -newgvn -simplifycfg -elim-avail-extern -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -newgvn -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -prune-eh -newgvn -simplifycfg -mldst-motion -jump-threading input.bc -o output.bc +benchmark://cbench-v1/ispell,1.019985925404645,70.07287931442261,opt -sroa -newgvn -simplifycfg -instcombine -newgvn -simplifycfg -elim-avail-extern -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -newgvn -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -prune-eh -newgvn -simplifycfg -mldst-motion -jump-threading input.bc -o output.bc +benchmark://cbench-v1/ispell,1.019985925404645,70.29381346702576,opt -sroa -newgvn -simplifycfg -instcombine -newgvn -simplifycfg -elim-avail-extern -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -newgvn -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -prune-eh -newgvn -simplifycfg -mldst-motion -jump-threading input.bc -o output.bc +benchmark://cbench-v1/ispell,1.019985925404645,70.60475730895996,opt -sroa -newgvn -simplifycfg -instcombine -newgvn -simplifycfg -elim-avail-extern -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -newgvn -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -prune-eh -newgvn -simplifycfg -mldst-motion -jump-threading input.bc -o output.bc +benchmark://cbench-v1/ispell,1.019985925404645,70.69765996932983,opt -sroa -newgvn -simplifycfg -instcombine -newgvn -simplifycfg -elim-avail-extern -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -newgvn -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -prune-eh -newgvn -simplifycfg -mldst-motion -jump-threading input.bc -o output.bc +benchmark://cbench-v1/ispell,1.019985925404645,70.92285132408142,opt -sroa -newgvn -simplifycfg -instcombine -newgvn -simplifycfg -elim-avail-extern -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -newgvn -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -prune-eh -newgvn -simplifycfg -mldst-motion -jump-threading input.bc -o output.bc +benchmark://cbench-v1/ispell,1.019985925404645,71.1001365184784,opt -sroa -newgvn -simplifycfg -instcombine -newgvn -simplifycfg -elim-avail-extern -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -newgvn -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -prune-eh -newgvn -simplifycfg -mldst-motion -jump-threading input.bc -o output.bc +benchmark://cbench-v1/ispell,1.019985925404645,80.4593243598938,opt -sroa -newgvn -simplifycfg -instcombine -newgvn -simplifycfg -elim-avail-extern -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -newgvn -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -prune-eh -newgvn -simplifycfg -mldst-motion -jump-threading input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0374492358247827,231.60082149505615,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -elim-avail-extern -mldst-motion -lower-constant-intrinsics -mldst-motion -ipsccp -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -correlated-propagation -newgvn -slsr -newgvn -globaldce -gvn-hoist -newgvn -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0374492358247827,231.77300357818604,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -elim-avail-extern -mldst-motion -lower-constant-intrinsics -mldst-motion -ipsccp -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -correlated-propagation -newgvn -slsr -newgvn -globaldce -gvn-hoist -newgvn -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0374492358247827,238.08568453788757,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -elim-avail-extern -mldst-motion -lower-constant-intrinsics -mldst-motion -ipsccp -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -correlated-propagation -newgvn -slsr -newgvn -globaldce -gvn-hoist -newgvn -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0374492358247827,238.2811233997345,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -elim-avail-extern -mldst-motion -lower-constant-intrinsics -mldst-motion -ipsccp -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -correlated-propagation -newgvn -slsr -newgvn -globaldce -gvn-hoist -newgvn -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0374492358247827,240.15624928474426,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -elim-avail-extern -mldst-motion -lower-constant-intrinsics -mldst-motion -ipsccp -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -correlated-propagation -newgvn -slsr -newgvn -globaldce -gvn-hoist -newgvn -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0374492358247827,240.99767327308655,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -elim-avail-extern -mldst-motion -lower-constant-intrinsics -mldst-motion -ipsccp -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -correlated-propagation -newgvn -slsr -newgvn -globaldce -gvn-hoist -newgvn -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0374492358247827,242.14424967765808,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -elim-avail-extern -mldst-motion -lower-constant-intrinsics -mldst-motion -ipsccp -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -correlated-propagation -newgvn -slsr -newgvn -globaldce -gvn-hoist -newgvn -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0374492358247827,242.46206092834473,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -elim-avail-extern -mldst-motion -lower-constant-intrinsics -mldst-motion -ipsccp -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -correlated-propagation -newgvn -slsr -newgvn -globaldce -gvn-hoist -newgvn -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0374492358247827,242.51537442207336,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -elim-avail-extern -mldst-motion -lower-constant-intrinsics -mldst-motion -ipsccp -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -correlated-propagation -newgvn -slsr -newgvn -globaldce -gvn-hoist -newgvn -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0374492358247827,275.1627869606018,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -elim-avail-extern -mldst-motion -lower-constant-intrinsics -mldst-motion -ipsccp -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -correlated-propagation -newgvn -slsr -newgvn -globaldce -gvn-hoist -newgvn -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0388615216201431,197.58089399337769,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -simplifycfg -instcombine -mergefunc -nary-reassociate -memcpyopt -newgvn -elim-avail-extern -mldst-motion -mldst-motion -lower-constant-intrinsics -simplifycfg -mldst-motion -ipsccp -newgvn -mldst-motion -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0388615216201431,201.74994444847107,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -simplifycfg -instcombine -mergefunc -nary-reassociate -memcpyopt -newgvn -elim-avail-extern -mldst-motion -mldst-motion -lower-constant-intrinsics -simplifycfg -mldst-motion -ipsccp -newgvn -mldst-motion -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0388615216201431,202.76921606063843,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -simplifycfg -instcombine -mergefunc -nary-reassociate -memcpyopt -newgvn -elim-avail-extern -mldst-motion -mldst-motion -lower-constant-intrinsics -simplifycfg -mldst-motion -ipsccp -newgvn -mldst-motion -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0388615216201431,203.09221363067627,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -simplifycfg -instcombine -mergefunc -nary-reassociate -memcpyopt -newgvn -elim-avail-extern -mldst-motion -mldst-motion -lower-constant-intrinsics -simplifycfg -mldst-motion -ipsccp -newgvn -mldst-motion -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0388615216201431,203.26621675491333,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -simplifycfg -instcombine -mergefunc -nary-reassociate -memcpyopt -newgvn -elim-avail-extern -mldst-motion -mldst-motion -lower-constant-intrinsics -simplifycfg -mldst-motion -ipsccp -newgvn -mldst-motion -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0388615216201431,204.81071066856384,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -simplifycfg -instcombine -mergefunc -nary-reassociate -memcpyopt -newgvn -elim-avail-extern -mldst-motion -mldst-motion -lower-constant-intrinsics -simplifycfg -mldst-motion -ipsccp -newgvn -mldst-motion -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0388615216201431,205.38714623451233,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -simplifycfg -instcombine -mergefunc -nary-reassociate -memcpyopt -newgvn -elim-avail-extern -mldst-motion -mldst-motion -lower-constant-intrinsics -simplifycfg -mldst-motion -ipsccp -newgvn -mldst-motion -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0388615216201431,206.71245503425598,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -simplifycfg -instcombine -mergefunc -nary-reassociate -memcpyopt -newgvn -elim-avail-extern -mldst-motion -mldst-motion -lower-constant-intrinsics -simplifycfg -mldst-motion -ipsccp -newgvn -mldst-motion -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0388615216201431,207.26565623283386,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -simplifycfg -instcombine -mergefunc -nary-reassociate -memcpyopt -newgvn -elim-avail-extern -mldst-motion -mldst-motion -lower-constant-intrinsics -simplifycfg -mldst-motion -ipsccp -newgvn -mldst-motion -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0388615216201431,236.7751350402832,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn-hoist -simplifycfg -instcombine -mergefunc -nary-reassociate -memcpyopt -newgvn -elim-avail-extern -mldst-motion -mldst-motion -lower-constant-intrinsics -simplifycfg -mldst-motion -ipsccp -newgvn -mldst-motion -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/lame,1.0658164427237529,181.06120204925537,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -nary-reassociate -gvn-hoist -bdce -jump-threading -instcombine -ipsccp -memcpyopt -newgvn -dse -simplifycfg -mldst-motion -globalopt -instcombine -simplifycfg -newgvn -elim-avail-extern -prune-eh -mergefunc -instsimplify -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc +benchmark://cbench-v1/lame,1.0658164427237529,184.7970871925354,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -nary-reassociate -gvn-hoist -bdce -jump-threading -instcombine -ipsccp -memcpyopt -newgvn -dse -simplifycfg -mldst-motion -globalopt -instcombine -simplifycfg -newgvn -elim-avail-extern -prune-eh -mergefunc -instsimplify -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc +benchmark://cbench-v1/lame,1.0658164427237529,187.30368876457214,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -nary-reassociate -gvn-hoist -bdce -jump-threading -instcombine -ipsccp -memcpyopt -newgvn -dse -simplifycfg -mldst-motion -globalopt -instcombine -simplifycfg -newgvn -elim-avail-extern -prune-eh -mergefunc -instsimplify -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc +benchmark://cbench-v1/lame,1.0658164427237529,188.11193895339966,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -nary-reassociate -gvn-hoist -bdce -jump-threading -instcombine -ipsccp -memcpyopt -newgvn -dse -simplifycfg -mldst-motion -globalopt -instcombine -simplifycfg -newgvn -elim-avail-extern -prune-eh -mergefunc -instsimplify -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc +benchmark://cbench-v1/lame,1.0658164427237529,188.78753519058228,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -nary-reassociate -gvn-hoist -bdce -jump-threading -instcombine -ipsccp -memcpyopt -newgvn -dse -simplifycfg -mldst-motion -globalopt -instcombine -simplifycfg -newgvn -elim-avail-extern -prune-eh -mergefunc -instsimplify -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc +benchmark://cbench-v1/lame,1.0658164427237529,189.2517716884613,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -nary-reassociate -gvn-hoist -bdce -jump-threading -instcombine -ipsccp -memcpyopt -newgvn -dse -simplifycfg -mldst-motion -globalopt -instcombine -simplifycfg -newgvn -elim-avail-extern -prune-eh -mergefunc -instsimplify -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc +benchmark://cbench-v1/lame,1.0658164427237529,190.45842099189758,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -nary-reassociate -gvn-hoist -bdce -jump-threading -instcombine -ipsccp -memcpyopt -newgvn -dse -simplifycfg -mldst-motion -globalopt -instcombine -simplifycfg -newgvn -elim-avail-extern -prune-eh -mergefunc -instsimplify -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc +benchmark://cbench-v1/lame,1.0658164427237529,190.51102375984192,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -nary-reassociate -gvn-hoist -bdce -jump-threading -instcombine -ipsccp -memcpyopt -newgvn -dse -simplifycfg -mldst-motion -globalopt -instcombine -simplifycfg -newgvn -elim-avail-extern -prune-eh -mergefunc -instsimplify -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc +benchmark://cbench-v1/lame,1.0658164427237529,191.6278738975525,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -nary-reassociate -gvn-hoist -bdce -jump-threading -instcombine -ipsccp -memcpyopt -newgvn -dse -simplifycfg -mldst-motion -globalopt -instcombine -simplifycfg -newgvn -elim-avail-extern -prune-eh -mergefunc -instsimplify -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc +benchmark://cbench-v1/lame,1.0658164427237529,217.91625666618347,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -nary-reassociate -gvn-hoist -bdce -jump-threading -instcombine -ipsccp -memcpyopt -newgvn -dse -simplifycfg -mldst-motion -globalopt -instcombine -simplifycfg -newgvn -elim-avail-extern -prune-eh -mergefunc -instsimplify -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9799777530589544,4.072362661361694,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9799777530589544,4.12520170211792,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9799777530589544,4.162842273712158,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9799777530589544,4.674448251724243,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9799777530589544,4.691532135009766,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9799777530589544,4.693127632141113,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9799777530589544,4.700468063354492,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9799777530589544,4.735736131668091,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9799777530589544,4.784304857254028,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9799777530589544,5.011373996734619,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc +benchmark://cbench-v1/qsort,1.1362229102167183,3.617689371109009,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/qsort,1.1362229102167183,3.627746105194092,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/qsort,1.1362229102167183,3.6945436000823975,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/qsort,1.1362229102167183,4.168741226196289,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/qsort,1.1362229102167183,4.213088274002075,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/qsort,1.1362229102167183,4.214311599731445,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/qsort,1.1362229102167183,4.229600191116333,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/qsort,1.1362229102167183,4.246491432189941,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/qsort,1.1362229102167183,4.304184913635254,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/qsort,1.1362229102167183,4.322846174240112,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1050210808738983,10.104260921478271,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1050210808738983,10.33758807182312,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1050210808738983,10.37963604927063,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1050210808738983,10.791464805603027,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1050210808738983,10.793577432632446,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1050210808738983,10.801882028579712,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1050210808738983,10.809131860733032,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1050210808738983,10.939861059188843,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1050210808738983,11.007495880126953,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1050210808738983,12.216138124465942,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc +benchmark://cbench-v1/sha,1.4749163879598661,3.296888589859009,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc +benchmark://cbench-v1/sha,1.4749163879598661,3.339097023010254,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc +benchmark://cbench-v1/sha,1.4749163879598661,3.3705661296844482,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc +benchmark://cbench-v1/sha,1.4749163879598661,3.7465083599090576,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc +benchmark://cbench-v1/sha,1.4749163879598661,3.784933090209961,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc +benchmark://cbench-v1/sha,1.4749163879598661,3.785313606262207,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc +benchmark://cbench-v1/sha,1.4749163879598661,3.794675827026367,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc +benchmark://cbench-v1/sha,1.4749163879598661,3.796710968017578,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc +benchmark://cbench-v1/sha,1.4749163879598661,3.8460588455200195,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc +benchmark://cbench-v1/sha,1.4749163879598661,3.9928929805755615,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0109289617486337,6.248675346374512,opt -sroa -newgvn -simplifycfg -instcombine -elim-avail-extern -jump-threading -lower-constant-intrinsics -gvn -gvn-hoist -newgvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0109289617486337,6.2487945556640625,opt -sroa -newgvn -simplifycfg -instcombine -elim-avail-extern -jump-threading -lower-constant-intrinsics -gvn -gvn-hoist -newgvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0109289617486337,6.303280591964722,opt -sroa -newgvn -simplifycfg -instcombine -elim-avail-extern -jump-threading -lower-constant-intrinsics -gvn -gvn-hoist -newgvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0109289617486337,7.014445543289185,opt -sroa -newgvn -simplifycfg -instcombine -elim-avail-extern -jump-threading -lower-constant-intrinsics -gvn -gvn-hoist -newgvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0109289617486337,7.057801961898804,opt -sroa -newgvn -simplifycfg -instcombine -elim-avail-extern -jump-threading -lower-constant-intrinsics -gvn -gvn-hoist -newgvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0109289617486337,7.113065242767334,opt -sroa -newgvn -simplifycfg -instcombine -elim-avail-extern -jump-threading -lower-constant-intrinsics -gvn -gvn-hoist -newgvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0109289617486337,7.117478609085083,opt -sroa -newgvn -simplifycfg -instcombine -elim-avail-extern -jump-threading -lower-constant-intrinsics -gvn -gvn-hoist -newgvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0109289617486337,7.162009954452515,opt -sroa -newgvn -simplifycfg -instcombine -elim-avail-extern -jump-threading -lower-constant-intrinsics -gvn -gvn-hoist -newgvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0109289617486337,7.254070997238159,opt -sroa -newgvn -simplifycfg -instcombine -elim-avail-extern -jump-threading -lower-constant-intrinsics -gvn -gvn-hoist -newgvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0109289617486337,7.473099708557129,opt -sroa -newgvn -simplifycfg -instcombine -elim-avail-extern -jump-threading -lower-constant-intrinsics -gvn -gvn-hoist -newgvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9813432835820897,2.699200391769409,opt -sroa -gvn -simplifycfg -instcombine -elim-avail-extern input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9813432835820897,2.7258427143096924,opt -sroa -gvn -simplifycfg -instcombine -elim-avail-extern input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9813432835820897,2.727332353591919,opt -sroa -gvn -simplifycfg -instcombine -elim-avail-extern input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9813432835820897,2.7604801654815674,opt -sroa -gvn -simplifycfg -instcombine -elim-avail-extern input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9813432835820897,3.0859103202819824,opt -sroa -gvn -simplifycfg -instcombine -elim-avail-extern input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9813432835820897,3.139512777328491,opt -sroa -gvn -simplifycfg -instcombine -elim-avail-extern input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9813432835820897,3.140896797180176,opt -sroa -gvn -simplifycfg -instcombine -elim-avail-extern input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9813432835820897,3.1499648094177246,opt -sroa -gvn -simplifycfg -instcombine -elim-avail-extern input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9813432835820897,3.163114070892334,opt -sroa -gvn -simplifycfg -instcombine -elim-avail-extern input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9813432835820897,3.185732364654541,opt -sroa -gvn -simplifycfg -instcombine -elim-avail-extern input.bc -o output.bc +benchmark://cbench-v1/susan,1.0053749680061435,24.814565896987915,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -elim-avail-extern -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/susan,1.0053749680061435,24.859406232833862,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -elim-avail-extern -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/susan,1.0053749680061435,24.87987756729126,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -elim-avail-extern -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/susan,1.0053749680061435,24.94978094100952,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -elim-avail-extern -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/susan,1.0053749680061435,25.079646348953247,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -elim-avail-extern -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/susan,1.0053749680061435,25.262638092041016,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -elim-avail-extern -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/susan,1.0053749680061435,25.379810571670532,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -elim-avail-extern -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/susan,1.0053749680061435,25.38713812828064,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -elim-avail-extern -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/susan,1.0053749680061435,25.631547212600708,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -elim-avail-extern -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/susan,1.0053749680061435,28.82014751434326,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -elim-avail-extern -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0423725778143924,206.9493591785431,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading -gvn -jump-threading -newgvn input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0423725778143924,207.85546779632568,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading -gvn -jump-threading -newgvn input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0423725778143924,210.78826022148132,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading -gvn -jump-threading -newgvn input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0423725778143924,212.0816934108734,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading -gvn -jump-threading -newgvn input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0423725778143924,212.3042595386505,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading -gvn -jump-threading -newgvn input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0423725778143924,212.96886539459229,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading -gvn -jump-threading -newgvn input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0423725778143924,217.08278965950012,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading -gvn -jump-threading -newgvn input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0423725778143924,221.63971638679504,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading -gvn -jump-threading -newgvn input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0423725778143924,225.90823554992676,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading -gvn -jump-threading -newgvn input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0423725778143924,246.46919798851013,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading -gvn -jump-threading -newgvn input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.042007755277897,175.83224821090698,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.042007755277897,176.67274570465088,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.042007755277897,179.36724948883057,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.042007755277897,180.25492811203003,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.042007755277897,181.93450570106506,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.042007755277897,182.94887852668762,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.042007755277897,183.34534311294556,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.042007755277897,183.8355176448822,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.042007755277897,186.5927677154541,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.042007755277897,207.1995928287506,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.042784025374856,185.1347677707672,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.042784025374856,185.2738618850708,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.042784025374856,185.6893789768219,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.042784025374856,187.23632884025574,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.042784025374856,187.24578022956848,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.042784025374856,187.73672819137573,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.042784025374856,188.05836939811707,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.042784025374856,188.25418829917908,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.042784025374856,188.62760400772095,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.042784025374856,222.01096987724304,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -jump-threading -newgvn -ipsccp -simplifycfg -slp-vectorizer -instcombine -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0399576517195448,193.30142498016357,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0399576517195448,194.35608434677124,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0399576517195448,195.15333223342896,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0399576517195448,195.2966709136963,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0399576517195448,195.76737356185913,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0399576517195448,195.93066239356995,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0399576517195448,200.3739206790924,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0399576517195448,201.457839012146,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0399576517195448,202.99476194381714,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0399576517195448,228.2633593082428,opt -sroa -gvn -simplifycfg -instcombine -newgvn -jump-threading -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -jump-threading -simplifycfg -mldst-motion -elim-avail-extern -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -jump-threading input.bc -o output.bc diff --git a/leaderboard/llvm_instcount/e_greedy/results_e10.csv b/leaderboard/llvm_instcount/e_greedy/results_e10.csv index e61a48a63..281c8f778 100644 --- a/leaderboard/llvm_instcount/e_greedy/results_e10.csv +++ b/leaderboard/llvm_instcount/e_greedy/results_e10.csv @@ -1,231 +1,231 @@ benchmark,reward,walltime,commandline -benchmark://cBench-v0/adpcm,0.9999999999999998,3.3471643924713135,opt -sroa -simplifycfg -early-cse-memssa -instcombine -sroa -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v0/adpcm,0.9999999999999998,3.305574417114258,opt -sroa -simplifycfg -loop-reroll -early-cse-memssa -instcombine -sroa -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/adpcm,0.9999999999999998,3.324244499206543,opt -sroa -simplifycfg -early-cse-memssa -instcombine -lcssa -newgvn -sroa -jump-threading input.bc -o output.bc -benchmark://cBench-v0/adpcm,0.9999999999999998,3.299079656600952,opt -sroa -simplifycfg -loop-predication -early-cse-memssa -instcombine -sroa -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/adpcm,0.9999999999999998,3.377950668334961,opt -sroa -simplifycfg -early-cse-memssa -instcombine -sroa -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v0/adpcm,0.9999999999999998,3.3638758659362793,opt -sroa -simplifycfg -early-cse-memssa -instcombine -sroa -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v0/adpcm,0.9999999999999998,3.332183361053467,opt -sroa -simplifycfg -early-cse-memssa -instcombine -sroa -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v0/adpcm,0.9999999999999998,3.319218873977661,opt -sroa -simplifycfg -early-cse-memssa -instcombine -sroa -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v0/adpcm,0.9999999999999998,3.2783472537994385,opt -sroa -simplifycfg -early-cse-memssa -instcombine -sroa -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v0/adpcm,0.9999999999999998,3.307706356048584,opt -sroa -simplifycfg -early-cse-memssa -instcombine -forceattrs -sroa -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v0/bitcount,1.0140845070422535,3.8666810989379883,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -tailcallelim input.bc -o output.bc -benchmark://cBench-v0/bitcount,1.0140845070422535,3.8608546257019043,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -tailcallelim input.bc -o output.bc -benchmark://cBench-v0/bitcount,1.0140845070422535,3.8102853298187256,opt -loop-unroll-and-jam -mem2reg -instcombine -simplifycfg -newgvn -sroa -globalopt -instcombine -gvn-hoist -tailcallelim input.bc -o output.bc -benchmark://cBench-v0/bitcount,1.0140845070422535,3.8933515548706055,opt -mem2reg -instcombine -simplifycfg -coro-split -newgvn -sroa -instcombine -tailcallelim input.bc -o output.bc -benchmark://cBench-v0/bitcount,1.0140845070422535,2.9114677906036377,opt -instcombine -sroa -instcombine -simplifycfg -newgvn -tailcallelim -lowerinvoke -mldst-motion input.bc -o output.bc -benchmark://cBench-v0/bitcount,1.0140845070422535,3.836970090866089,opt -mem2reg -instcombine -coro-split -simplifycfg -newgvn -sroa -instcombine -tailcallelim input.bc -o output.bc -benchmark://cBench-v0/bitcount,1.0140845070422535,3.8814189434051514,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -tailcallelim input.bc -o output.bc -benchmark://cBench-v0/bitcount,1.0140845070422535,3.8782660961151123,opt -ipconstprop -mem2reg -instcombine -simplifycfg -newgvn -mldst-motion -sroa -instcombine -tailcallelim input.bc -o output.bc -benchmark://cBench-v0/bitcount,1.0140845070422535,3.8800272941589355,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -tailcallelim input.bc -o output.bc -benchmark://cBench-v0/bitcount,1.0140845070422535,3.846477508544922,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -tailcallelim input.bc -o output.bc -benchmark://cBench-v0/blowfish,1.0232690124858117,8.110476970672607,opt -sroa -instcombine -newgvn -simplifycfg -loop-rotate -simplifycfg -instcombine -tailcallelim -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc -benchmark://cBench-v0/blowfish,1.0351872871736663,7.367157936096191,opt -sroa -instcombine -loop-simplify -newgvn -simplifycfg -instcombine -dse -strip-nondebug -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc -benchmark://cBench-v0/blowfish,1.0351872871736663,7.363828420639038,opt -sroa -instcombine -newgvn -lower-constant-intrinsics -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc -benchmark://cBench-v0/blowfish,1.0351872871736663,7.39405083656311,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc -benchmark://cBench-v0/blowfish,1.0351872871736663,7.37799596786499,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc -benchmark://cBench-v0/blowfish,1.0351872871736663,7.371485710144043,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc -benchmark://cBench-v0/blowfish,1.0351872871736663,7.369072198867798,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc -benchmark://cBench-v0/blowfish,1.0351872871736663,7.314395189285278,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc -benchmark://cBench-v0/blowfish,1.0351872871736663,7.367866277694702,opt -sroa -attributor -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -ipsccp -newgvn input.bc -o output.bc -benchmark://cBench-v0/blowfish,1.0351872871736663,7.394887208938599,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -constprop -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc -benchmark://cBench-v0/bzip2,1.0302307692307697,61.19139552116394,opt -sroa -gvn -simplifycfg -irce -instcombine -nary-reassociate -simplifycfg -newgvn -ipsccp -memcpyopt -instcombine -redundant-dbg-inst-elim -gvn-hoist -loop-versioning -jump-threading -early-cse-memssa -constmerge -dse -mergefunc -gvn-hoist -prune-eh -simplifycfg -mldst-motion -tailcallelim -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v0/bzip2,1.0321538461538464,59.12892007827759,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -ipsccp -newgvn -simplifycfg -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -memcpyopt -prune-eh -simplifycfg -mldst-motion -tailcallelim -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v0/bzip2,1.0301538461538464,64.346684217453,opt -sroa -insert-gcov-profiling -gvn -simplifycfg -instcombine -nary-reassociate -ipsccp -newgvn -simplifycfg -memcpyopt -instcombine -globaldce -loop-guard-widening -newgvn -simplifycfg -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -lowerinvoke -prune-eh -simplifycfg -mldst-motion -tailcallelim -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v0/bzip2,1.0302307692307695,57.54291582107544,opt -sroa -gvn -loop-deletion -simplifycfg -instcombine -nary-reassociate -simplifycfg -newgvn -ipsccp -memcpyopt -strip -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -gvn-hoist -prune-eh -simplifycfg -tailcallelim -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v0/bzip2,1.0303076923076924,59.354525327682495,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -ipsccp -gvn -simplifycfg -memcpyopt -tailcallelim -loop-versioning-licm -instcombine -simplifycfg -loop-predication -name-anon-globals -newgvn -simplifycfg -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -prune-eh -simplifycfg -name-anon-globals -newgvn -mldst-motion input.bc -o output.bc -benchmark://cBench-v0/bzip2,1.0406153846153852,71.96076917648315,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -ipsccp -newgvn -simplifycfg -memcpyopt -functionattrs -newgvn -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -instcombine -simplifycfg -loop-distribute -prune-eh -simplifycfg -mldst-motion -instnamer -globalopt -gvn-hoist -tailcallelim -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v0/bzip2,1.0301538461538464,64.51102471351624,opt -sroa -gvn -post-inline-ee-instrument -simplifycfg -instcombine -nary-reassociate -ipsccp -newgvn -simplifycfg -memcpyopt -instcombine -loop-load-elim -irce -newgvn -simplifycfg -gvn-hoist -jump-threading -early-cse-memssa -lower-widenable-condition -dse -mergefunc -prune-eh -simplifycfg -mldst-motion -tailcallelim -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v0/bzip2,1.0301538461538464,60.58538103103638,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -guard-widening -ipsccp -newgvn -simplifycfg -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -prune-eh -simplifycfg -mldst-motion -loop-simplify -simplifycfg -tailcallelim -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v0/bzip2,1.0394615384615389,69.45560908317566,opt -sroa -gvn -simplifycfg -slsr -coro-early -instcombine -nary-reassociate -ipsccp -jump-threading -early-cse-memssa -memcpyopt -instcombine -gvn-hoist -functionattrs -newgvn -simplifycfg -dse -loweratomic -mergefunc -instcombine -gvn-hoist -prune-eh -simplifycfg -lower-widenable-condition -newgvn -mldst-motion -globalopt -gvn-hoist -tailcallelim -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/bzip2,1.0321538461538464,57.45151472091675,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -ipsccp -newgvn -hotcoldsplit -simplifycfg -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -ipconstprop -mergefunc -prune-eh -simplifycfg -mldst-motion -tailcallelim -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v0/crc32,1.0,2.325608015060425,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v0/crc32,1.0,2.3096039295196533,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v0/crc32,1.0,2.311483860015869,opt -sroa -libcalls-shrinkwrap -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v0/crc32,1.0,2.306170701980591,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v0/crc32,1.0,2.30281925201416,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v0/crc32,1.0,2.323596954345703,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v0/crc32,1.0,2.3132190704345703,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v0/crc32,1.0,2.3064634799957275,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v0/crc32,1.0,2.2902536392211914,opt -sroa -gvn -simplifycfg -instcombine -flattencfg input.bc -o output.bc -benchmark://cBench-v0/crc32,1.0,2.332601547241211,opt -mergereturn -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v0/dijkstra,1.0193548387096774,3.082825183868408,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc -benchmark://cBench-v0/dijkstra,1.0193548387096774,3.0587315559387207,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc -benchmark://cBench-v0/dijkstra,1.0193548387096774,3.0633692741394043,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc -benchmark://cBench-v0/dijkstra,1.0193548387096774,3.0405640602111816,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc -benchmark://cBench-v0/dijkstra,1.0193548387096774,3.0435636043548584,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc -benchmark://cBench-v0/dijkstra,1.0193548387096774,3.050528049468994,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc -benchmark://cBench-v0/dijkstra,1.0193548387096774,3.0575389862060547,opt -sroa -newgvn -simplifycfg -instcombine -loweratomic -gvn-hoist -partial-inliner input.bc -o output.bc -benchmark://cBench-v0/dijkstra,1.0193548387096774,3.0271060466766357,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc -benchmark://cBench-v0/dijkstra,1.0193548387096774,3.0591702461242676,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc -benchmark://cBench-v0/dijkstra,0.935483870967742,4.069051742553711,opt -speculative-execution -sroa -newgvn -simplifycfg -instcombine -gvn-hoist -loop-rotate -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v0/ghostscript,1.0023535801575092,1957.73517537117,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -mergefunc -newgvn -ipsccp -simplifycfg -mldst-motion -instcombine -memcpyopt -instcombine -simplifycfg -dse -sroa -instcombine -ipsccp -newgvn -nary-reassociate -barrier -slp-vectorizer -instcombine -gvn-hoist -bdce -globaldce -early-cse-memssa -slp-vectorizer -mldst-motion -simplifycfg -deadargelim -bdce -dse -prune-eh -mldst-motion -slsr -newgvn -mldst-motion -mergefunc -instcombine -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/ghostscript,1.001570828385668,1778.0900359153748,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -mergefunc -newgvn -ipsccp -simplifycfg -coro-cleanup -mldst-motion -instcombine -memcpyopt -coro-elide -instcombine -simplifycfg -dse -sroa -instcombine -ipsccp -newgvn -nary-reassociate -slp-vectorizer -mergereturn -instcombine -simplifycfg -gvn-hoist -bdce -globaldce -early-cse-memssa -slp-vectorizer -mldst-motion -dse -prune-eh -simplifycfg -strip -newgvn -mldst-motion -slsr -newgvn -mldst-motion input.bc -o output.bc -benchmark://cBench-v0/ghostscript,1.002332280789568,2109.468429327011,opt -sroa -gvn -simplifycfg -instcombine -newgvn -loop-data-prefetch -simplifycfg -aggressive-instcombine -gvn-hoist -mergefunc -newgvn -ipsccp -simplifycfg -mldst-motion -instcombine -memcpyopt -instcombine -simplifycfg -dse -newgvn -instcombine -ipsccp -nary-reassociate -slp-vectorizer -instcombine -gvn-hoist -sroa -inline -globaldce -gvn -bdce -deadargelim -instcombine -simplifycfg -newgvn -slp-vectorizer -mldst-motion -gvn-hoist -early-cse-memssa -simplifycfg -bdce -dse -prune-eh -inferattrs -mldst-motion -slsr -newgvn -mldst-motion -mergefunc -instcombine -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/ghostscript,1.0021885100559647,2090.4159104824066,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -mergefunc -newgvn -ipsccp -simplifycfg -mldst-motion -instcombine -memcpyopt -instcombine -simplifycfg -dse -sroa -instcombine -ipsccp -load-store-vectorizer -instcombine -newgvn -slp-vectorizer -instcombine -gvn-hoist -simplifycfg -nary-reassociate -globaldce -loop-interchange -instcombine -hotcoldsplit -simplifycfg -early-cse-memssa -bdce -mergefunc -mldst-motion -dse -simplifycfg -prune-eh -newgvn -globaldce -gvn-hoist -mldst-motion -slsr -newgvn -mldst-motion input.bc -o output.bc -benchmark://cBench-v0/ghostscript,1.007662447616867,3265.486672401428,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -mergefunc -newgvn -ipsccp -simplifycfg -mldst-motion -instcombine -memcpyopt -instcombine -simplifycfg -dse -sroa -instcombine -ipsccp -newgvn -nary-reassociate -slp-vectorizer -lower-matrix-intrinsics -instcombine -gvn-hoist -bdce -globaldce -early-cse-memssa -slp-vectorizer -mldst-motion -instnamer -simplifycfg -dse -prune-eh -newgvn -speculative-execution -newgvn -simplifycfg -gvn-hoist -instcombine -simplifycfg -newgvn -mldst-motion -simplifycfg -licm -newgvn -simplifycfg -gvn-hoist -dce -instcombine -simplifycfg -newgvn -float2int -nary-reassociate -correlated-propagation -insert-gcov-profiling -instcombine -scalarizer -instcombine -slp-vectorizer -instcombine -slp-vectorizer -newgvn -gvn-hoist -instcombine -slsr -newgvn -mldst-motion input.bc -o output.bc -benchmark://cBench-v0/ghostscript,1.0016453761734625,1860.8326251506805,opt -sroa -gvn -simplifycfg -instcombine -partially-inline-libcalls -newgvn -simplifycfg -gvn-hoist -mergefunc -tailcallelim -newgvn -ipsccp -simplifycfg -mldst-motion -instcombine -memcpyopt -instcombine -simplifycfg -dse -sroa -instcombine -ipsccp -newgvn -nary-reassociate -slp-vectorizer -instcombine -gvn-hoist -bdce -globaldce -early-cse-memssa -slp-vectorizer -mldst-motion -loop-distribute -simplifycfg -dse -prune-eh -flattencfg -newgvn -mldst-motion -slsr -newgvn -mldst-motion input.bc -o output.bc -benchmark://cBench-v0/ghostscript,1.0000692229458097,1986.2773809432983,opt -loweratomic -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -mergefunc -newgvn -ipsccp -simplifycfg -mldst-motion -instcombine -memcpyopt -instcombine -scalarizer -simplifycfg -dse -sroa -instcombine -ipsccp -newgvn -nary-reassociate -slp-vectorizer -instcombine -gvn-hoist -bdce -globaldce -loop-idiom -instcombine -lower-guard-intrinsic -simplifycfg -early-cse-memssa -slp-vectorizer -partially-inline-libcalls -mldst-motion -dse -prune-eh -simplifycfg -newgvn -mldst-motion -instsimplify -slsr -newgvn -pgo-memop-opt -mldst-motion -gvn-hoist input.bc -o output.bc -benchmark://cBench-v0/ghostscript,0.9779125554449174,2321.2995405197144,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -mergefunc -newgvn -ipsccp -lowerswitch -simplifycfg -instcombine -simplifycfg -mldst-motion -memcpyopt -instcombine -simplifycfg -dse -gvn-hoist -newgvn -instcombine -ipsccp -nary-reassociate -slp-vectorizer -instcombine -gvn-hoist -sroa -globaldce -bdce -early-cse-memssa -slp-vectorizer -dse -instcombine -simplifycfg -prune-eh -mldst-motion -mldst-motion -slsr -newgvn -newgvn -loop-instsimplify -instcombine -simplifycfg -ee-instrument -newgvn -newgvn -mldst-motion -gvn-hoist -newgvn input.bc -o output.bc -benchmark://cBench-v0/ghostscript,0.9965228781835901,2097.893942117691,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -mergefunc -newgvn -ipsccp -simplifycfg -mldst-motion -instcombine -memcpyopt -instcombine -simplifycfg -dse -sroa -globalsplit -instcombine -loop-reduce -licm -newgvn -simplifycfg -instcombine -jump-threading -infer-address-spaces -newgvn -gvn-hoist -bdce -ipsccp -simplifycfg -instcombine -aggressive-instcombine -nary-reassociate -correlated-propagation -instcombine -loop-reroll -instcombine -simplifycfg -globaldce -dse -newgvn -mldst-motion -prune-eh -early-cse-memssa -mldst-motion -simplifycfg -gvn-hoist -slsr -newgvn -nary-reassociate input.bc -o output.bc -benchmark://cBench-v0/ghostscript,1.0000798726297802,1923.4439957141876,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -mergefunc -newgvn -ipsccp -loop-simplifycfg -instcombine -simplifycfg -mldst-motion -memcpyopt -instcombine -simplifycfg -dse -ipsccp -newgvn -instcombine -nary-reassociate -slp-vectorizer -instcombine -gvn-hoist -sroa -globaldce -bdce -newgvn -add-discriminators -slp-vectorizer -dse -prune-eh -mldst-motion -instcombine -simplifycfg -mldst-motion -partial-inliner -early-cse-memssa -slsr -newgvn -mldst-motion input.bc -o output.bc -benchmark://cBench-v0/gsm,1.1495167708925527,37.8730034828186,opt -sroa -instcombine -simplifycfg -forceattrs -newgvn -slp-vectorizer -early-cse-memssa -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -rpo-functionattrs -newgvn -simplifycfg -dse -ipsccp -instcombine -mergefunc -simplifycfg -nary-reassociate -gvn-hoist -prune-eh -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/gsm,1.1381466742467308,43.94974994659424,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -loop-reduce -simplifycfg -instcombine -newgvn -dse -ipsccp -instcombine -jump-threading -nary-reassociate -gvn-hoist -prune-eh -scalarizer -instcombine -slp-vectorizer -instcombine -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/gsm,1.1495167708925527,38.894811391830444,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -ipsccp -instcombine -simplifycfg -nary-reassociate -gvn-hoist -prune-eh -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/gsm,1.1496588971006254,41.75011491775513,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -loop-unroll-and-jam -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -simplifycfg -instcombine -jump-threading -newgvn -loop-sink -name-anon-globals -post-inline-ee-instrument -simplifycfg -newgvn -dse -ipsccp -instcombine -simplifycfg -nary-reassociate -gvn-hoist -prune-eh -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/gsm,1.1509380329732803,37.99203038215637,opt -sroa -instcombine -simplifycfg -functionattrs -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -ipsccp -instcombine -dse -simplifycfg -nary-reassociate -gvn-hoist -prune-eh -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/gsm,1.1468163729391696,42.09191536903381,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -lower-guard-intrinsic -instcombine -slp-vectorizer -loop-idiom -loop-idiom -instcombine -simplifycfg -jump-threading -newgvn -reassociate -dse -callsite-splitting -ipsccp -scalarizer -instcombine -slp-vectorizer -instcombine -simplifycfg -nary-reassociate -gvn-hoist -prune-eh -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/gsm,1.1495167708925527,38.51568388938904,opt -lower-matrix-intrinsics -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -mergeicmps -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -lower-expect -callsite-splitting -dse -ipsccp -instcombine -simplifycfg -nary-reassociate -gvn-hoist -prune-eh -always-inline -simplifycfg -hotcoldsplit input.bc -o output.bc -benchmark://cBench-v0/gsm,1.1495167708925529,42.394848585128784,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -ipsccp -lower-constant-intrinsics -instcombine -simplifycfg -nary-reassociate -gvn-hoist -prune-eh -simplifycfg -loop-reroll -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v0/gsm,1.1496588971006252,38.50854277610779,opt -sroa -instcombine -simplifycfg -loop-vectorize -partial-inliner -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -simplifycfg -instcombine -jump-threading -reassociate -newgvn -dse -ipsccp -instcombine -simplifycfg -nary-reassociate -gvn-hoist -prune-eh -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/gsm,1.1495167708925529,40.232659101486206,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -ipsccp -loop-deletion -simplifycfg -instcombine -dse -simplifycfg -nary-reassociate -gvn-hoist -redundant-dbg-inst-elim -prune-eh -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/ispell,0.9484346224677719,61.475505352020264,opt -sroa -newgvn -simplifycfg -instcombine -simplifycfg -newgvn -simplifycfg -lowerswitch -simplifycfg -instcombine -simplifycfg -gvn-hoist -newgvn -ipsccp -lcssa -newgvn -strip-dead-prototypes -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -redundant-dbg-inst-elim -newgvn -mldst-motion -correlated-propagation -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/ispell,1.0005022601707687,58.671817779541016,opt -sroa -newgvn -simplifycfg -instcombine -simplifycfg -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -newgvn -jump-threading -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -simplifycfg -called-value-propagation -newgvn -mldst-motion -jump-threading input.bc -o output.bc -benchmark://cBench-v0/ispell,1.0006696802276915,58.156036138534546,opt -sroa -newgvn -simplifycfg -instcombine -simplifycfg -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -newgvn -jump-threading -loop-load-elim -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -newgvn -mldst-motion -jump-threading input.bc -o output.bc -benchmark://cBench-v0/ispell,1.0005022601707687,57.86407923698425,opt -sroa -newgvn -simplifycfg -instcombine -simplifycfg -newgvn -sroa -simplifycfg -gvn-hoist -instcombine -ipsccp -newgvn -jump-threading -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -simplifycfg -newgvn -mldst-motion -jump-threading input.bc -o output.bc -benchmark://cBench-v0/ispell,0.9487694625816174,56.39859914779663,opt -lower-matrix-intrinsics -sroa -newgvn -simplifycfg -instcombine -simplifycfg -newgvn -simplifycfg -slsr -gvn-hoist -dse -lowerswitch -simplifycfg -instcombine -simplifycfg -ipsccp -rpo-functionattrs -newgvn -simplifycfg -newgvn -nary-reassociate -memcpyopt -newgvn -mldst-motion -correlated-propagation -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/ispell,1.0005022601707687,57.664350748062134,opt -consthoist -sroa -newgvn -simplifycfg -instcombine -adce -simplifycfg -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -newgvn -jump-threading -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -simplifycfg -newgvn -mldst-motion -jump-threading input.bc -o output.bc -benchmark://cBench-v0/ispell,0.9810815335677215,58.025816679000854,opt -gvn -instcombine -simplifycfg -coro-early -sroa -partial-inliner -newgvn -instcombine -simplifycfg -jump-threading -newgvn -gvn-hoist -dse -newgvn -ipsccp -irce -attributor -simplifycfg -newgvn -simplifycfg -nary-reassociate -memcpyopt -prune-eh -newgvn -mldst-motion -simplifycfg -correlated-propagation input.bc -o output.bc -benchmark://cBench-v0/ispell,1.0005022601707687,58.73056602478027,opt -sroa -newgvn -simplifycfg -instcombine -simplifycfg -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -newgvn -jump-threading -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -simplifycfg -newgvn -mldst-motion -jump-threading input.bc -o output.bc -benchmark://cBench-v0/ispell,1.0006696802276915,56.32115340232849,opt -sroa -strip-dead-prototypes -newgvn -simplifycfg -instcombine -loop-fusion -simplifycfg -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -newgvn -jump-threading -newgvn -break-crit-edges -simplifycfg -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -mldst-motion -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v0/ispell,1.0005022601707685,62.48310446739197,opt -speculative-execution -sroa -newgvn -simplifycfg -instcombine -simplifycfg -loweratomic -newgvn -simplifycfg -gvn-hoist -reg2mem -sroa -simplifycfg -instcombine -ipsccp -newgvn -jump-threading -newgvn -loop-simplifycfg -simplifycfg -correlated-propagation -dse -nary-reassociate -memcpyopt -newgvn -mldst-motion -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/jpeg-c,1.022896304661033,167.0369176864624,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -mldst-motion -mldst-motion -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -ipsccp -correlated-propagation -lower-expect -newgvn -simplifycfg -gvn-hoist -newgvn -slsr -newgvn -globaldce input.bc -o output.bc -benchmark://cBench-v0/jpeg-c,1.022896304661033,162.6602861881256,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -mergefunc -coro-early -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -mldst-motion -mldst-motion -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -ipsccp -correlated-propagation -newgvn -simplifycfg -gvn-hoist -newgvn -slsr -newgvn -globaldce input.bc -o output.bc -benchmark://cBench-v0/jpeg-c,1.022896304661033,162.48382711410522,opt -slsr -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -name-anon-globals -instsimplify -mldst-motion -mldst-motion -mldst-motion -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -ipsccp -correlated-propagation -newgvn -simplifycfg -gvn-hoist -newgvn -slsr -newgvn -globaldce input.bc -o output.bc -benchmark://cBench-v0/jpeg-c,1.022896304661033,163.83925199508667,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -mldst-motion -mldst-motion -newgvn -simplifycfg -prune-eh -coro-split -newgvn -mldst-motion -ipsccp -correlated-propagation -newgvn -simplifycfg -gvn-hoist -newgvn -slsr -newgvn -globaldce input.bc -o output.bc -benchmark://cBench-v0/jpeg-c,1.0228963046610333,170.10317039489746,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -loop-simplify -simplifycfg -early-cse-memssa -mldst-motion -mldst-motion -mldst-motion -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -ipsccp -correlated-propagation -newgvn -simplifycfg -gvn-hoist -newgvn -slsr -newgvn -globaldce input.bc -o output.bc -benchmark://cBench-v0/jpeg-c,1.0231299404228804,163.70789122581482,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -loweratomic -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -mldst-motion -mldst-motion -newgvn -simplifycfg -prune-eh -newgvn -memcpyopt -lower-guard-intrinsic -mldst-motion -ipsccp -correlated-propagation -newgvn -sink -simplifycfg -gvn-hoist -newgvn -slsr -newgvn -globaldce -argpromotion input.bc -o output.bc -benchmark://cBench-v0/jpeg-c,1.022896304661033,170.07374668121338,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -mergefunc -simplifycfg -rpo-functionattrs -lower-expect -nary-reassociate -partial-inliner -memcpyopt -instsimplify -mldst-motion -mldst-motion -mldst-motion -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -ipsccp -correlated-propagation -newgvn -simplifycfg -gvn-hoist -newgvn -slsr -newgvn -globaldce input.bc -o output.bc -benchmark://cBench-v0/jpeg-c,1.0227794867801094,184.75065994262695,opt -sroa -always-inline -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -mldst-motion -mldst-motion -newgvn -partial-inliner -simplifycfg -prune-eh -sink -newgvn -mldst-motion -ipsccp -correlated-propagation -newgvn -scalarizer -simplifycfg -gvn-hoist -newgvn -coro-early -slsr -newgvn -div-rem-pairs -globaldce -irce -newgvn -simplifycfg -correlated-propagation input.bc -o output.bc -benchmark://cBench-v0/jpeg-c,1.022896304661033,163.94377493858337,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -mldst-motion -mldst-motion -newgvn -simplifycfg -prune-eh -lower-constant-intrinsics -prune-eh -newgvn -mldst-motion -ipsccp -correlated-propagation -newgvn -simplifycfg -gvn-hoist -newgvn -slsr -newgvn -coro-split -globaldce input.bc -o output.bc -benchmark://cBench-v0/jpeg-c,1.0226237296055445,161.27980875968933,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -mldst-motion -mldst-motion -loop-predication -sink -newgvn -simplifycfg -correlated-propagation -globalopt -newgvn -prune-eh -newgvn -mldst-motion -ipsccp -simplifycfg -gvn-hoist -newgvn -slsr -newgvn input.bc -o output.bc -benchmark://cBench-v0/jpeg-d,1.0218300233175202,162.80999040603638,opt -sroa -gvn -simplifycfg -loop-fusion -instcombine -simplifycfg -gvn-hoist -newgvn -mergefunc -nary-reassociate -memcpyopt -instcombine -simplifycfg -div-rem-pairs -mldst-motion -mldst-motion -mldst-motion -simplifycfg -newgvn -mldst-motion -instcombine -simplifycfg -ipsccp -slsr -newgvn -globaldce -constprop -correlated-propagation -instcombine -sroa -simplifycfg -nary-reassociate input.bc -o output.bc -benchmark://cBench-v0/jpeg-d,1.0217898206963092,155.09252095222473,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -simplifycfg -mergefunc -nary-reassociate -memcpyopt -instcombine -mldst-motion -mldst-motion -newgvn -mldst-motion -simplifycfg -mldst-motion -ipsccp -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -instcombine -simplifycfg -nary-reassociate input.bc -o output.bc -benchmark://cBench-v0/jpeg-d,1.0217898206963092,158.51034665107727,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -simplifycfg -mergefunc -attributor -nary-reassociate -memcpyopt -argpromotion -instcombine -mldst-motion -newgvn -insert-gcov-profiling -mldst-motion -mldst-motion -coro-early -simplifycfg -mldst-motion -lower-widenable-condition -ipsccp -slsr -newgvn -globaldce -forceattrs -gvn-hoist -correlated-propagation -simplifycfg -instcombine -simplifycfg -nary-reassociate input.bc -o output.bc -benchmark://cBench-v0/jpeg-d,1.0217898206963092,154.6300506591797,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -simplifycfg -mergefunc -nary-reassociate -memcpyopt -instcombine -mldst-motion -mldst-motion -newgvn -mldst-motion -simplifycfg -mldst-motion -ipsccp -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -instcombine -simplifycfg -nary-reassociate input.bc -o output.bc -benchmark://cBench-v0/jpeg-d,1.0217898206963092,157.87810039520264,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -simplifycfg -mergefunc -nary-reassociate -memcpyopt -instcombine -mldst-motion -mldst-motion -newgvn -mldst-motion -simplifycfg -mldst-motion -ipsccp -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -instcombine -simplifycfg -nary-reassociate input.bc -o output.bc -benchmark://cBench-v0/jpeg-d,1.0217898206963092,163.5455927848816,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -simplifycfg -mergefunc -nary-reassociate -memcpyopt -instcombine -mldst-motion -mldst-motion -newgvn -nary-reassociate -mldst-motion -simplifycfg -break-crit-edges -simplifycfg -mldst-motion -ipsccp -inject-tli-mappings -coro-split -slsr -newgvn -insert-gcov-profiling -globaldce -gvn-hoist -correlated-propagation -simplifycfg -strip-debug-declare -instcombine -simplifycfg -nary-reassociate input.bc -o output.bc -benchmark://cBench-v0/jpeg-d,1.0217898206963092,154.0655062198639,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -simplifycfg -mergefunc -nary-reassociate -memcpyopt -instcombine -mldst-motion -mldst-motion -newgvn -mldst-motion -simplifycfg -mldst-motion -ipsccp -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -instcombine -simplifycfg -nary-reassociate input.bc -o output.bc -benchmark://cBench-v0/jpeg-d,1.02183002331752,161.41529035568237,opt -sroa -gvn -simplifycfg -canonicalize-aliases -instcombine -gvn-hoist -newgvn -simplifycfg -mergefunc -nary-reassociate -memcpyopt -instcombine -mldst-motion -mldst-motion -newgvn -mldst-motion -simplifycfg -mldst-motion -ipsccp -slsr -newgvn -globaldce -gvn-hoist -simple-loop-unswitch -newgvn -simplifycfg -correlated-propagation -instcombine -simplifycfg -nary-reassociate input.bc -o output.bc -benchmark://cBench-v0/jpeg-d,1.0217898206963092,155.45213294029236,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -pgo-memop-opt -newgvn -simplifycfg -mergefunc -nary-reassociate -memcpyopt -instcombine -mldst-motion -mldst-motion -newgvn -mldst-motion -simplifycfg -mldst-motion -ipsccp -slsr -newgvn -insert-gcov-profiling -globaldce -gvn-hoist -correlated-propagation -simplifycfg -instcombine -simplifycfg -nary-reassociate input.bc -o output.bc -benchmark://cBench-v0/jpeg-d,1.0217898206963092,156.0222954750061,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -simplifycfg -prune-eh -mergefunc -nary-reassociate -memcpyopt -instcombine -mldst-motion -mldst-motion -newgvn -mldst-motion -hotcoldsplit -simplifycfg -mldst-motion -ipsccp -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -inject-tli-mappings -instcombine -simplifycfg -nary-reassociate input.bc -o output.bc -benchmark://cBench-v0/lame,1.1155323029663051,167.26788115501404,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -gvn-hoist -bdce -ipsccp -memcpyopt -instcombine -dse -mldst-motion -simplifycfg -adce -globalopt -instcombine -newgvn -simplifycfg -prune-eh -mergefunc -instcombine -jump-threading -instcombine -simplifycfg -newgvn -instcombine -globalsplit -globalopt -prune-eh -gvn-hoist -newgvn -dse input.bc -o output.bc -benchmark://cBench-v0/lame,1.115532302966305,164.133118391037,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -gvn-hoist -dce -ipsccp -memcpyopt -bdce -dse -instcombine -mldst-motion -simplifycfg -globalopt -instcombine -newgvn -simplifycfg -prune-eh -mergefunc -instcombine -jump-threading -instcombine -simplifycfg -newgvn -instcombine -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc -benchmark://cBench-v0/lame,1.1141883459729292,148.71487617492676,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -loop-instsimplify -simplifycfg -instcombine -gvn-hoist -bdce -ipsccp -memcpyopt -newgvn -simplifycfg -dse -mldst-motion -loop-reroll -simplifycfg -instcombine -simplifycfg -globalopt -instcombine -newgvn -prune-eh -mergefunc -instcombine -globalopt -dse input.bc -o output.bc -benchmark://cBench-v0/lame,1.1191801862340403,159.07205843925476,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -gvn-hoist -bdce -ipsccp -memcpyopt -instcombine -dse -loop-versioning-licm -newgvn -simplifycfg -mldst-motion -globalopt -instcombine -simplifycfg -licm -newgvn -simplifycfg -prune-eh -mergefunc -gvn-hoist -instcombine -newgvn -globalopt -dse -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/lame,1.1175962369204187,160.42251658439636,opt -sroa -gvn -simplifycfg -instcombine -indvars -newgvn -mergereturn -simplifycfg -nary-reassociate -gvn-hoist -instcombine -ipsccp -memcpyopt -bdce -dse -simplifycfg -mldst-motion -newgvn -globalopt -instcombine -simplifycfg -prune-eh -newgvn -mergefunc -instsimplify -globalopt -gvn-hoist -dse -correlated-propagation -instsimplify -nary-reassociate input.bc -o output.bc -benchmark://cBench-v0/lame,1.1160122876067964,167.25811386108398,opt -sroa -nary-reassociate -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -bdce -bdce -nary-reassociate -ipsccp -memcpyopt -instcombine -dse -mldst-motion -insert-gcov-profiling -simplifycfg -scalarizer -globalopt -instcombine -newgvn -simplifycfg -prune-eh -mergefunc -instcombine -lower-matrix-intrinsics -jump-threading -instcombine -simplifycfg -newgvn -instcombine -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc -benchmark://cBench-v0/lame,1.107900547182491,171.84539914131165,opt -gvn -instcombine -simplifycfg -newgvn -sroa -newgvn -nary-reassociate -instcombine -simplifycfg -gvn-hoist -newgvn -ipsccp -memcpyopt -bdce -dse -globalopt -instcombine -simplifycfg -mldst-motion -simplifycfg -early-cse-memssa -newgvn -prune-eh -jump-threading -instcombine -simplifycfg -sroa -mergefunc -newgvn -globalopt -gvn-hoist -canonicalize-aliases -newgvn -dse -dce input.bc -o output.bc -benchmark://cBench-v0/lame,1.1158682922146492,172.36621642112732,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -gvn-hoist -bdce -ipsccp -memcpyopt -instcombine -dse -mldst-motion -simplifycfg -globalopt -instcombine -newgvn -simplifycfg -prune-eh -mergefunc -instcombine -jump-threading -instcombine -simplifycfg -newgvn -instcombine -slp-vectorizer -instcombine -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc -benchmark://cBench-v0/lame,1.1155803014303542,166.15596842765808,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -tailcallelim -simplifycfg -gvn-hoist -alignment-from-assumptions -bdce -ipsccp -memcpyopt -instcombine -dse -mldst-motion -simplifycfg -globalopt -instcombine -newgvn -simplifycfg -prune-eh -inject-tli-mappings -mergefunc -instcombine -jump-threading -instcombine -simplifycfg -newgvn -instcombine -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc -benchmark://cBench-v0/lame,1.1155323029663051,167.29455971717834,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -gvn-hoist -bdce -ipsccp -memcpyopt -instcombine -dse -mldst-motion -simplifycfg -globalopt -instcombine -newgvn -simplifycfg -prune-eh -mergefunc -instcombine -jump-threading -instcombine -simplifycfg -newgvn -instcombine -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc -benchmark://cBench-v0/patricia,0.9693094629156009,3.9266302585601807,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc -benchmark://cBench-v0/patricia,0.9705882352941178,4.825629711151123,opt -sroa -simplifycfg -newgvn -sccp -ipsccp -adce -simplifycfg -newgvn -tailcallelim -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v0/patricia,0.9693094629156009,3.8992760181427,opt -correlated-propagation -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc -benchmark://cBench-v0/patricia,0.9693094629156009,3.912933349609375,opt -sroa -ipsccp -gvn -simplifycfg -separate-const-offset-from-gep -reassociate -tailcallelim -jump-threading input.bc -o output.bc -benchmark://cBench-v0/patricia,0.9693094629156009,4.404894113540649,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -lcssa -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v0/patricia,0.9693094629156009,3.931546211242676,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc -benchmark://cBench-v0/patricia,0.9693094629156009,3.909588575363159,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc -benchmark://cBench-v0/patricia,0.9705882352941176,5.27163028717041,opt -simplifycfg -loop-versioning-licm -loop-deletion -sroa -ipsccp -newgvn -simplifycfg -newgvn -newgvn -simplifycfg -tailcallelim -reassociate -jump-threading input.bc -o output.bc -benchmark://cBench-v0/patricia,0.9693094629156009,3.8775691986083984,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc -benchmark://cBench-v0/patricia,0.9693094629156009,3.929682970046997,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc -benchmark://cBench-v0/qsort,1.029197080291971,3.5581681728363037,opt -sroa -gvn -simplifycfg -instcombine -newgvn -coro-elide -simplifycfg -gvn-hoist input.bc -o output.bc -benchmark://cBench-v0/qsort,0.9744525547445256,3.591317653656006,opt -sroa -gvn -simplifycfg -loop-rotate -instcombine -deadargelim -div-rem-pairs -simplifycfg -newgvn -barrier -gvn-hoist input.bc -o output.bc -benchmark://cBench-v0/qsort,1.029197080291971,3.514180898666382,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc -benchmark://cBench-v0/qsort,1.029197080291971,3.069769859313965,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/qsort,1.029197080291971,3.5526814460754395,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -strip-dead-prototypes -gvn-hoist input.bc -o output.bc -benchmark://cBench-v0/qsort,1.029197080291971,3.538724899291992,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc -benchmark://cBench-v0/qsort,1.029197080291971,3.5244412422180176,opt -sroa -barrier -gvn -simplifycfg -instcombine -newgvn -simplifycfg -hotcoldsplit -gvn-hoist input.bc -o output.bc -benchmark://cBench-v0/qsort,1.029197080291971,3.529522657394409,opt -sroa -gvn -simplifycfg -instcombine -newgvn -bdce -simplifycfg -gvn-hoist input.bc -o output.bc -benchmark://cBench-v0/qsort,1.029197080291971,3.5224571228027344,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc -benchmark://cBench-v0/qsort,1.0145985401459854,3.466933250427246,opt -loop-load-elim -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc -benchmark://cBench-v0/rijndael,1.1151767151767153,8.526031732559204,opt -sroa -instcombine -gvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -instcombine input.bc -o output.bc -benchmark://cBench-v0/rijndael,1.1151767151767153,9.324137210845947,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc -benchmark://cBench-v0/rijndael,1.1151767151767153,9.431487083435059,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc -benchmark://cBench-v0/rijndael,1.1151767151767153,9.38455605506897,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -slsr -newgvn -jump-threading -instcombine -die input.bc -o output.bc -benchmark://cBench-v0/rijndael,1.1151767151767153,9.348448514938354,opt -sroa -instcombine -gvn -mergereturn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -pgo-memop-opt -instcombine input.bc -o output.bc -benchmark://cBench-v0/rijndael,1.1151767151767153,9.432142496109009,opt -sroa -pgo-memop-opt -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc -benchmark://cBench-v0/rijndael,1.1151767151767151,12.2704598903656,opt -sroa -instcombine -gvn -simplifycfg -die -loop-interchange -reassociate -memcpyopt -instcombine -simplifycfg -gvn-hoist -newgvn -jump-threading -instcombine -loop-load-elim -simple-loop-unswitch -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v0/rijndael,1.1151767151767153,9.399054765701294,opt -sroa -instcombine -gvn -simplifycfg -alignment-from-assumptions -lower-matrix-intrinsics -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc -benchmark://cBench-v0/rijndael,1.1151767151767153,9.413830041885376,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc -benchmark://cBench-v0/rijndael,1.1151767151767153,9.393671989440918,opt -sroa -instcombine -gvn -simplifycfg -mergereturn -instcombine -gvn-hoist -flattencfg -newgvn -jump-threading -instcombine input.bc -o output.bc -benchmark://cBench-v0/sha,1.553191489361702,3.252039909362793,opt -sroa -gvn -simplifycfg -instcombine -add-discriminators -newgvn -ipsccp input.bc -o output.bc -benchmark://cBench-v0/sha,1.553191489361702,3.23064923286438,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc -benchmark://cBench-v0/sha,1.548936170212766,4.220396995544434,opt -sroa -gvn -simplifycfg -instcombine -functionattrs -licm -newgvn -simplifycfg -ipsccp -loop-simplify -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/sha,1.553191489361702,4.221415758132935,opt -strip -sroa -strip-debug-declare -gvn -simplifycfg -reg2mem -sroa -instcombine -simplifycfg -newgvn -ipsccp input.bc -o output.bc -benchmark://cBench-v0/sha,1.553191489361702,3.221076726913452,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp -canonicalize-aliases input.bc -o output.bc -benchmark://cBench-v0/sha,1.553191489361702,3.246673583984375,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc -benchmark://cBench-v0/sha,1.553191489361702,3.227952480316162,opt -sroa -gvn -simplifycfg -constmerge -instcombine -newgvn -ipsccp input.bc -o output.bc -benchmark://cBench-v0/sha,1.557446808510638,3.208369731903076,opt -sroa -gvn -simplifycfg -instcombine -memcpyopt -newgvn -coro-split -ipsccp input.bc -o output.bc -benchmark://cBench-v0/sha,1.553191489361702,3.2176291942596436,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc -benchmark://cBench-v0/sha,1.553191489361702,3.220510244369507,opt -sroa -forceattrs -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc -benchmark://cBench-v0/stringsearch,1.0143149284253579,4.852210521697998,opt -sroa -newgvn -simplifycfg -instcombine -jump-threading -partial-inliner -newgvn -gvn-hoist -newgvn input.bc -o output.bc -benchmark://cBench-v0/stringsearch,1.0143149284253579,4.825301647186279,opt -sroa -newgvn -simplifycfg -ee-instrument -instcombine -jump-threading -newgvn -gvn-hoist -newgvn input.bc -o output.bc -benchmark://cBench-v0/stringsearch,1.0143149284253579,4.837324857711792,opt -sroa -newgvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -newgvn input.bc -o output.bc -benchmark://cBench-v0/stringsearch,1.0143149284253579,4.83894157409668,opt -sroa -newgvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -newgvn input.bc -o output.bc -benchmark://cBench-v0/stringsearch,1.0143149284253579,4.832793951034546,opt -sroa -newgvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -newgvn input.bc -o output.bc -benchmark://cBench-v0/stringsearch,1.0122699386503067,6.490794897079468,opt -sroa -newgvn -simplifycfg -instcombine -jump-threading -loop-deletion -gvn -simplifycfg -gvn-hoist -newgvn -loop-unswitch -instcombine -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/stringsearch,1.0143149284253579,4.842012643814087,opt -sroa -newgvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -newgvn input.bc -o output.bc -benchmark://cBench-v0/stringsearch,1.0143149284253579,4.311517715454102,opt -sroa -newgvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -bdce input.bc -o output.bc -benchmark://cBench-v0/stringsearch,1.0143149284253579,4.877126693725586,opt -sroa -newgvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -newgvn input.bc -o output.bc -benchmark://cBench-v0/stringsearch,1.0143149284253579,4.864404916763306,opt -sroa -newgvn -simplifycfg -instcombine -jump-threading -pgo-memop-opt -ee-instrument -newgvn -gvn-hoist -newgvn input.bc -o output.bc -benchmark://cBench-v0/stringsearch2,0.9742268041237113,2.238586187362671,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v0/stringsearch2,0.9742268041237113,2.196035623550415,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v0/stringsearch2,0.9742268041237113,2.195099115371704,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v0/stringsearch2,0.9742268041237113,2.6221635341644287,opt -sroa -gvn -simplifycfg -loop-reroll -instcombine -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/stringsearch2,0.9742268041237113,2.192682981491089,opt -sroa -mergereturn -gvn -infer-address-spaces -name-anon-globals -simplifycfg -newgvn -instcombine input.bc -o output.bc -benchmark://cBench-v0/stringsearch2,0.9742268041237113,2.186244487762451,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v0/stringsearch2,0.9742268041237113,2.2214152812957764,opt -sroa -gvn -simplifycfg -instcombine -post-inline-ee-instrument input.bc -o output.bc -benchmark://cBench-v0/stringsearch2,0.9742268041237113,2.1809301376342773,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v0/stringsearch2,0.9742268041237113,2.1874279975891113,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v0/stringsearch2,0.9742268041237113,2.164578437805176,opt -lower-guard-intrinsic -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v0/susan,1.0062154696132597,21.237401962280273,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -simplifycfg -coro-early -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/susan,1.0073204419889503,21.022145748138428,opt -sroa -licm -newgvn -instcombine -simplifycfg -nary-reassociate -gvn-hoist -slsr -nary-reassociate -newgvn -instcombine -simplifycfg -newgvn -newgvn -mldst-motion -simplifycfg -gvn-hoist input.bc -o output.bc -benchmark://cBench-v0/susan,1.002900552486188,24.97674560546875,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -loop-simplify -simplifycfg -newgvn -instcombine -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -lowerswitch -simplifycfg -instcombine -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/susan,1.0040055248618784,21.214195251464844,opt -sroa -lowerswitch -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/susan,1.0062154696132597,23.505887031555176,opt -irce -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -simplifycfg -gvn-hoist -newgvn -newgvn -loop-versioning-licm -newgvn -simplifycfg -mldst-motion -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/susan,1.0062154696132597,20.977452278137207,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -globalopt -mem2reg -gvn-hoist -flattencfg -newgvn -guard-widening -instcombine -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/susan,1.0062154696132597,21.33326506614685,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/susan,1.0062154696132595,22.355042695999146,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -mem2reg -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -loop-versioning-licm -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/susan,1.0062154696132597,23.273910999298096,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -globalopt -newgvn -instcombine -simplifycfg -gvn-hoist -newgvn -newgvn -irce -newgvn -simplifycfg -mldst-motion -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/susan,1.0062154696132597,21.12042999267578,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -simplifycfg -gvn-hoist -newgvn -newgvn -correlated-propagation -mldst-motion -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/tiff2bw,1.004535996670828,150.02621173858643,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -gvn -tailcallelim -simplifycfg -lower-constant-intrinsics -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc input.bc -o output.bc -benchmark://cBench-v0/tiff2bw,1.004369538077403,147.0981001853943,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -gvn -simplifycfg -memcpyopt -instcombine -prune-eh -newgvn -nary-reassociate -mergefunc input.bc -o output.bc -benchmark://cBench-v0/tiff2bw,1.0043695380774031,140.48020720481873,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -mldst-motion -newgvn -memcpyopt -instcombine -gvn -simplifycfg -prune-eh -newgvn -nary-reassociate -mergefunc input.bc -o output.bc -benchmark://cBench-v0/tiff2bw,0.9884727424053266,154.1393620967865,opt -partial-inliner -sroa -gvn -simplifycfg -instcombine -newgvn -loop-reduce -simplifycfg -instcombine -newgvn -gvn-hoist -instcombine -simplifycfg -ipsccp -loop-versioning-licm -instcombine -simplifycfg -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -strip-nondebug -mergefunc -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/tiff2bw,1.004369538077403,140.4969711303711,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -sroa -instcombine -lower-widenable-condition -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -gvn -simplifycfg -memcpyopt -instcombine -prune-eh -newgvn -nary-reassociate -libcalls-shrinkwrap -mergefunc input.bc -o output.bc -benchmark://cBench-v0/tiff2bw,1.0035372451102786,154.5895640850067,opt -globalopt -sroa -gvn -simplifycfg -instcombine -loop-load-elim -simplifycfg -newgvn -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -mldst-motion -simplifycfg -gvn -simplifycfg -memcpyopt -instcombine -prune-eh -newgvn -nary-reassociate -mergefunc input.bc -o output.bc -benchmark://cBench-v0/tiff2bw,1.0035372451102784,166.6245219707489,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -gvn -simplifycfg -memcpyopt -instcombine -prune-eh -newgvn -loop-sink -instcombine -simplifycfg -sink -newgvn -nary-reassociate -mergefunc input.bc -o output.bc -benchmark://cBench-v0/tiff2bw,1.0012068248023298,150.62344455718994,opt -sroa -gvn -callsite-splitting -simplifycfg -attributor -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -libcalls-shrinkwrap -simplifycfg -slp-vectorizer -newgvn -adce -constmerge -mldst-motion -gvn -simplifycfg -memcpyopt -correlated-propagation -instcombine -simplifycfg -prune-eh -newgvn -nary-reassociate -mergefunc input.bc -o output.bc -benchmark://cBench-v0/tiff2bw,1.004369538077403,144.84855127334595,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -aggressive-instcombine -newgvn -mldst-motion -gvn -simplifycfg -memcpyopt -instcombine -prune-eh -newgvn -nary-reassociate -mergefunc input.bc -o output.bc -benchmark://cBench-v0/tiff2bw,1.003995006242197,154.96046471595764,opt -sroa -slp-vectorizer -strip-dead-prototypes -gvn -simplifycfg -instcombine -mergeicmps -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -gvn -simplifycfg -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -simplifycfg -die -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/tiff2rgba,1.0079806125433504,140.1571226119995,opt -coro-early -licm -sroa -gvn -simplifycfg -instcombine -newgvn -bdce -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -mldst-motion -newgvn -memcpyopt -instcombine -ee-instrument -nary-reassociate -mergefunc -simplifycfg -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/tiff2rgba,1.0043036811097648,169.4242286682129,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -float2int -slp-vectorizer -newgvn -mldst-motion -loop-simplifycfg -instcombine -simplifycfg -gvn -simplifycfg -memcpyopt -forceattrs -instcombine -lower-constant-intrinsics -nary-reassociate -mergefunc -gvn-hoist -simplifycfg -newgvn -simplifycfg -attributor input.bc -o output.bc -benchmark://cBench-v0/tiff2rgba,1.0023816487694814,151.39407300949097,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -correlated-propagation -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -mldst-motion -simplifycfg -newgvn -memcpyopt -instcombine -nary-reassociate -correlated-propagation -simplifycfg -newgvn -simplifycfg -alignment-from-assumptions -mergefunc input.bc -o output.bc -benchmark://cBench-v0/tiff2rgba,1.0051393473446708,164.57986044883728,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -coro-split -gvn -simplifycfg -memcpyopt -instcombine -newgvn -nary-reassociate -mergefunc -gvn-hoist -simplifycfg -newgvn -simplifycfg -die input.bc -o output.bc -benchmark://cBench-v0/tiff2rgba,1.0051393473446708,165.66000533103943,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -mem2reg -ipsccp -simplifycfg -attributor -slp-vectorizer -newgvn -mldst-motion -gvn -simplifycfg -memcpyopt -instcombine -newgvn -nary-reassociate -mergefunc -gvn-hoist -simplifycfg -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/tiff2rgba,1.0051393473446708,164.64863204956055,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -gvn -simplifycfg -memcpyopt -instcombine -newgvn -nary-reassociate -mergefunc -gvn-hoist -simplifycfg -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/tiff2rgba,1.0054736138386327,170.99662113189697,opt -sroa -gvn -simplifycfg -instcombine -inline -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -loop-unroll-and-jam -instcombine -simplifycfg -slp-vectorizer -newgvn -mldst-motion -functionattrs -newgvn -memcpyopt -instcombine -gvn-hoist -nary-reassociate -mergefunc -gvn -simplifycfg -newgvn -gvn-hoist -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/tiff2rgba,1.0051393473446708,163.80334520339966,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -gvn -simplifycfg -memcpyopt -instcombine -constmerge -newgvn -nary-reassociate -mergefunc -gvn-hoist -simplifycfg -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/tiff2rgba,1.0042618977980196,169.33936262130737,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -gvn -simplifycfg -memcpyopt -instcombine -newgvn -nary-reassociate -mergefunc -name-anon-globals -gvn-hoist -loop-versioning-licm -instcombine -simplifycfg -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/tiff2rgba,1.0044708143567458,172.3550157546997,opt -loop-guard-widening -sroa -gvn -simplifycfg -instcombine -newgvn -loop-simplifycfg -instcombine -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -gvn -simplifycfg -slp-vectorizer -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -nary-reassociate -mergefunc -gvn-hoist -simplifycfg -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/tiffdither,1.00364245342265,182.47542238235474,opt -sroa -loop-unroll-and-jam -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -gvn -simplifycfg -newgvn -nary-reassociate -coro-elide -mergefunc -gvn-hoist -simplifycfg -newgvn -sancov -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/tiffdither,1.0046054008792127,179.6926872730255,opt -sroa -gvn -loop-distribute -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -coro-early -ipsccp -simplifycfg -slp-vectorizer -simplifycfg -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -gvn -simplifycfg -newgvn -nary-reassociate -mergefunc -gvn-hoist -simplifycfg -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/tiffdither,1.0046054008792127,181.03862118721008,opt -sroa -gvn -simplifycfg -float2int -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -gvn -simplifycfg -newgvn -nary-reassociate -mergefunc -gvn-hoist -simplifycfg -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/tiffdither,1.0038099225455306,152.89263606071472,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -load-store-vectorizer -instcombine -gvn -slp-vectorizer -instcombine -bdce -simplifycfg -gvn-hoist -mldst-motion -newgvn -prune-eh -instcombine -simplifycfg -nary-reassociate -mergefunc -loop-versioning input.bc -o output.bc -benchmark://cBench-v0/tiffdither,1.001507222105924,206.75270867347717,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -gvn -simplifycfg -newgvn -nary-reassociate -mergefunc -scalarizer -slp-vectorizer -instsimplify -gvn-hoist -simplifycfg -newgvn -correlated-propagation -instcombine -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v0/tiffdither,1.0046054008792127,181.0861098766327,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -inline -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -gvn -simplifycfg -newgvn -nary-reassociate -mergefunc -gvn-hoist -simplifycfg -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/tiffdither,1.0074523759681808,152.34258794784546,opt -licm -sroa -gvn -simplifycfg -instcombine -newgvn -bdce -simplifycfg -callsite-splitting -gvn-hoist -instcombine -ipsccp -simplifycfg -mldst-motion -newgvn -memcpyopt -instcombine -loop-versioning -prune-eh -nary-reassociate -loop-interchange -instcombine -simplifycfg -newgvn -simplifycfg -mergefunc input.bc -o output.bc -benchmark://cBench-v0/tiffdither,1.0046054008792127,181.79122877120972,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -consthoist -simplifycfg -slp-vectorizer -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -strip-debug-declare -prune-eh -gvn -loop-distribute -simplifycfg -newgvn -nary-reassociate -pgo-memop-opt -mergefunc -gvn-hoist -simplifycfg -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/tiffdither,1.0046054008792127,179.61281037330627,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -separate-const-offset-from-gep -mldst-motion -newgvn -lower-expect -memcpyopt -instcombine -prune-eh -gvn -simplifycfg -newgvn -nary-reassociate -mergefunc -gvn-hoist -simplifycfg -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/tiffdither,1.00343311701905,160.62122535705566,opt -sroa -gvn -forceattrs -simplifycfg -loop-load-elim -instcombine -simplifycfg -float2int -newgvn -mergefunc -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -mldst-motion -indvars -instcombine -simplifycfg -gvn -simplifycfg -memcpyopt -instcombine -nary-reassociate -gvn-hoist -simplifycfg -prune-eh input.bc -o output.bc -benchmark://cBench-v0/tiffmedian,1.0029028153332273,156.72716856002808,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -strip-dead-prototypes -simplifycfg -slp-vectorizer -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -simplifycfg -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/tiffmedian,1.002743756958804,125.29713702201843,opt -sroa -gvn -simplifycfg -instcombine -strip-debug-declare -newgvn -mldst-motion -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -globaldce -slp-vectorizer -newgvn -memcpyopt -strip-debug-declare -instcombine -prune-eh -nary-reassociate -mergefunc input.bc -o output.bc -benchmark://cBench-v0/tiffmedian,0.9846508668681409,177.36504006385803,opt -sroa -gvn -simplifycfg -instcombine -loop-rotate -simplifycfg -newgvn -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -simplifycfg -instcombine -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -loop-unroll-and-jam -simplifycfg -newgvn -libcalls-shrinkwrap -nary-reassociate -simplifycfg -mergefunc input.bc -o output.bc -benchmark://cBench-v0/tiffmedian,0.9873548592333389,183.290344953537,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -loop-reduce -simplifycfg -instcombine -newgvn -simplifycfg -mldst-motion -barrier -newgvn -memcpyopt -instcombine -gvn-hoist -prune-eh -nary-reassociate -mergefunc -simplifycfg -coro-early -deadargelim -instsimplify -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/tiffmedian,1.0029028153332273,158.110027551651,opt -sroa -attributor -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -simplifycfg -callsite-splitting -newgvn -slp-vectorizer -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/tiffmedian,1.0038174009861622,156.45879292488098,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn -simplifycfg -gvn-hoist -instcombine -ipsccp -adce -simplifycfg -slp-vectorizer -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -simplifycfg -newgvn -lower-guard-intrinsic -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/tiffmedian,1.0027437569588038,138.8569803237915,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -mldst-motion -simplifycfg -newgvn -slp-vectorizer -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc input.bc -o output.bc -benchmark://cBench-v0/tiffmedian,1.0029028153332273,158.62155079841614,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -simplifycfg -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/tiffmedian,1.002147288054716,164.67037558555603,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -loop-load-elim -simplifycfg -slp-vectorizer -newgvn -instcombine -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -simplifycfg -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v0/tiffmedian,1.0090265627485289,180.88373947143555,opt -sroa -always-inline -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -simplifycfg -newgvn -simplifycfg -licm -newgvn -simplifycfg -strip-dead-prototypes -instcombine input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9999999999999998,3.3471643924713135,opt -sroa -simplifycfg -early-cse-memssa -instcombine -sroa -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9999999999999998,3.305574417114258,opt -sroa -simplifycfg -loop-reroll -early-cse-memssa -instcombine -sroa -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9999999999999998,3.324244499206543,opt -sroa -simplifycfg -early-cse-memssa -instcombine -lcssa -newgvn -sroa -jump-threading input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9999999999999998,3.299079656600952,opt -sroa -simplifycfg -loop-predication -early-cse-memssa -instcombine -sroa -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9999999999999998,3.377950668334961,opt -sroa -simplifycfg -early-cse-memssa -instcombine -sroa -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9999999999999998,3.3638758659362793,opt -sroa -simplifycfg -early-cse-memssa -instcombine -sroa -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9999999999999998,3.332183361053467,opt -sroa -simplifycfg -early-cse-memssa -instcombine -sroa -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9999999999999998,3.319218873977661,opt -sroa -simplifycfg -early-cse-memssa -instcombine -sroa -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9999999999999998,3.2783472537994385,opt -sroa -simplifycfg -early-cse-memssa -instcombine -sroa -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9999999999999998,3.307706356048584,opt -sroa -simplifycfg -early-cse-memssa -instcombine -forceattrs -sroa -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0140845070422535,3.8666810989379883,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -tailcallelim input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0140845070422535,3.8608546257019043,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -tailcallelim input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0140845070422535,3.8102853298187256,opt -loop-unroll-and-jam -mem2reg -instcombine -simplifycfg -newgvn -sroa -globalopt -instcombine -gvn-hoist -tailcallelim input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0140845070422535,3.8933515548706055,opt -mem2reg -instcombine -simplifycfg -coro-split -newgvn -sroa -instcombine -tailcallelim input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0140845070422535,2.9114677906036377,opt -instcombine -sroa -instcombine -simplifycfg -newgvn -tailcallelim -lowerinvoke -mldst-motion input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0140845070422535,3.836970090866089,opt -mem2reg -instcombine -coro-split -simplifycfg -newgvn -sroa -instcombine -tailcallelim input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0140845070422535,3.8814189434051514,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -tailcallelim input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0140845070422535,3.8782660961151123,opt -ipconstprop -mem2reg -instcombine -simplifycfg -newgvn -mldst-motion -sroa -instcombine -tailcallelim input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0140845070422535,3.8800272941589355,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -tailcallelim input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0140845070422535,3.846477508544922,opt -mem2reg -instcombine -simplifycfg -newgvn -sroa -instcombine -tailcallelim input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0232690124858117,8.110476970672607,opt -sroa -instcombine -newgvn -simplifycfg -loop-rotate -simplifycfg -instcombine -tailcallelim -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0351872871736663,7.367157936096191,opt -sroa -instcombine -loop-simplify -newgvn -simplifycfg -instcombine -dse -strip-nondebug -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0351872871736663,7.363828420639038,opt -sroa -instcombine -newgvn -lower-constant-intrinsics -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0351872871736663,7.39405083656311,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0351872871736663,7.37799596786499,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0351872871736663,7.371485710144043,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0351872871736663,7.369072198867798,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0351872871736663,7.314395189285278,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0351872871736663,7.367866277694702,opt -sroa -attributor -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -load-store-vectorizer -instcombine -ipsccp -newgvn input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0351872871736663,7.394887208938599,opt -sroa -instcombine -newgvn -simplifycfg -instcombine -dse -simplifycfg -constprop -load-store-vectorizer -instcombine -newgvn input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.0302307692307697,61.19139552116394,opt -sroa -gvn -simplifycfg -irce -instcombine -nary-reassociate -simplifycfg -newgvn -ipsccp -memcpyopt -instcombine -redundant-dbg-inst-elim -gvn-hoist -loop-versioning -jump-threading -early-cse-memssa -constmerge -dse -mergefunc -gvn-hoist -prune-eh -simplifycfg -mldst-motion -tailcallelim -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.0321538461538464,59.12892007827759,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -ipsccp -newgvn -simplifycfg -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -memcpyopt -prune-eh -simplifycfg -mldst-motion -tailcallelim -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.0301538461538464,64.346684217453,opt -sroa -insert-gcov-profiling -gvn -simplifycfg -instcombine -nary-reassociate -ipsccp -newgvn -simplifycfg -memcpyopt -instcombine -globaldce -loop-guard-widening -newgvn -simplifycfg -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -lowerinvoke -prune-eh -simplifycfg -mldst-motion -tailcallelim -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.0302307692307695,57.54291582107544,opt -sroa -gvn -loop-deletion -simplifycfg -instcombine -nary-reassociate -simplifycfg -newgvn -ipsccp -memcpyopt -strip -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -gvn-hoist -prune-eh -simplifycfg -tailcallelim -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.0303076923076924,59.354525327682495,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -ipsccp -gvn -simplifycfg -memcpyopt -tailcallelim -loop-versioning-licm -instcombine -simplifycfg -loop-predication -name-anon-globals -newgvn -simplifycfg -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -prune-eh -simplifycfg -name-anon-globals -newgvn -mldst-motion input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.0406153846153852,71.96076917648315,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -ipsccp -newgvn -simplifycfg -memcpyopt -functionattrs -newgvn -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -instcombine -simplifycfg -loop-distribute -prune-eh -simplifycfg -mldst-motion -instnamer -globalopt -gvn-hoist -tailcallelim -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.0301538461538464,64.51102471351624,opt -sroa -gvn -post-inline-ee-instrument -simplifycfg -instcombine -nary-reassociate -ipsccp -newgvn -simplifycfg -memcpyopt -instcombine -loop-load-elim -irce -newgvn -simplifycfg -gvn-hoist -jump-threading -early-cse-memssa -lower-widenable-condition -dse -mergefunc -prune-eh -simplifycfg -mldst-motion -tailcallelim -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.0301538461538464,60.58538103103638,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -guard-widening -ipsccp -newgvn -simplifycfg -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -mergefunc -prune-eh -simplifycfg -mldst-motion -loop-simplify -simplifycfg -tailcallelim -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.0394615384615389,69.45560908317566,opt -sroa -gvn -simplifycfg -slsr -coro-early -instcombine -nary-reassociate -ipsccp -jump-threading -early-cse-memssa -memcpyopt -instcombine -gvn-hoist -functionattrs -newgvn -simplifycfg -dse -loweratomic -mergefunc -instcombine -gvn-hoist -prune-eh -simplifycfg -lower-widenable-condition -newgvn -mldst-motion -globalopt -gvn-hoist -tailcallelim -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.0321538461538464,57.45151472091675,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -ipsccp -newgvn -hotcoldsplit -simplifycfg -memcpyopt -instcombine -gvn-hoist -jump-threading -early-cse-memssa -dse -ipconstprop -mergefunc -prune-eh -simplifycfg -mldst-motion -tailcallelim -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,2.325608015060425,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,2.3096039295196533,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,2.311483860015869,opt -sroa -libcalls-shrinkwrap -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,2.306170701980591,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,2.30281925201416,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,2.323596954345703,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,2.3132190704345703,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,2.3064634799957275,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,2.2902536392211914,opt -sroa -gvn -simplifycfg -instcombine -flattencfg input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,2.332601547241211,opt -mergereturn -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/dijkstra,1.0193548387096774,3.082825183868408,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/dijkstra,1.0193548387096774,3.0587315559387207,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/dijkstra,1.0193548387096774,3.0633692741394043,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/dijkstra,1.0193548387096774,3.0405640602111816,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/dijkstra,1.0193548387096774,3.0435636043548584,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/dijkstra,1.0193548387096774,3.050528049468994,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/dijkstra,1.0193548387096774,3.0575389862060547,opt -sroa -newgvn -simplifycfg -instcombine -loweratomic -gvn-hoist -partial-inliner input.bc -o output.bc +benchmark://cbench-v1/dijkstra,1.0193548387096774,3.0271060466766357,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/dijkstra,1.0193548387096774,3.0591702461242676,opt -sroa -newgvn -simplifycfg -instcombine -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.935483870967742,4.069051742553711,opt -speculative-execution -sroa -newgvn -simplifycfg -instcombine -gvn-hoist -loop-rotate -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/ghostscript,1.0023535801575092,1957.73517537117,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -mergefunc -newgvn -ipsccp -simplifycfg -mldst-motion -instcombine -memcpyopt -instcombine -simplifycfg -dse -sroa -instcombine -ipsccp -newgvn -nary-reassociate -barrier -slp-vectorizer -instcombine -gvn-hoist -bdce -globaldce -early-cse-memssa -slp-vectorizer -mldst-motion -simplifycfg -deadargelim -bdce -dse -prune-eh -mldst-motion -slsr -newgvn -mldst-motion -mergefunc -instcombine -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/ghostscript,1.001570828385668,1778.0900359153748,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -mergefunc -newgvn -ipsccp -simplifycfg -coro-cleanup -mldst-motion -instcombine -memcpyopt -coro-elide -instcombine -simplifycfg -dse -sroa -instcombine -ipsccp -newgvn -nary-reassociate -slp-vectorizer -mergereturn -instcombine -simplifycfg -gvn-hoist -bdce -globaldce -early-cse-memssa -slp-vectorizer -mldst-motion -dse -prune-eh -simplifycfg -strip -newgvn -mldst-motion -slsr -newgvn -mldst-motion input.bc -o output.bc +benchmark://cbench-v1/ghostscript,1.002332280789568,2109.468429327011,opt -sroa -gvn -simplifycfg -instcombine -newgvn -loop-data-prefetch -simplifycfg -aggressive-instcombine -gvn-hoist -mergefunc -newgvn -ipsccp -simplifycfg -mldst-motion -instcombine -memcpyopt -instcombine -simplifycfg -dse -newgvn -instcombine -ipsccp -nary-reassociate -slp-vectorizer -instcombine -gvn-hoist -sroa -inline -globaldce -gvn -bdce -deadargelim -instcombine -simplifycfg -newgvn -slp-vectorizer -mldst-motion -gvn-hoist -early-cse-memssa -simplifycfg -bdce -dse -prune-eh -inferattrs -mldst-motion -slsr -newgvn -mldst-motion -mergefunc -instcombine -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/ghostscript,1.0021885100559647,2090.4159104824066,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -mergefunc -newgvn -ipsccp -simplifycfg -mldst-motion -instcombine -memcpyopt -instcombine -simplifycfg -dse -sroa -instcombine -ipsccp -load-store-vectorizer -instcombine -newgvn -slp-vectorizer -instcombine -gvn-hoist -simplifycfg -nary-reassociate -globaldce -loop-interchange -instcombine -hotcoldsplit -simplifycfg -early-cse-memssa -bdce -mergefunc -mldst-motion -dse -simplifycfg -prune-eh -newgvn -globaldce -gvn-hoist -mldst-motion -slsr -newgvn -mldst-motion input.bc -o output.bc +benchmark://cbench-v1/ghostscript,1.007662447616867,3265.486672401428,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -mergefunc -newgvn -ipsccp -simplifycfg -mldst-motion -instcombine -memcpyopt -instcombine -simplifycfg -dse -sroa -instcombine -ipsccp -newgvn -nary-reassociate -slp-vectorizer -lower-matrix-intrinsics -instcombine -gvn-hoist -bdce -globaldce -early-cse-memssa -slp-vectorizer -mldst-motion -instnamer -simplifycfg -dse -prune-eh -newgvn -speculative-execution -newgvn -simplifycfg -gvn-hoist -instcombine -simplifycfg -newgvn -mldst-motion -simplifycfg -licm -newgvn -simplifycfg -gvn-hoist -dce -instcombine -simplifycfg -newgvn -float2int -nary-reassociate -correlated-propagation -insert-gcov-profiling -instcombine -scalarizer -instcombine -slp-vectorizer -instcombine -slp-vectorizer -newgvn -gvn-hoist -instcombine -slsr -newgvn -mldst-motion input.bc -o output.bc +benchmark://cbench-v1/ghostscript,1.0016453761734625,1860.8326251506805,opt -sroa -gvn -simplifycfg -instcombine -partially-inline-libcalls -newgvn -simplifycfg -gvn-hoist -mergefunc -tailcallelim -newgvn -ipsccp -simplifycfg -mldst-motion -instcombine -memcpyopt -instcombine -simplifycfg -dse -sroa -instcombine -ipsccp -newgvn -nary-reassociate -slp-vectorizer -instcombine -gvn-hoist -bdce -globaldce -early-cse-memssa -slp-vectorizer -mldst-motion -loop-distribute -simplifycfg -dse -prune-eh -flattencfg -newgvn -mldst-motion -slsr -newgvn -mldst-motion input.bc -o output.bc +benchmark://cbench-v1/ghostscript,1.0000692229458097,1986.2773809432983,opt -loweratomic -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -mergefunc -newgvn -ipsccp -simplifycfg -mldst-motion -instcombine -memcpyopt -instcombine -scalarizer -simplifycfg -dse -sroa -instcombine -ipsccp -newgvn -nary-reassociate -slp-vectorizer -instcombine -gvn-hoist -bdce -globaldce -loop-idiom -instcombine -lower-guard-intrinsic -simplifycfg -early-cse-memssa -slp-vectorizer -partially-inline-libcalls -mldst-motion -dse -prune-eh -simplifycfg -newgvn -mldst-motion -instsimplify -slsr -newgvn -pgo-memop-opt -mldst-motion -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/ghostscript,0.9779125554449174,2321.2995405197144,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -mergefunc -newgvn -ipsccp -lowerswitch -simplifycfg -instcombine -simplifycfg -mldst-motion -memcpyopt -instcombine -simplifycfg -dse -gvn-hoist -newgvn -instcombine -ipsccp -nary-reassociate -slp-vectorizer -instcombine -gvn-hoist -sroa -globaldce -bdce -early-cse-memssa -slp-vectorizer -dse -instcombine -simplifycfg -prune-eh -mldst-motion -mldst-motion -slsr -newgvn -newgvn -loop-instsimplify -instcombine -simplifycfg -ee-instrument -newgvn -newgvn -mldst-motion -gvn-hoist -newgvn input.bc -o output.bc +benchmark://cbench-v1/ghostscript,0.9965228781835901,2097.893942117691,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -mergefunc -newgvn -ipsccp -simplifycfg -mldst-motion -instcombine -memcpyopt -instcombine -simplifycfg -dse -sroa -globalsplit -instcombine -loop-reduce -licm -newgvn -simplifycfg -instcombine -jump-threading -infer-address-spaces -newgvn -gvn-hoist -bdce -ipsccp -simplifycfg -instcombine -aggressive-instcombine -nary-reassociate -correlated-propagation -instcombine -loop-reroll -instcombine -simplifycfg -globaldce -dse -newgvn -mldst-motion -prune-eh -early-cse-memssa -mldst-motion -simplifycfg -gvn-hoist -slsr -newgvn -nary-reassociate input.bc -o output.bc +benchmark://cbench-v1/ghostscript,1.0000798726297802,1923.4439957141876,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -mergefunc -newgvn -ipsccp -loop-simplifycfg -instcombine -simplifycfg -mldst-motion -memcpyopt -instcombine -simplifycfg -dse -ipsccp -newgvn -instcombine -nary-reassociate -slp-vectorizer -instcombine -gvn-hoist -sroa -globaldce -bdce -newgvn -add-discriminators -slp-vectorizer -dse -prune-eh -mldst-motion -instcombine -simplifycfg -mldst-motion -partial-inliner -early-cse-memssa -slsr -newgvn -mldst-motion input.bc -o output.bc +benchmark://cbench-v1/gsm,1.1495167708925527,37.8730034828186,opt -sroa -instcombine -simplifycfg -forceattrs -newgvn -slp-vectorizer -early-cse-memssa -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -rpo-functionattrs -newgvn -simplifycfg -dse -ipsccp -instcombine -mergefunc -simplifycfg -nary-reassociate -gvn-hoist -prune-eh -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/gsm,1.1381466742467308,43.94974994659424,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -loop-reduce -simplifycfg -instcombine -newgvn -dse -ipsccp -instcombine -jump-threading -nary-reassociate -gvn-hoist -prune-eh -scalarizer -instcombine -slp-vectorizer -instcombine -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/gsm,1.1495167708925527,38.894811391830444,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -ipsccp -instcombine -simplifycfg -nary-reassociate -gvn-hoist -prune-eh -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/gsm,1.1496588971006254,41.75011491775513,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -loop-unroll-and-jam -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -simplifycfg -instcombine -jump-threading -newgvn -loop-sink -name-anon-globals -post-inline-ee-instrument -simplifycfg -newgvn -dse -ipsccp -instcombine -simplifycfg -nary-reassociate -gvn-hoist -prune-eh -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/gsm,1.1509380329732803,37.99203038215637,opt -sroa -instcombine -simplifycfg -functionattrs -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -ipsccp -instcombine -dse -simplifycfg -nary-reassociate -gvn-hoist -prune-eh -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/gsm,1.1468163729391696,42.09191536903381,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -lower-guard-intrinsic -instcombine -slp-vectorizer -loop-idiom -loop-idiom -instcombine -simplifycfg -jump-threading -newgvn -reassociate -dse -callsite-splitting -ipsccp -scalarizer -instcombine -slp-vectorizer -instcombine -simplifycfg -nary-reassociate -gvn-hoist -prune-eh -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/gsm,1.1495167708925527,38.51568388938904,opt -lower-matrix-intrinsics -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -mergeicmps -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -lower-expect -callsite-splitting -dse -ipsccp -instcombine -simplifycfg -nary-reassociate -gvn-hoist -prune-eh -always-inline -simplifycfg -hotcoldsplit input.bc -o output.bc +benchmark://cbench-v1/gsm,1.1495167708925529,42.394848585128784,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -ipsccp -lower-constant-intrinsics -instcombine -simplifycfg -nary-reassociate -gvn-hoist -prune-eh -simplifycfg -loop-reroll -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/gsm,1.1496588971006252,38.50854277610779,opt -sroa -instcombine -simplifycfg -loop-vectorize -partial-inliner -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -simplifycfg -instcombine -jump-threading -reassociate -newgvn -dse -ipsccp -instcombine -simplifycfg -nary-reassociate -gvn-hoist -prune-eh -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/gsm,1.1495167708925529,40.232659101486206,opt -sroa -instcombine -simplifycfg -newgvn -slp-vectorizer -instcombine -load-store-vectorizer -instcombine -slp-vectorizer -instcombine -jump-threading -newgvn -simplifycfg -dse -ipsccp -loop-deletion -simplifycfg -instcombine -dse -simplifycfg -nary-reassociate -gvn-hoist -redundant-dbg-inst-elim -prune-eh -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/ispell,0.9484346224677719,61.475505352020264,opt -sroa -newgvn -simplifycfg -instcombine -simplifycfg -newgvn -simplifycfg -lowerswitch -simplifycfg -instcombine -simplifycfg -gvn-hoist -newgvn -ipsccp -lcssa -newgvn -strip-dead-prototypes -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -redundant-dbg-inst-elim -newgvn -mldst-motion -correlated-propagation -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/ispell,1.0005022601707687,58.671817779541016,opt -sroa -newgvn -simplifycfg -instcombine -simplifycfg -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -newgvn -jump-threading -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -simplifycfg -called-value-propagation -newgvn -mldst-motion -jump-threading input.bc -o output.bc +benchmark://cbench-v1/ispell,1.0006696802276915,58.156036138534546,opt -sroa -newgvn -simplifycfg -instcombine -simplifycfg -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -newgvn -jump-threading -loop-load-elim -simplifycfg -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -newgvn -mldst-motion -jump-threading input.bc -o output.bc +benchmark://cbench-v1/ispell,1.0005022601707687,57.86407923698425,opt -sroa -newgvn -simplifycfg -instcombine -simplifycfg -newgvn -sroa -simplifycfg -gvn-hoist -instcombine -ipsccp -newgvn -jump-threading -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -simplifycfg -newgvn -mldst-motion -jump-threading input.bc -o output.bc +benchmark://cbench-v1/ispell,0.9487694625816174,56.39859914779663,opt -lower-matrix-intrinsics -sroa -newgvn -simplifycfg -instcombine -simplifycfg -newgvn -simplifycfg -slsr -gvn-hoist -dse -lowerswitch -simplifycfg -instcombine -simplifycfg -ipsccp -rpo-functionattrs -newgvn -simplifycfg -newgvn -nary-reassociate -memcpyopt -newgvn -mldst-motion -correlated-propagation -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/ispell,1.0005022601707687,57.664350748062134,opt -consthoist -sroa -newgvn -simplifycfg -instcombine -adce -simplifycfg -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -newgvn -jump-threading -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -simplifycfg -newgvn -mldst-motion -jump-threading input.bc -o output.bc +benchmark://cbench-v1/ispell,0.9810815335677215,58.025816679000854,opt -gvn -instcombine -simplifycfg -coro-early -sroa -partial-inliner -newgvn -instcombine -simplifycfg -jump-threading -newgvn -gvn-hoist -dse -newgvn -ipsccp -irce -attributor -simplifycfg -newgvn -simplifycfg -nary-reassociate -memcpyopt -prune-eh -newgvn -mldst-motion -simplifycfg -correlated-propagation input.bc -o output.bc +benchmark://cbench-v1/ispell,1.0005022601707687,58.73056602478027,opt -sroa -newgvn -simplifycfg -instcombine -simplifycfg -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -newgvn -jump-threading -newgvn -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -simplifycfg -newgvn -mldst-motion -jump-threading input.bc -o output.bc +benchmark://cbench-v1/ispell,1.0006696802276915,56.32115340232849,opt -sroa -strip-dead-prototypes -newgvn -simplifycfg -instcombine -loop-fusion -simplifycfg -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -newgvn -jump-threading -newgvn -break-crit-edges -simplifycfg -dse -nary-reassociate -memcpyopt -newgvn -correlated-propagation -mldst-motion -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/ispell,1.0005022601707685,62.48310446739197,opt -speculative-execution -sroa -newgvn -simplifycfg -instcombine -simplifycfg -loweratomic -newgvn -simplifycfg -gvn-hoist -reg2mem -sroa -simplifycfg -instcombine -ipsccp -newgvn -jump-threading -newgvn -loop-simplifycfg -simplifycfg -correlated-propagation -dse -nary-reassociate -memcpyopt -newgvn -mldst-motion -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.022896304661033,167.0369176864624,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -mldst-motion -mldst-motion -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -ipsccp -correlated-propagation -lower-expect -newgvn -simplifycfg -gvn-hoist -newgvn -slsr -newgvn -globaldce input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.022896304661033,162.6602861881256,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -mergefunc -coro-early -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -mldst-motion -mldst-motion -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -ipsccp -correlated-propagation -newgvn -simplifycfg -gvn-hoist -newgvn -slsr -newgvn -globaldce input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.022896304661033,162.48382711410522,opt -slsr -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -name-anon-globals -instsimplify -mldst-motion -mldst-motion -mldst-motion -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -ipsccp -correlated-propagation -newgvn -simplifycfg -gvn-hoist -newgvn -slsr -newgvn -globaldce input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.022896304661033,163.83925199508667,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -mldst-motion -mldst-motion -newgvn -simplifycfg -prune-eh -coro-split -newgvn -mldst-motion -ipsccp -correlated-propagation -newgvn -simplifycfg -gvn-hoist -newgvn -slsr -newgvn -globaldce input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0228963046610333,170.10317039489746,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -loop-simplify -simplifycfg -early-cse-memssa -mldst-motion -mldst-motion -mldst-motion -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -ipsccp -correlated-propagation -newgvn -simplifycfg -gvn-hoist -newgvn -slsr -newgvn -globaldce input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0231299404228804,163.70789122581482,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -loweratomic -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -mldst-motion -mldst-motion -newgvn -simplifycfg -prune-eh -newgvn -memcpyopt -lower-guard-intrinsic -mldst-motion -ipsccp -correlated-propagation -newgvn -sink -simplifycfg -gvn-hoist -newgvn -slsr -newgvn -globaldce -argpromotion input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.022896304661033,170.07374668121338,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -mergefunc -simplifycfg -rpo-functionattrs -lower-expect -nary-reassociate -partial-inliner -memcpyopt -instsimplify -mldst-motion -mldst-motion -mldst-motion -newgvn -simplifycfg -prune-eh -newgvn -mldst-motion -ipsccp -correlated-propagation -newgvn -simplifycfg -gvn-hoist -newgvn -slsr -newgvn -globaldce input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0227794867801094,184.75065994262695,opt -sroa -always-inline -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -mldst-motion -mldst-motion -newgvn -partial-inliner -simplifycfg -prune-eh -sink -newgvn -mldst-motion -ipsccp -correlated-propagation -newgvn -scalarizer -simplifycfg -gvn-hoist -newgvn -coro-early -slsr -newgvn -div-rem-pairs -globaldce -irce -newgvn -simplifycfg -correlated-propagation input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.022896304661033,163.94377493858337,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -mldst-motion -mldst-motion -newgvn -simplifycfg -prune-eh -lower-constant-intrinsics -prune-eh -newgvn -mldst-motion -ipsccp -correlated-propagation -newgvn -simplifycfg -gvn-hoist -newgvn -slsr -newgvn -coro-split -globaldce input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0226237296055445,161.27980875968933,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -mergefunc -simplifycfg -nary-reassociate -memcpyopt -instsimplify -mldst-motion -mldst-motion -mldst-motion -loop-predication -sink -newgvn -simplifycfg -correlated-propagation -globalopt -newgvn -prune-eh -newgvn -mldst-motion -ipsccp -simplifycfg -gvn-hoist -newgvn -slsr -newgvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0218300233175202,162.80999040603638,opt -sroa -gvn -simplifycfg -loop-fusion -instcombine -simplifycfg -gvn-hoist -newgvn -mergefunc -nary-reassociate -memcpyopt -instcombine -simplifycfg -div-rem-pairs -mldst-motion -mldst-motion -mldst-motion -simplifycfg -newgvn -mldst-motion -instcombine -simplifycfg -ipsccp -slsr -newgvn -globaldce -constprop -correlated-propagation -instcombine -sroa -simplifycfg -nary-reassociate input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0217898206963092,155.09252095222473,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -simplifycfg -mergefunc -nary-reassociate -memcpyopt -instcombine -mldst-motion -mldst-motion -newgvn -mldst-motion -simplifycfg -mldst-motion -ipsccp -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -instcombine -simplifycfg -nary-reassociate input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0217898206963092,158.51034665107727,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -simplifycfg -mergefunc -attributor -nary-reassociate -memcpyopt -argpromotion -instcombine -mldst-motion -newgvn -insert-gcov-profiling -mldst-motion -mldst-motion -coro-early -simplifycfg -mldst-motion -lower-widenable-condition -ipsccp -slsr -newgvn -globaldce -forceattrs -gvn-hoist -correlated-propagation -simplifycfg -instcombine -simplifycfg -nary-reassociate input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0217898206963092,154.6300506591797,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -simplifycfg -mergefunc -nary-reassociate -memcpyopt -instcombine -mldst-motion -mldst-motion -newgvn -mldst-motion -simplifycfg -mldst-motion -ipsccp -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -instcombine -simplifycfg -nary-reassociate input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0217898206963092,157.87810039520264,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -simplifycfg -mergefunc -nary-reassociate -memcpyopt -instcombine -mldst-motion -mldst-motion -newgvn -mldst-motion -simplifycfg -mldst-motion -ipsccp -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -instcombine -simplifycfg -nary-reassociate input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0217898206963092,163.5455927848816,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -simplifycfg -mergefunc -nary-reassociate -memcpyopt -instcombine -mldst-motion -mldst-motion -newgvn -nary-reassociate -mldst-motion -simplifycfg -break-crit-edges -simplifycfg -mldst-motion -ipsccp -inject-tli-mappings -coro-split -slsr -newgvn -insert-gcov-profiling -globaldce -gvn-hoist -correlated-propagation -simplifycfg -strip-debug-declare -instcombine -simplifycfg -nary-reassociate input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0217898206963092,154.0655062198639,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -simplifycfg -mergefunc -nary-reassociate -memcpyopt -instcombine -mldst-motion -mldst-motion -newgvn -mldst-motion -simplifycfg -mldst-motion -ipsccp -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -instcombine -simplifycfg -nary-reassociate input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.02183002331752,161.41529035568237,opt -sroa -gvn -simplifycfg -canonicalize-aliases -instcombine -gvn-hoist -newgvn -simplifycfg -mergefunc -nary-reassociate -memcpyopt -instcombine -mldst-motion -mldst-motion -newgvn -mldst-motion -simplifycfg -mldst-motion -ipsccp -slsr -newgvn -globaldce -gvn-hoist -simple-loop-unswitch -newgvn -simplifycfg -correlated-propagation -instcombine -simplifycfg -nary-reassociate input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0217898206963092,155.45213294029236,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -pgo-memop-opt -newgvn -simplifycfg -mergefunc -nary-reassociate -memcpyopt -instcombine -mldst-motion -mldst-motion -newgvn -mldst-motion -simplifycfg -mldst-motion -ipsccp -slsr -newgvn -insert-gcov-profiling -globaldce -gvn-hoist -correlated-propagation -simplifycfg -instcombine -simplifycfg -nary-reassociate input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0217898206963092,156.0222954750061,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -simplifycfg -prune-eh -mergefunc -nary-reassociate -memcpyopt -instcombine -mldst-motion -mldst-motion -newgvn -mldst-motion -hotcoldsplit -simplifycfg -mldst-motion -ipsccp -slsr -newgvn -globaldce -gvn-hoist -correlated-propagation -simplifycfg -inject-tli-mappings -instcombine -simplifycfg -nary-reassociate input.bc -o output.bc +benchmark://cbench-v1/lame,1.1155323029663051,167.26788115501404,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -gvn-hoist -bdce -ipsccp -memcpyopt -instcombine -dse -mldst-motion -simplifycfg -adce -globalopt -instcombine -newgvn -simplifycfg -prune-eh -mergefunc -instcombine -jump-threading -instcombine -simplifycfg -newgvn -instcombine -globalsplit -globalopt -prune-eh -gvn-hoist -newgvn -dse input.bc -o output.bc +benchmark://cbench-v1/lame,1.115532302966305,164.133118391037,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -gvn-hoist -dce -ipsccp -memcpyopt -bdce -dse -instcombine -mldst-motion -simplifycfg -globalopt -instcombine -newgvn -simplifycfg -prune-eh -mergefunc -instcombine -jump-threading -instcombine -simplifycfg -newgvn -instcombine -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc +benchmark://cbench-v1/lame,1.1141883459729292,148.71487617492676,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -loop-instsimplify -simplifycfg -instcombine -gvn-hoist -bdce -ipsccp -memcpyopt -newgvn -simplifycfg -dse -mldst-motion -loop-reroll -simplifycfg -instcombine -simplifycfg -globalopt -instcombine -newgvn -prune-eh -mergefunc -instcombine -globalopt -dse input.bc -o output.bc +benchmark://cbench-v1/lame,1.1191801862340403,159.07205843925476,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -gvn-hoist -bdce -ipsccp -memcpyopt -instcombine -dse -loop-versioning-licm -newgvn -simplifycfg -mldst-motion -globalopt -instcombine -simplifycfg -licm -newgvn -simplifycfg -prune-eh -mergefunc -gvn-hoist -instcombine -newgvn -globalopt -dse -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/lame,1.1175962369204187,160.42251658439636,opt -sroa -gvn -simplifycfg -instcombine -indvars -newgvn -mergereturn -simplifycfg -nary-reassociate -gvn-hoist -instcombine -ipsccp -memcpyopt -bdce -dse -simplifycfg -mldst-motion -newgvn -globalopt -instcombine -simplifycfg -prune-eh -newgvn -mergefunc -instsimplify -globalopt -gvn-hoist -dse -correlated-propagation -instsimplify -nary-reassociate input.bc -o output.bc +benchmark://cbench-v1/lame,1.1160122876067964,167.25811386108398,opt -sroa -nary-reassociate -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -bdce -bdce -nary-reassociate -ipsccp -memcpyopt -instcombine -dse -mldst-motion -insert-gcov-profiling -simplifycfg -scalarizer -globalopt -instcombine -newgvn -simplifycfg -prune-eh -mergefunc -instcombine -lower-matrix-intrinsics -jump-threading -instcombine -simplifycfg -newgvn -instcombine -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc +benchmark://cbench-v1/lame,1.107900547182491,171.84539914131165,opt -gvn -instcombine -simplifycfg -newgvn -sroa -newgvn -nary-reassociate -instcombine -simplifycfg -gvn-hoist -newgvn -ipsccp -memcpyopt -bdce -dse -globalopt -instcombine -simplifycfg -mldst-motion -simplifycfg -early-cse-memssa -newgvn -prune-eh -jump-threading -instcombine -simplifycfg -sroa -mergefunc -newgvn -globalopt -gvn-hoist -canonicalize-aliases -newgvn -dse -dce input.bc -o output.bc +benchmark://cbench-v1/lame,1.1158682922146492,172.36621642112732,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -gvn-hoist -bdce -ipsccp -memcpyopt -instcombine -dse -mldst-motion -simplifycfg -globalopt -instcombine -newgvn -simplifycfg -prune-eh -mergefunc -instcombine -jump-threading -instcombine -simplifycfg -newgvn -instcombine -slp-vectorizer -instcombine -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc +benchmark://cbench-v1/lame,1.1155803014303542,166.15596842765808,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -tailcallelim -simplifycfg -gvn-hoist -alignment-from-assumptions -bdce -ipsccp -memcpyopt -instcombine -dse -mldst-motion -simplifycfg -globalopt -instcombine -newgvn -simplifycfg -prune-eh -inject-tli-mappings -mergefunc -instcombine -jump-threading -instcombine -simplifycfg -newgvn -instcombine -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc +benchmark://cbench-v1/lame,1.1155323029663051,167.29455971717834,opt -sroa -gvn -simplifycfg -instcombine -nary-reassociate -newgvn -simplifycfg -gvn-hoist -bdce -ipsccp -memcpyopt -instcombine -dse -mldst-motion -simplifycfg -globalopt -instcombine -newgvn -simplifycfg -prune-eh -mergefunc -instcombine -jump-threading -instcombine -simplifycfg -newgvn -instcombine -globalopt -gvn-hoist -newgvn -dse input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9693094629156009,3.9266302585601807,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9705882352941178,4.825629711151123,opt -sroa -simplifycfg -newgvn -sccp -ipsccp -adce -simplifycfg -newgvn -tailcallelim -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9693094629156009,3.8992760181427,opt -correlated-propagation -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9693094629156009,3.912933349609375,opt -sroa -ipsccp -gvn -simplifycfg -separate-const-offset-from-gep -reassociate -tailcallelim -jump-threading input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9693094629156009,4.404894113540649,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -lcssa -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9693094629156009,3.931546211242676,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9693094629156009,3.909588575363159,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9705882352941176,5.27163028717041,opt -simplifycfg -loop-versioning-licm -loop-deletion -sroa -ipsccp -newgvn -simplifycfg -newgvn -newgvn -simplifycfg -tailcallelim -reassociate -jump-threading input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9693094629156009,3.8775691986083984,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9693094629156009,3.929682970046997,opt -sroa -ipsccp -gvn -simplifycfg -reassociate -tailcallelim -jump-threading input.bc -o output.bc +benchmark://cbench-v1/qsort,1.029197080291971,3.5581681728363037,opt -sroa -gvn -simplifycfg -instcombine -newgvn -coro-elide -simplifycfg -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/qsort,0.9744525547445256,3.591317653656006,opt -sroa -gvn -simplifycfg -loop-rotate -instcombine -deadargelim -div-rem-pairs -simplifycfg -newgvn -barrier -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/qsort,1.029197080291971,3.514180898666382,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/qsort,1.029197080291971,3.069769859313965,opt -sroa -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/qsort,1.029197080291971,3.5526814460754395,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -strip-dead-prototypes -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/qsort,1.029197080291971,3.538724899291992,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/qsort,1.029197080291971,3.5244412422180176,opt -sroa -barrier -gvn -simplifycfg -instcombine -newgvn -simplifycfg -hotcoldsplit -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/qsort,1.029197080291971,3.529522657394409,opt -sroa -gvn -simplifycfg -instcombine -newgvn -bdce -simplifycfg -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/qsort,1.029197080291971,3.5224571228027344,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/qsort,1.0145985401459854,3.466933250427246,opt -loop-load-elim -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1151767151767153,8.526031732559204,opt -sroa -instcombine -gvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1151767151767153,9.324137210845947,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1151767151767153,9.431487083435059,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1151767151767153,9.38455605506897,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -slsr -newgvn -jump-threading -instcombine -die input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1151767151767153,9.348448514938354,opt -sroa -instcombine -gvn -mergereturn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -pgo-memop-opt -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1151767151767153,9.432142496109009,opt -sroa -pgo-memop-opt -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1151767151767151,12.2704598903656,opt -sroa -instcombine -gvn -simplifycfg -die -loop-interchange -reassociate -memcpyopt -instcombine -simplifycfg -gvn-hoist -newgvn -jump-threading -instcombine -loop-load-elim -simple-loop-unswitch -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1151767151767153,9.399054765701294,opt -sroa -instcombine -gvn -simplifycfg -alignment-from-assumptions -lower-matrix-intrinsics -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1151767151767153,9.413830041885376,opt -sroa -instcombine -gvn -simplifycfg -instcombine -gvn-hoist -newgvn -jump-threading -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1151767151767153,9.393671989440918,opt -sroa -instcombine -gvn -simplifycfg -mergereturn -instcombine -gvn-hoist -flattencfg -newgvn -jump-threading -instcombine input.bc -o output.bc +benchmark://cbench-v1/sha,1.553191489361702,3.252039909362793,opt -sroa -gvn -simplifycfg -instcombine -add-discriminators -newgvn -ipsccp input.bc -o output.bc +benchmark://cbench-v1/sha,1.553191489361702,3.23064923286438,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc +benchmark://cbench-v1/sha,1.548936170212766,4.220396995544434,opt -sroa -gvn -simplifycfg -instcombine -functionattrs -licm -newgvn -simplifycfg -ipsccp -loop-simplify -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/sha,1.553191489361702,4.221415758132935,opt -strip -sroa -strip-debug-declare -gvn -simplifycfg -reg2mem -sroa -instcombine -simplifycfg -newgvn -ipsccp input.bc -o output.bc +benchmark://cbench-v1/sha,1.553191489361702,3.221076726913452,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp -canonicalize-aliases input.bc -o output.bc +benchmark://cbench-v1/sha,1.553191489361702,3.246673583984375,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc +benchmark://cbench-v1/sha,1.553191489361702,3.227952480316162,opt -sroa -gvn -simplifycfg -constmerge -instcombine -newgvn -ipsccp input.bc -o output.bc +benchmark://cbench-v1/sha,1.557446808510638,3.208369731903076,opt -sroa -gvn -simplifycfg -instcombine -memcpyopt -newgvn -coro-split -ipsccp input.bc -o output.bc +benchmark://cbench-v1/sha,1.553191489361702,3.2176291942596436,opt -sroa -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc +benchmark://cbench-v1/sha,1.553191489361702,3.220510244369507,opt -sroa -forceattrs -gvn -simplifycfg -instcombine -newgvn -ipsccp input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0143149284253579,4.852210521697998,opt -sroa -newgvn -simplifycfg -instcombine -jump-threading -partial-inliner -newgvn -gvn-hoist -newgvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0143149284253579,4.825301647186279,opt -sroa -newgvn -simplifycfg -ee-instrument -instcombine -jump-threading -newgvn -gvn-hoist -newgvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0143149284253579,4.837324857711792,opt -sroa -newgvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -newgvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0143149284253579,4.83894157409668,opt -sroa -newgvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -newgvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0143149284253579,4.832793951034546,opt -sroa -newgvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -newgvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0122699386503067,6.490794897079468,opt -sroa -newgvn -simplifycfg -instcombine -jump-threading -loop-deletion -gvn -simplifycfg -gvn-hoist -newgvn -loop-unswitch -instcombine -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0143149284253579,4.842012643814087,opt -sroa -newgvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -newgvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0143149284253579,4.311517715454102,opt -sroa -newgvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -bdce input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0143149284253579,4.877126693725586,opt -sroa -newgvn -simplifycfg -instcombine -jump-threading -newgvn -gvn-hoist -newgvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0143149284253579,4.864404916763306,opt -sroa -newgvn -simplifycfg -instcombine -jump-threading -pgo-memop-opt -ee-instrument -newgvn -gvn-hoist -newgvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9742268041237113,2.238586187362671,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9742268041237113,2.196035623550415,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9742268041237113,2.195099115371704,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9742268041237113,2.6221635341644287,opt -sroa -gvn -simplifycfg -loop-reroll -instcombine -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9742268041237113,2.192682981491089,opt -sroa -mergereturn -gvn -infer-address-spaces -name-anon-globals -simplifycfg -newgvn -instcombine input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9742268041237113,2.186244487762451,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9742268041237113,2.2214152812957764,opt -sroa -gvn -simplifycfg -instcombine -post-inline-ee-instrument input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9742268041237113,2.1809301376342773,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9742268041237113,2.1874279975891113,opt -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9742268041237113,2.164578437805176,opt -lower-guard-intrinsic -sroa -gvn -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/susan,1.0062154696132597,21.237401962280273,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -simplifycfg -coro-early -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/susan,1.0073204419889503,21.022145748138428,opt -sroa -licm -newgvn -instcombine -simplifycfg -nary-reassociate -gvn-hoist -slsr -nary-reassociate -newgvn -instcombine -simplifycfg -newgvn -newgvn -mldst-motion -simplifycfg -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/susan,1.002900552486188,24.97674560546875,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -loop-simplify -simplifycfg -newgvn -instcombine -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -lowerswitch -simplifycfg -instcombine -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/susan,1.0040055248618784,21.214195251464844,opt -sroa -lowerswitch -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/susan,1.0062154696132597,23.505887031555176,opt -irce -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -simplifycfg -gvn-hoist -newgvn -newgvn -loop-versioning-licm -newgvn -simplifycfg -mldst-motion -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/susan,1.0062154696132597,20.977452278137207,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -globalopt -mem2reg -gvn-hoist -flattencfg -newgvn -guard-widening -instcombine -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/susan,1.0062154696132597,21.33326506614685,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/susan,1.0062154696132595,22.355042695999146,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -mem2reg -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -simplifycfg -gvn-hoist -newgvn -newgvn -mldst-motion -loop-versioning-licm -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/susan,1.0062154696132597,23.273910999298096,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -globalopt -newgvn -instcombine -simplifycfg -gvn-hoist -newgvn -newgvn -irce -newgvn -simplifycfg -mldst-motion -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/susan,1.0062154696132597,21.12042999267578,opt -sroa -newgvn -instcombine -simplifycfg -nary-reassociate -slsr -nary-reassociate -gvn-hoist -newgvn -instcombine -simplifycfg -gvn-hoist -newgvn -newgvn -correlated-propagation -mldst-motion -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.004535996670828,150.02621173858643,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -gvn -tailcallelim -simplifycfg -lower-constant-intrinsics -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.004369538077403,147.0981001853943,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -gvn -simplifycfg -memcpyopt -instcombine -prune-eh -newgvn -nary-reassociate -mergefunc input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0043695380774031,140.48020720481873,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -mldst-motion -newgvn -memcpyopt -instcombine -gvn -simplifycfg -prune-eh -newgvn -nary-reassociate -mergefunc input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,0.9884727424053266,154.1393620967865,opt -partial-inliner -sroa -gvn -simplifycfg -instcombine -newgvn -loop-reduce -simplifycfg -instcombine -newgvn -gvn-hoist -instcombine -simplifycfg -ipsccp -loop-versioning-licm -instcombine -simplifycfg -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -strip-nondebug -mergefunc -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.004369538077403,140.4969711303711,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -sroa -instcombine -lower-widenable-condition -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -gvn -simplifycfg -memcpyopt -instcombine -prune-eh -newgvn -nary-reassociate -libcalls-shrinkwrap -mergefunc input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0035372451102786,154.5895640850067,opt -globalopt -sroa -gvn -simplifycfg -instcombine -loop-load-elim -simplifycfg -newgvn -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -mldst-motion -simplifycfg -gvn -simplifycfg -memcpyopt -instcombine -prune-eh -newgvn -nary-reassociate -mergefunc input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0035372451102784,166.6245219707489,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -gvn -simplifycfg -memcpyopt -instcombine -prune-eh -newgvn -loop-sink -instcombine -simplifycfg -sink -newgvn -nary-reassociate -mergefunc input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0012068248023298,150.62344455718994,opt -sroa -gvn -callsite-splitting -simplifycfg -attributor -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -libcalls-shrinkwrap -simplifycfg -slp-vectorizer -newgvn -adce -constmerge -mldst-motion -gvn -simplifycfg -memcpyopt -correlated-propagation -instcombine -simplifycfg -prune-eh -newgvn -nary-reassociate -mergefunc input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.004369538077403,144.84855127334595,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -aggressive-instcombine -newgvn -mldst-motion -gvn -simplifycfg -memcpyopt -instcombine -prune-eh -newgvn -nary-reassociate -mergefunc input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.003995006242197,154.96046471595764,opt -sroa -slp-vectorizer -strip-dead-prototypes -gvn -simplifycfg -instcombine -mergeicmps -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -gvn -simplifycfg -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -simplifycfg -die -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0079806125433504,140.1571226119995,opt -coro-early -licm -sroa -gvn -simplifycfg -instcombine -newgvn -bdce -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -mldst-motion -newgvn -memcpyopt -instcombine -ee-instrument -nary-reassociate -mergefunc -simplifycfg -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0043036811097648,169.4242286682129,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -float2int -slp-vectorizer -newgvn -mldst-motion -loop-simplifycfg -instcombine -simplifycfg -gvn -simplifycfg -memcpyopt -forceattrs -instcombine -lower-constant-intrinsics -nary-reassociate -mergefunc -gvn-hoist -simplifycfg -newgvn -simplifycfg -attributor input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0023816487694814,151.39407300949097,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -correlated-propagation -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -mldst-motion -simplifycfg -newgvn -memcpyopt -instcombine -nary-reassociate -correlated-propagation -simplifycfg -newgvn -simplifycfg -alignment-from-assumptions -mergefunc input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0051393473446708,164.57986044883728,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -coro-split -gvn -simplifycfg -memcpyopt -instcombine -newgvn -nary-reassociate -mergefunc -gvn-hoist -simplifycfg -newgvn -simplifycfg -die input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0051393473446708,165.66000533103943,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -mem2reg -ipsccp -simplifycfg -attributor -slp-vectorizer -newgvn -mldst-motion -gvn -simplifycfg -memcpyopt -instcombine -newgvn -nary-reassociate -mergefunc -gvn-hoist -simplifycfg -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0051393473446708,164.64863204956055,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -gvn -simplifycfg -memcpyopt -instcombine -newgvn -nary-reassociate -mergefunc -gvn-hoist -simplifycfg -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0054736138386327,170.99662113189697,opt -sroa -gvn -simplifycfg -instcombine -inline -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -loop-unroll-and-jam -instcombine -simplifycfg -slp-vectorizer -newgvn -mldst-motion -functionattrs -newgvn -memcpyopt -instcombine -gvn-hoist -nary-reassociate -mergefunc -gvn -simplifycfg -newgvn -gvn-hoist -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0051393473446708,163.80334520339966,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -gvn -simplifycfg -memcpyopt -instcombine -constmerge -newgvn -nary-reassociate -mergefunc -gvn-hoist -simplifycfg -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0042618977980196,169.33936262130737,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -gvn -simplifycfg -memcpyopt -instcombine -newgvn -nary-reassociate -mergefunc -name-anon-globals -gvn-hoist -loop-versioning-licm -instcombine -simplifycfg -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0044708143567458,172.3550157546997,opt -loop-guard-widening -sroa -gvn -simplifycfg -instcombine -newgvn -loop-simplifycfg -instcombine -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -gvn -simplifycfg -slp-vectorizer -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -nary-reassociate -mergefunc -gvn-hoist -simplifycfg -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.00364245342265,182.47542238235474,opt -sroa -loop-unroll-and-jam -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -gvn -simplifycfg -newgvn -nary-reassociate -coro-elide -mergefunc -gvn-hoist -simplifycfg -newgvn -sancov -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.0046054008792127,179.6926872730255,opt -sroa -gvn -loop-distribute -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -coro-early -ipsccp -simplifycfg -slp-vectorizer -simplifycfg -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -gvn -simplifycfg -newgvn -nary-reassociate -mergefunc -gvn-hoist -simplifycfg -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.0046054008792127,181.03862118721008,opt -sroa -gvn -simplifycfg -float2int -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -gvn -simplifycfg -newgvn -nary-reassociate -mergefunc -gvn-hoist -simplifycfg -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.0038099225455306,152.89263606071472,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -load-store-vectorizer -instcombine -gvn -slp-vectorizer -instcombine -bdce -simplifycfg -gvn-hoist -mldst-motion -newgvn -prune-eh -instcombine -simplifycfg -nary-reassociate -mergefunc -loop-versioning input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.001507222105924,206.75270867347717,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -gvn -simplifycfg -newgvn -nary-reassociate -mergefunc -scalarizer -slp-vectorizer -instsimplify -gvn-hoist -simplifycfg -newgvn -correlated-propagation -instcombine -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.0046054008792127,181.0861098766327,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -inline -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -gvn -simplifycfg -newgvn -nary-reassociate -mergefunc -gvn-hoist -simplifycfg -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.0074523759681808,152.34258794784546,opt -licm -sroa -gvn -simplifycfg -instcombine -newgvn -bdce -simplifycfg -callsite-splitting -gvn-hoist -instcombine -ipsccp -simplifycfg -mldst-motion -newgvn -memcpyopt -instcombine -loop-versioning -prune-eh -nary-reassociate -loop-interchange -instcombine -simplifycfg -newgvn -simplifycfg -mergefunc input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.0046054008792127,181.79122877120972,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -consthoist -simplifycfg -slp-vectorizer -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -strip-debug-declare -prune-eh -gvn -loop-distribute -simplifycfg -newgvn -nary-reassociate -pgo-memop-opt -mergefunc -gvn-hoist -simplifycfg -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.0046054008792127,179.61281037330627,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -separate-const-offset-from-gep -mldst-motion -newgvn -lower-expect -memcpyopt -instcombine -prune-eh -gvn -simplifycfg -newgvn -nary-reassociate -mergefunc -gvn-hoist -simplifycfg -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.00343311701905,160.62122535705566,opt -sroa -gvn -forceattrs -simplifycfg -loop-load-elim -instcombine -simplifycfg -float2int -newgvn -mergefunc -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -mldst-motion -indvars -instcombine -simplifycfg -gvn -simplifycfg -memcpyopt -instcombine -nary-reassociate -gvn-hoist -simplifycfg -prune-eh input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0029028153332273,156.72716856002808,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -strip-dead-prototypes -simplifycfg -slp-vectorizer -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -simplifycfg -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.002743756958804,125.29713702201843,opt -sroa -gvn -simplifycfg -instcombine -strip-debug-declare -newgvn -mldst-motion -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -globaldce -slp-vectorizer -newgvn -memcpyopt -strip-debug-declare -instcombine -prune-eh -nary-reassociate -mergefunc input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,0.9846508668681409,177.36504006385803,opt -sroa -gvn -simplifycfg -instcombine -loop-rotate -simplifycfg -newgvn -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -simplifycfg -instcombine -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -loop-unroll-and-jam -simplifycfg -newgvn -libcalls-shrinkwrap -nary-reassociate -simplifycfg -mergefunc input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,0.9873548592333389,183.290344953537,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -loop-reduce -simplifycfg -instcombine -newgvn -simplifycfg -mldst-motion -barrier -newgvn -memcpyopt -instcombine -gvn-hoist -prune-eh -nary-reassociate -mergefunc -simplifycfg -coro-early -deadargelim -instsimplify -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0029028153332273,158.110027551651,opt -sroa -attributor -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -simplifycfg -callsite-splitting -newgvn -slp-vectorizer -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0038174009861622,156.45879292488098,opt -sroa -gvn -simplifycfg -instcombine -newgvn -gvn -simplifycfg -gvn-hoist -instcombine -ipsccp -adce -simplifycfg -slp-vectorizer -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -simplifycfg -newgvn -lower-guard-intrinsic -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0027437569588038,138.8569803237915,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -simplifycfg -ipsccp -slp-vectorizer -newgvn -mldst-motion -simplifycfg -newgvn -slp-vectorizer -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0029028153332273,158.62155079841614,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -simplifycfg -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.002147288054716,164.67037558555603,opt -sroa -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -loop-load-elim -simplifycfg -slp-vectorizer -newgvn -instcombine -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -simplifycfg -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0090265627485289,180.88373947143555,opt -sroa -always-inline -gvn -simplifycfg -instcombine -newgvn -simplifycfg -gvn-hoist -instcombine -ipsccp -simplifycfg -slp-vectorizer -newgvn -mldst-motion -newgvn -memcpyopt -instcombine -prune-eh -nary-reassociate -mergefunc -simplifycfg -newgvn -simplifycfg -licm -newgvn -simplifycfg -strip-dead-prototypes -instcombine input.bc -o output.bc diff --git a/leaderboard/llvm_instcount/random_search/results_p125_t10.csv b/leaderboard/llvm_instcount/random_search/results_p125_t10.csv index 3f166a1af..2098e1dbf 100644 --- a/leaderboard/llvm_instcount/random_search/results_p125_t10.csv +++ b/leaderboard/llvm_instcount/random_search/results_p125_t10.csv @@ -1,231 +1,231 @@ benchmark,reward,walltime,commandline -benchmark://cBench-v1/adpcm,0.994413407821229,12.527162551879883,opt -indvars -loop-unroll -infer-address-spaces -guard-widening -loop-reroll -loop-simplifycfg -loop-interchange -partial-inliner -nary-reassociate -loop-unroll-and-jam -coro-cleanup -rewrite-statepoints-for-gc -mergeicmps -slsr -loop-distribute -reassociate -lcssa -inferattrs -alignment-from-assumptions -coro-cleanup -loop-load-elim -mem2reg -slp-vectorizer -instsimplify -canonicalize-aliases -globalsplit -loop-reroll -instcombine -loop-load-elim -loop-simplifycfg -sroa -lower-widenable-condition -loop-instsimplify -rewrite-statepoints-for-gc -simplifycfg -rpo-functionattrs -sccp -nary-reassociate -lowerinvoke -loop-data-prefetch -lower-guard-intrinsic -loop-predication -sink -rpo-functionattrs -constprop -loop-unswitch -reassociate -lower-matrix-intrinsics -attributor -pgo-memop-opt -elim-avail-extern -inline -reassociate -speculative-execution -mem2reg -libcalls-shrinkwrap -jump-threading -loop-vectorize -loop-reduce -coro-split -functionattrs -simplifycfg -load-store-vectorizer -constprop -infer-address-spaces -loop-distribute -loop-versioning-licm -mergefunc -globalsplit -licm -lower-matrix-intrinsics -barrier -forceattrs -name-anon-globals -ee-instrument -cross-dso-cfi -lowerinvoke -instsimplify -pgo-memop-opt -die -reassociate -gvn input.bc -o output.bc -benchmark://cBench-v1/adpcm,0.9972067039106146,11.98168158531189,opt -post-inline-ee-instrument -called-value-propagation -alignment-from-assumptions -licm -prune-eh -loop-simplifycfg -loop-deletion -redundant-dbg-inst-elim -loop-sink -sroa -coro-early -mergereturn -lowerswitch -constprop -instsimplify -name-anon-globals -mergereturn -ipconstprop -alignment-from-assumptions -cross-dso-cfi -nary-reassociate -strip-debug-declare -instsimplify -argpromotion -post-inline-ee-instrument -loop-unswitch -barrier -indvars -strip-debug-declare -lowerinvoke -ee-instrument -instcombine -simplifycfg -loop-load-elim -break-crit-edges -argpromotion -load-store-vectorizer -loop-load-elim -callsite-splitting -newgvn -loop-reduce -gvn-hoist -inferattrs -loop-reduce -slp-vectorizer -irce -callsite-splitting -coro-early -add-discriminators -loop-sink -loop-reduce -die -called-value-propagation -constprop -rpo-functionattrs -irce -loop-versioning -deadargelim -loop-idiom -strip-debug-declare -post-inline-ee-instrument -loop-unroll -indvars -strip-debug-declare -separate-const-offset-from-gep -inline -loweratomic -loop-guard-widening -indvars -libcalls-shrinkwrap -loop-idiom -loweratomic -memcpyopt -callsite-splitting -coro-cleanup -pgo-memop-opt -instsimplify -reg2mem -float2int -add-discriminators -lower-constant-intrinsics -lower-expect -loop-simplify -globaldce -inject-tli-mappings -flattencfg -inject-tli-mappings -globalsplit -sroa -lower-expect -adce -forceattrs -loop-deletion -loop-simplify -inject-tli-mappings -sancov -inferattrs -loop-versioning -newgvn -loop-reroll -loop-load-elim -simplifycfg -instsimplify input.bc -o output.bc -benchmark://cBench-v1/adpcm,0.9972067039106146,12.768595933914185,opt -barrier -loop-predication -infer-address-spaces -loop-reroll -add-discriminators -prune-eh -aggressive-instcombine -strip -reg2mem -mldst-motion -alignment-from-assumptions -callsite-splitting -loop-unroll-and-jam -sancov -loop-predication -memcpyopt -loop-distribute -lower-expect -licm -break-crit-edges -deadargelim -sccp -loop-predication -sancov -correlated-propagation -slp-vectorizer -globalopt -gvn -slsr -lower-constant-intrinsics -loop-distribute -post-inline-ee-instrument -aggressive-instcombine -simplifycfg -instnamer -simple-loop-unswitch -reg2mem -inject-tli-mappings -constmerge -called-value-propagation -dce -mergeicmps -reassociate -strip-nondebug -forceattrs -consthoist -ipconstprop -strip-dead-prototypes -strip -redundant-dbg-inst-elim -attributor -deadargelim -mergereturn -loop-distribute -strip-dead-prototypes -forceattrs -constprop -partial-inliner -constmerge -argpromotion -elim-avail-extern -inferattrs -loop-simplify -globalsplit -loop-simplifycfg -lowerinvoke -sroa -mem2reg -loop-sink -deadargelim -adce -lower-matrix-intrinsics -loop-unroll -slp-vectorizer -globalopt -loop-instsimplify -nary-reassociate -loop-reduce -lowerinvoke -libcalls-shrinkwrap -rewrite-statepoints-for-gc -deadargelim -inject-tli-mappings -pgo-memop-opt -loop-unswitch -gvn-hoist -sroa -tailcallelim -lowerinvoke -simple-loop-unswitch -inline -loop-load-elim -consthoist -strip -strip-nondebug -slp-vectorizer -prune-eh -add-discriminators -lower-guard-intrinsic -add-discriminators -canonicalize-aliases -flattencfg -mldst-motion -simple-loop-unswitch -globalsplit -simple-loop-unswitch -mergeicmps -slsr -mergeicmps -strip-dead-prototypes -instnamer -load-store-vectorizer -float2int -mldst-motion -coro-early -partially-inline-libcalls -sccp -consthoist -float2int -attributor -constmerge -strip-dead-prototypes -ee-instrument -sccp -early-cse-memssa -strip -instsimplify -early-cse-memssa -die -loop-load-elim -loop-sink -mergereturn -gvn-hoist -consthoist -dce -constprop -sccp -float2int -inject-tli-mappings -guard-widening -slp-vectorizer -loop-unroll-and-jam -lowerswitch -inferattrs -lower-widenable-condition -globaldce -lowerswitch -sccp -lower-constant-intrinsics -float2int -inline -slp-vectorizer -sroa -dse -loop-unroll-and-jam -loop-versioning -tailcallelim -mem2reg -partial-inliner -loop-fusion -infer-address-spaces -mldst-motion -break-crit-edges -loop-predication -loop-unroll -newgvn -callsite-splitting -die -div-rem-pairs -instcombine -loop-data-prefetch -constmerge -float2int -redundant-dbg-inst-elim -simple-loop-unswitch -sroa -simple-loop-unswitch -loop-deletion -callsite-splitting -simplifycfg -loweratomic -loop-sink -inline -memcpyopt -add-discriminators -instnamer -loop-unroll -loop-deletion -globaldce -constprop -inject-tli-mappings -rewrite-statepoints-for-gc -always-inline -loop-simplify -lower-expect -loop-reroll -simple-loop-unswitch -correlated-propagation -coro-split -flattencfg -loweratomic -aggressive-instcombine -scalarizer -loop-idiom -separate-const-offset-from-gep -attributor -die -rewrite-statepoints-for-gc -coro-split -newgvn input.bc -o output.bc -benchmark://cBench-v1/adpcm,0.9972067039106147,12.197010517120361,opt -guard-widening -name-anon-globals -name-anon-globals -barrier -strip-nondebug -mem2reg -add-discriminators -pgo-memop-opt -insert-gcov-profiling -sink -die -sancov -strip-dead-prototypes -indvars -mergereturn -rewrite-statepoints-for-gc -loop-versioning-licm -loop-reduce -bdce -mergefunc -adce -flattencfg -guard-widening -break-crit-edges -mldst-motion -instsimplify -instnamer -instsimplify -bdce -instcombine -mergefunc -forceattrs -coro-early -loweratomic -loop-unswitch -infer-address-spaces -loop-fusion -load-store-vectorizer -rewrite-statepoints-for-gc -licm -ipsccp -separate-const-offset-from-gep -post-inline-ee-instrument -mergeicmps -mldst-motion -partial-inliner -attributor -load-store-vectorizer -partially-inline-libcalls -ee-instrument -nary-reassociate -dce -attributor -loop-distribute -functionattrs -name-anon-globals -nary-reassociate -ipsccp -globalsplit -strip-debug-declare -rpo-functionattrs -ee-instrument -strip-debug-declare -licm -inject-tli-mappings -sancov -forceattrs -early-cse-memssa -instnamer -bdce -licm -lower-widenable-condition -deadargelim -always-inline -loop-deletion -partially-inline-libcalls -newgvn -sink -ipsccp -add-discriminators -slp-vectorizer -div-rem-pairs -infer-address-spaces -loop-deletion -correlated-propagation -correlated-propagation -instnamer -loop-idiom -name-anon-globals -deadargelim -mergeicmps -coro-split -irce -tailcallelim -called-value-propagation -lower-expect -licm -loop-versioning -mergereturn -tailcallelim -loop-versioning-licm -aggressive-instcombine -functionattrs -mem2reg -constprop -sroa -lower-expect -mem2reg -libcalls-shrinkwrap -loweratomic -sccp -sccp -ipconstprop -barrier -loop-distribute -loop-versioning -lower-constant-intrinsics -redundant-dbg-inst-elim -scalarizer -aggressive-instcombine -gvn-hoist -speculative-execution -loop-unroll -partial-inliner -simple-loop-unswitch -alignment-from-assumptions -memcpyopt -strip -float2int -loop-vectorize -loop-versioning-licm -loop-vectorize -loop-reduce -rpo-functionattrs -die -loop-versioning-licm -loop-unswitch -licm -loop-reroll -called-value-propagation -always-inline -strip -lower-expect -newgvn -constmerge -loop-versioning-licm -adce -loop-predication -simple-loop-unswitch -consthoist -cross-dso-cfi -licm -adce -lower-widenable-condition -loop-idiom -simplifycfg -barrier -slp-vectorizer -loop-simplify -loop-unroll-and-jam -gvn-hoist -strip-dead-prototypes -inferattrs -loop-data-prefetch -elim-avail-extern -sccp -loweratomic -correlated-propagation -div-rem-pairs -lcssa -add-discriminators -functionattrs -instcombine -constprop -loop-instsimplify -strip-nondebug -separate-const-offset-from-gep -loop-load-elim -sccp -name-anon-globals -float2int -lower-expect -loop-simplify -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v1/adpcm,0.9972067039106147,12.215384006500244,opt -scalarizer -loop-distribute -mldst-motion -hotcoldsplit -loop-guard-widening -mergefunc -infer-address-spaces -add-discriminators -ipconstprop -cross-dso-cfi -tailcallelim -deadargelim -dce -instsimplify -loop-deletion -strip-nondebug -ipsccp -constprop -loop-instsimplify -inferattrs -loop-instsimplify -adce -forceattrs -tailcallelim -inferattrs -div-rem-pairs -loop-guard-widening -canonicalize-aliases -infer-address-spaces -always-inline -inject-tli-mappings -name-anon-globals -elim-avail-extern -scalarizer -strip-nondebug -elim-avail-extern -partial-inliner -coro-cleanup -irce -deadargelim -loop-reroll -ipconstprop -loop-simplify -redundant-dbg-inst-elim -loop-reroll -mergeicmps -scalarizer -lower-guard-intrinsic -loop-instsimplify -loop-deletion -irce -barrier -loop-unswitch -lower-expect -name-anon-globals -lower-widenable-condition -infer-address-spaces -mem2reg -loop-simplifycfg -elim-avail-extern -rewrite-statepoints-for-gc -adce -libcalls-shrinkwrap -post-inline-ee-instrument -reg2mem -bdce -strip -loop-instsimplify -newgvn -lower-expect -pgo-memop-opt -loop-simplify -globalopt -coro-split -sancov -instsimplify -constprop -loop-vectorize -mem2reg -redundant-dbg-inst-elim -slp-vectorizer -partially-inline-libcalls -callsite-splitting -constmerge -loop-simplify -loop-interchange -loop-unroll -loop-load-elim -inline -loop-load-elim -rewrite-statepoints-for-gc -memcpyopt -rpo-functionattrs -scalarizer -sancov -strip-dead-prototypes -constmerge -loop-sink -name-anon-globals -constmerge -globalsplit -lower-expect -nary-reassociate -loop-versioning-licm -lower-guard-intrinsic -adce -partial-inliner -loop-vectorize -called-value-propagation -partial-inliner -lower-guard-intrinsic -strip -loop-simplifycfg -lower-expect -mem2reg -simplifycfg -coro-cleanup -nary-reassociate -loop-simplify -barrier -loop-guard-widening -lower-matrix-intrinsics -bdce -deadargelim -loop-fusion -cross-dso-cfi -strip-nondebug -separate-const-offset-from-gep -sink -loop-vectorize -cross-dso-cfi -loop-unroll -correlated-propagation -loop-simplifycfg -lcssa -ipsccp -load-store-vectorizer -loop-reroll -simplifycfg -coro-elide -consthoist -gvn-hoist -elim-avail-extern -instsimplify -jump-threading -instsimplify -sancov -deadargelim -die -instnamer -add-discriminators -alignment-from-assumptions -sink -forceattrs -coro-early -dse -ipconstprop -loop-reroll -aggressive-instcombine -loop-reroll -globalsplit -mergeicmps -gvn -strip-debug-declare -sroa -instnamer -irce -sink -newgvn -add-discriminators -loop-deletion -strip-nondebug -instsimplify -loop-unroll -barrier -guard-widening -name-anon-globals -mergereturn -loop-vectorize -early-cse-memssa -die -bdce -reassociate -bdce -pgo-memop-opt -cross-dso-cfi -loop-interchange -mldst-motion -lower-widenable-condition -adce -add-discriminators -strip-dead-prototypes -lower-constant-intrinsics -attributor -simple-loop-unswitch -deadargelim -lowerswitch -loweratomic -callsite-splitting -gvn-hoist -flattencfg -speculative-execution -loop-unswitch -lowerswitch -mem2reg -loop-simplify -slsr -lcssa -canonicalize-aliases -canonicalize-aliases -slsr -always-inline -cross-dso-cfi -lowerinvoke -indvars -early-cse-memssa -callsite-splitting -globalsplit -lower-guard-intrinsic -coro-elide -insert-gcov-profiling -lower-widenable-condition -gvn-hoist -elim-avail-extern -dce -loweratomic -lower-constant-intrinsics -nary-reassociate -add-discriminators -adce -prune-eh -gvn -insert-gcov-profiling -cross-dso-cfi -memcpyopt -ipsccp -called-value-propagation -reassociate -irce -pgo-memop-opt -licm -loop-unroll-and-jam -deadargelim -dse -lower-widenable-condition -loop-simplify -lowerinvoke -memcpyopt -bdce -sancov -instsimplify -forceattrs -strip-dead-prototypes -consthoist -mem2reg -redundant-dbg-inst-elim -memcpyopt -inline -hotcoldsplit -jump-threading -gvn-hoist -mergeicmps -gvn -mem2reg -name-anon-globals -lower-expect -loop-sink -strip-nondebug -ee-instrument -attributor -ipsccp -licm -pgo-memop-opt -post-inline-ee-instrument -sink -loop-reduce -early-cse-memssa -loop-guard-widening -licm -break-crit-edges -lower-constant-intrinsics -canonicalize-aliases -loop-data-prefetch -coro-early -instnamer -simplifycfg -infer-address-spaces -instcombine -lowerswitch -coro-early -instsimplify -loop-versioning -add-discriminators -slsr -partial-inliner -barrier -coro-cleanup -lowerswitch -reassociate -licm -loop-unroll -loop-sink -strip-dead-prototypes -nary-reassociate -deadargelim -globaldce -simplifycfg -argpromotion -libcalls-shrinkwrap -prune-eh -loop-deletion -infer-address-spaces -early-cse-memssa -loop-unroll -infer-address-spaces -attributor -add-discriminators -flattencfg -load-store-vectorizer -lower-constant-intrinsics -loop-predication -early-cse-memssa -ipsccp -lowerswitch -speculative-execution -newgvn -sancov -flattencfg -reg2mem -ipsccp -libcalls-shrinkwrap -loop-idiom -lower-widenable-condition -loop-idiom -argpromotion -functionattrs -memcpyopt -mergefunc -loop-sink -globalsplit -always-inline -inject-tli-mappings -ee-instrument -loop-distribute -constprop -memcpyopt -simplifycfg -guard-widening -globaldce -ee-instrument -lowerinvoke -loop-sink -inject-tli-mappings -consthoist -rpo-functionattrs -infer-address-spaces -float2int -lower-guard-intrinsic -tailcallelim -correlated-propagation -loop-unroll-and-jam -pgo-memop-opt -scalarizer -load-store-vectorizer -instnamer -insert-gcov-profiling -alignment-from-assumptions -globalsplit -inject-tli-mappings -cross-dso-cfi -slsr -tailcallelim -dce -loop-data-prefetch -callsite-splitting -mergeicmps -callsite-splitting -globalopt -dse -pgo-memop-opt -aggressive-instcombine -irce -div-rem-pairs -lowerswitch -dce -post-inline-ee-instrument -libcalls-shrinkwrap -ipconstprop -lcssa -callsite-splitting -attributor -loop-idiom -mem2reg input.bc -o output.bc -benchmark://cBench-v1/adpcm,0.9999999999999999,12.475622177124023,opt -loweratomic -prune-eh -guard-widening -prune-eh -constmerge -gvn-hoist -gvn -coro-cleanup -load-store-vectorizer -scalarizer -jump-threading -slp-vectorizer -lower-guard-intrinsic -loop-reduce -nary-reassociate -mem2reg -lower-matrix-intrinsics -tailcallelim -constmerge -aggressive-instcombine -forceattrs -name-anon-globals -licm -constprop -consthoist -loop-deletion -pgo-memop-opt -div-rem-pairs -loop-simplifycfg -argpromotion -inject-tli-mappings -globalopt -slsr -loop-deletion -gvn -coro-elide -hotcoldsplit -instcombine -infer-address-spaces -loop-guard-widening -loop-vectorize -loop-sink -name-anon-globals -elim-avail-extern -redundant-dbg-inst-elim -loop-versioning -break-crit-edges -scalarizer -elim-avail-extern -irce -functionattrs -constprop -coro-cleanup -lower-constant-intrinsics -coro-early -mem2reg -correlated-propagation -sink -early-cse-memssa -early-cse-memssa -add-discriminators -dse -loop-distribute -libcalls-shrinkwrap -constprop -loop-instsimplify -loop-distribute -strip-dead-prototypes -strip-nondebug -libcalls-shrinkwrap -lower-matrix-intrinsics -coro-elide -tailcallelim -callsite-splitting -lowerswitch -libcalls-shrinkwrap -loop-simplify -lcssa -gvn-hoist -flattencfg -instnamer -load-store-vectorizer -dse -infer-address-spaces -loop-unswitch -prune-eh -forceattrs -alignment-from-assumptions -consthoist -guard-widening -lower-matrix-intrinsics -redundant-dbg-inst-elim -coro-cleanup -scalarizer -simple-loop-unswitch -rewrite-statepoints-for-gc -coro-early -sink -lcssa -gvn-hoist -loop-distribute -loop-deletion -insert-gcov-profiling -loop-distribute -loop-interchange -globalsplit -add-discriminators -loop-simplify -simplifycfg -prune-eh -always-inline -lower-guard-intrinsic -irce -simplifycfg -strip-debug-declare -argpromotion -strip -instcombine -sancov -gvn-hoist -consthoist -lowerinvoke -globalopt -loop-reduce -consthoist -argpromotion -rpo-functionattrs -deadargelim -jump-threading -barrier -functionattrs -speculative-execution -argpromotion -loop-distribute -bdce -mergereturn -ipconstprop -loop-fusion -loop-idiom -loop-guard-widening -mldst-motion -name-anon-globals -post-inline-ee-instrument -newgvn -functionattrs -lower-matrix-intrinsics -float2int -loop-sink -post-inline-ee-instrument -loop-idiom -scalarizer -always-inline -name-anon-globals -coro-early -strip -gvn -load-store-vectorizer -loop-reduce -flattencfg -inferattrs -reg2mem -aggressive-instcombine -bdce -argpromotion -memcpyopt -lcssa -loop-distribute -infer-address-spaces -add-discriminators -coro-split -lower-widenable-condition -strip-dead-prototypes -lower-guard-intrinsic -always-inline -add-discriminators -called-value-propagation -bdce -mergefunc -instnamer -loop-reroll -tailcallelim -div-rem-pairs -loweratomic -reg2mem -sancov -coro-elide -ee-instrument -sroa -argpromotion -simplifycfg -simplifycfg -partially-inline-libcalls -inferattrs -gvn -sancov -strip-nondebug -lcssa -licm -tailcallelim -ee-instrument -canonicalize-aliases -loop-fusion -functionattrs -lowerswitch -always-inline -alignment-from-assumptions -loop-simplify -lowerinvoke -separate-const-offset-from-gep -lowerswitch -lcssa -gvn -alignment-from-assumptions -sink -aggressive-instcombine -break-crit-edges -scalarizer -float2int -indvars -gvn -ipconstprop -loop-guard-widening -nary-reassociate -instcombine -die -loop-unswitch -loop-idiom -pgo-memop-opt -consthoist -loop-unroll-and-jam -slsr -attributor -adce -gvn-hoist -slp-vectorizer -strip -mem2reg -lower-widenable-condition -strip-nondebug -licm -coro-elide -ee-instrument -consthoist -constprop -simplifycfg -functionattrs -coro-cleanup -alignment-from-assumptions -called-value-propagation -slsr -functionattrs -loop-reroll -loop-simplifycfg -forceattrs -cross-dso-cfi -loop-data-prefetch -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/adpcm,1.0000000000000002,12.368368148803711,opt -libcalls-shrinkwrap -globaldce -globalopt -loop-sink -callsite-splitting -post-inline-ee-instrument -mergeicmps -jump-threading -loop-instsimplify -mldst-motion -lowerswitch -sccp -sccp -elim-avail-extern -gvn -add-discriminators -ipsccp -loop-versioning-licm -insert-gcov-profiling -mergeicmps -coro-cleanup -bdce -constprop -strip -loop-fusion -callsite-splitting -early-cse-memssa -mergefunc -loop-instsimplify -strip-nondebug -forceattrs -forceattrs -mergereturn -strip-dead-prototypes -coro-split -aggressive-instcombine -reassociate -coro-cleanup -loop-simplifycfg -sink -load-store-vectorizer -constprop -loop-unswitch -loop-distribute -lower-matrix-intrinsics -float2int -pgo-memop-opt -loop-unroll -loop-unroll-and-jam -guard-widening -reg2mem -ee-instrument -always-inline -strip -slp-vectorizer -flattencfg -deadargelim -called-value-propagation -globalopt -mldst-motion -consthoist -infer-address-spaces -loop-fusion -infer-address-spaces -post-inline-ee-instrument -partial-inliner -loop-sink -deadargelim -sroa -lcssa -loop-versioning-licm -simplifycfg -simplifycfg -load-store-vectorizer -deadargelim -partial-inliner -loop-fusion -redundant-dbg-inst-elim -partial-inliner -partially-inline-libcalls -elim-avail-extern -constprop -loop-deletion -memcpyopt -lowerswitch -loop-predication -strip-debug-declare -lower-guard-intrinsic -dce -indvars -licm -deadargelim -coro-early -partially-inline-libcalls -functionattrs -loop-instsimplify -loop-idiom -lowerswitch -separate-const-offset-from-gep -instsimplify -redundant-dbg-inst-elim -loop-deletion -scalarizer -instcombine -memcpyopt -irce -lower-guard-intrinsic -indvars -loop-distribute -mem2reg -gvn -aggressive-instcombine -loop-interchange -always-inline -rewrite-statepoints-for-gc -lower-widenable-condition -partial-inliner -sccp -alignment-from-assumptions -gvn-hoist -attributor -dse -bdce -insert-gcov-profiling -argpromotion -gvn -loop-distribute -loop-simplify -die -instnamer -memcpyopt -coro-elide -coro-split -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/adpcm,1.0027932960893855,12.703411340713501,opt -irce -consthoist -separate-const-offset-from-gep -sroa -add-discriminators -inferattrs -sroa -loop-data-prefetch -forceattrs -partially-inline-libcalls -loop-fusion -mldst-motion -flattencfg -loop-distribute -simplifycfg -callsite-splitting -separate-const-offset-from-gep -sccp -lower-constant-intrinsics -instcombine -indvars -loop-vectorize -add-discriminators -nary-reassociate -strip-debug-declare -float2int -loop-distribute -insert-gcov-profiling -jump-threading -reassociate -flattencfg -sink -add-discriminators -memcpyopt -strip-dead-prototypes -loop-vectorize -ipconstprop -loop-vectorize -lower-constant-intrinsics -prune-eh -correlated-propagation -loop-idiom -loop-fusion -coro-cleanup -lowerswitch -cross-dso-cfi -adce -strip-nondebug -speculative-execution -mergefunc -lower-widenable-condition -infer-address-spaces -alignment-from-assumptions -sccp -gvn -newgvn -strip-debug-declare -loop-sink -strip -div-rem-pairs -guard-widening -strip-debug-declare -slsr -strip-dead-prototypes -strip -loop-interchange -always-inline -mergefunc -sccp -gvn -tailcallelim -consthoist -separate-const-offset-from-gep -instcombine input.bc -o output.bc -benchmark://cBench-v1/adpcm,1.005586592178771,12.421398878097534,opt -loop-interchange -mldst-motion -instcombine -speculative-execution -loop-load-elim -loop-versioning -strip-debug-declare -partially-inline-libcalls -simplifycfg -libcalls-shrinkwrap -globaldce -globalopt -barrier -prune-eh -infer-address-spaces -reassociate -loop-unroll -callsite-splitting -reg2mem -loop-load-elim -dse -called-value-propagation -loop-versioning-licm -infer-address-spaces -mergefunc -loop-interchange -nary-reassociate -die -loop-data-prefetch -coro-early -loop-vectorize -constprop -newgvn -scalarizer -mergefunc -loop-guard-widening -globalsplit -loop-unswitch -correlated-propagation -partially-inline-libcalls -early-cse-memssa -strip-nondebug -sancov -loop-versioning -speculative-execution -newgvn -alignment-from-assumptions -mergereturn -licm -coro-split -mergeicmps -newgvn -lower-widenable-condition -strip-nondebug -redundant-dbg-inst-elim -globaldce -tailcallelim -jump-threading -coro-elide -instnamer -redundant-dbg-inst-elim -break-crit-edges -add-discriminators -mergefunc -argpromotion -add-discriminators -newgvn -tailcallelim -ipconstprop -lowerinvoke -attributor -insert-gcov-profiling -load-store-vectorizer -loop-versioning -indvars -lower-expect -simplifycfg -instsimplify -constmerge -loop-distribute -loop-load-elim -sink -cross-dso-cfi -cross-dso-cfi -loop-simplify -attributor -loop-reduce -loop-idiom -argpromotion -pgo-memop-opt -loop-load-elim -partial-inliner -mem2reg -instcombine -coro-early -mem2reg -gvn-hoist -sink -div-rem-pairs -tailcallelim -sroa -reassociate -callsite-splitting -aggressive-instcombine -aggressive-instcombine -loop-reroll -memcpyopt -ee-instrument -div-rem-pairs -break-crit-edges -globaldce -tailcallelim -early-cse-memssa -die -loop-reroll -functionattrs -strip -loop-distribute -load-store-vectorizer -div-rem-pairs -infer-address-spaces -slp-vectorizer -canonicalize-aliases -coro-cleanup -load-store-vectorizer -strip-debug-declare -cross-dso-cfi -loop-simplifycfg -gvn-hoist -sroa -simplifycfg -loop-versioning-licm -loop-vectorize -nary-reassociate -forceattrs -lower-matrix-intrinsics -barrier -partially-inline-libcalls -flattencfg -aggressive-instcombine -flattencfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/adpcm,1.005586592178771,12.565289497375488,opt -coro-cleanup -loop-versioning-licm -libcalls-shrinkwrap -loop-versioning-licm -redundant-dbg-inst-elim -lower-guard-intrinsic -loop-simplifycfg -slp-vectorizer -functionattrs -lower-widenable-condition -nary-reassociate -loop-idiom -adce -loop-instsimplify -lowerinvoke -constprop -cross-dso-cfi -globaldce -argpromotion -loop-unroll-and-jam -strip-nondebug -irce -strip -dse -load-store-vectorizer -loop-fusion -pgo-memop-opt -canonicalize-aliases -memcpyopt -load-store-vectorizer -slp-vectorizer -canonicalize-aliases -elim-avail-extern -separate-const-offset-from-gep -reassociate -alignment-from-assumptions -flattencfg -lcssa -globalopt -post-inline-ee-instrument -bdce -coro-split -sink -rpo-functionattrs -loop-reroll -reg2mem -consthoist -lower-matrix-intrinsics -strip-debug-declare -simplifycfg -alignment-from-assumptions -separate-const-offset-from-gep -always-inline -loop-distribute -loop-predication -loop-simplifycfg -deadargelim -lowerinvoke -loop-data-prefetch -loop-load-elim -libcalls-shrinkwrap -lcssa -loop-load-elim -float2int -scalarizer -scalarizer -nary-reassociate -lower-matrix-intrinsics -mergereturn -lower-expect -name-anon-globals -lowerswitch -ipconstprop -mergefunc -loop-reroll -coro-cleanup -guard-widening -loop-simplify -alignment-from-assumptions -div-rem-pairs -barrier -partial-inliner -loop-fusion -gvn-hoist -licm -strip-debug-declare -sink -aggressive-instcombine -loop-deletion -slsr -ee-instrument -lower-constant-intrinsics -mergereturn -insert-gcov-profiling -bdce -memcpyopt -simplifycfg -loop-versioning -globalopt -elim-avail-extern -loop-unswitch -prune-eh -ipconstprop -irce -inject-tli-mappings -lowerinvoke -rewrite-statepoints-for-gc -dse -forceattrs -sink -loop-fusion -alignment-from-assumptions -loop-unroll-and-jam -libcalls-shrinkwrap -scalarizer -instcombine -post-inline-ee-instrument -lower-guard-intrinsic -redundant-dbg-inst-elim -gvn -strip-debug-declare -cross-dso-cfi -instcombine -called-value-propagation -newgvn -lowerswitch -functionattrs -early-cse-memssa -inject-tli-mappings -mergeicmps -indvars -sancov -infer-address-spaces -die -loop-versioning-licm -div-rem-pairs -loop-vectorize -early-cse-memssa -ee-instrument -gvn-hoist -ipconstprop -alignment-from-assumptions -instcombine -constmerge -alignment-from-assumptions -gvn-hoist -dse -functionattrs -reg2mem -strip-debug-declare -lowerswitch -irce -memcpyopt -aggressive-instcombine -early-cse-memssa -globalopt -strip -loop-simplifycfg -loop-deletion -rewrite-statepoints-for-gc -partial-inliner -cross-dso-cfi -newgvn -sccp -post-inline-ee-instrument -correlated-propagation -adce -alignment-from-assumptions -deadargelim -loop-instsimplify -coro-split -attributor -strip-nondebug -ipsccp -break-crit-edges -insert-gcov-profiling -ipconstprop -sroa -elim-avail-extern -bdce -partial-inliner -loop-simplifycfg -jump-threading -inject-tli-mappings -lowerinvoke -loop-unswitch -lower-expect -attributor -nary-reassociate -globalopt -redundant-dbg-inst-elim -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/bitcount,0.9867256637168141,12.089999437332153,opt -canonicalize-aliases -globaldce -newgvn -callsite-splitting -sancov -globalsplit -sroa -scalarizer -inject-tli-mappings -die -mergeicmps -coro-split -loop-deletion -jump-threading -strip -coro-cleanup -infer-address-spaces -flattencfg -inferattrs -loop-idiom -lower-matrix-intrinsics -alignment-from-assumptions -indvars -mergereturn -globalopt -lowerswitch -lowerinvoke -sccp -inferattrs -jump-threading -mem2reg -strip-debug-declare -hotcoldsplit -simplifycfg -loop-predication -coro-cleanup -jump-threading -partially-inline-libcalls -mergeicmps -strip-dead-prototypes -guard-widening -simplifycfg -loop-unroll -memcpyopt -memcpyopt -instcombine -sccp -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/bitcount,0.991150442477876,12.189716339111328,opt -barrier -reassociate -sancov -partial-inliner -adce -globalsplit -gvn -cross-dso-cfi -inject-tli-mappings -nary-reassociate -coro-elide -loop-vectorize -loop-data-prefetch -mldst-motion -inferattrs -mergeicmps -add-discriminators -loop-fusion -mergefunc -ipsccp -loop-reduce -licm -coro-cleanup -strip-nondebug -loop-reroll -newgvn -deadargelim -coro-elide -barrier -load-store-vectorizer -gvn -lower-guard-intrinsic -always-inline -loop-reduce -always-inline -mergeicmps -lower-guard-intrinsic -die -alignment-from-assumptions -mergereturn -constprop -loop-idiom -correlated-propagation -ipconstprop -globaldce -scalarizer -gvn -partial-inliner -loop-fusion -coro-cleanup -functionattrs -partially-inline-libcalls -infer-address-spaces -mldst-motion -loop-unswitch -strip-nondebug -deadargelim -libcalls-shrinkwrap -inferattrs -rpo-functionattrs -loop-predication -loop-data-prefetch -post-inline-ee-instrument -loop-unswitch -newgvn -callsite-splitting -loop-deletion -ipsccp -inferattrs -early-cse-memssa -loop-unswitch -instnamer -lower-matrix-intrinsics -instsimplify -elim-avail-extern -loop-simplifycfg -ipsccp -attributor -simplifycfg -licm -float2int -instnamer -div-rem-pairs -loop-sink -reassociate -loop-unroll -ee-instrument -sroa -called-value-propagation -newgvn -mergefunc -bdce -loop-guard-widening -pgo-memop-opt -rpo-functionattrs -die -consthoist -loop-distribute -loop-load-elim -div-rem-pairs -nary-reassociate -nary-reassociate -rewrite-statepoints-for-gc -barrier -speculative-execution -instsimplify -sink -lower-widenable-condition -prune-eh -coro-elide -jump-threading -attributor -constprop -float2int -coro-elide -reassociate -loop-distribute -globalsplit -load-store-vectorizer -rpo-functionattrs -licm -strip-dead-prototypes -separate-const-offset-from-gep -rewrite-statepoints-for-gc -dse -constprop -licm -strip -loop-predication -inject-tli-mappings -aggressive-instcombine -constmerge -loop-versioning -licm -simple-loop-unswitch -elim-avail-extern -constmerge -loop-load-elim -dce -rpo-functionattrs -sancov -strip-nondebug -float2int -indvars -irce -strip -loop-reroll -gvn-hoist -infer-address-spaces -pgo-memop-opt -scalarizer -prune-eh -bdce -loop-instsimplify -rpo-functionattrs -ee-instrument -loop-idiom -redundant-dbg-inst-elim -scalarizer -aggressive-instcombine -partially-inline-libcalls -post-inline-ee-instrument -loop-unroll-and-jam -consthoist -scalarizer -indvars -lower-guard-intrinsic -lower-matrix-intrinsics -flattencfg -newgvn -globalopt -instnamer -irce -slsr -callsite-splitting -loop-distribute -ee-instrument -lowerswitch -rewrite-statepoints-for-gc -dce -flattencfg -canonicalize-aliases -load-store-vectorizer -insert-gcov-profiling -name-anon-globals -ipconstprop -loop-deletion -bdce -strip -instcombine -lowerswitch -pgo-memop-opt -loop-guard-widening -functionattrs -name-anon-globals -loop-unroll -instcombine -float2int -slsr -irce -loop-fusion -adce -loop-instsimplify -lowerinvoke -loop-reduce -loop-instsimplify -post-inline-ee-instrument -instnamer -prune-eh -loop-simplify -consthoist -canonicalize-aliases -guard-widening -lowerswitch -partially-inline-libcalls -elim-avail-extern -coro-cleanup -mergeicmps -loop-unswitch -mem2reg -licm -inferattrs -name-anon-globals -infer-address-spaces -loop-simplify -loop-instsimplify -elim-avail-extern -gvn-hoist -jump-threading -loop-reduce -functionattrs -globalsplit -add-discriminators -loop-unroll -loop-predication -slsr -loop-unswitch -instsimplify -newgvn -adce -constprop -callsite-splitting -deadargelim -constmerge -adce -flattencfg -dce -jump-threading -lower-widenable-condition -lowerswitch -licm -loop-data-prefetch -lower-constant-intrinsics -loop-vectorize -loop-reduce -strip -memcpyopt -loweratomic -constprop -ipsccp -div-rem-pairs -aggressive-instcombine -strip -correlated-propagation -loop-load-elim -ipsccp -deadargelim -strip -load-store-vectorizer -loop-distribute -deadargelim -lcssa -loop-reduce -strip-debug-declare -called-value-propagation -canonicalize-aliases -dse -scalarizer -loop-instsimplify -loop-vectorize -jump-threading -mergereturn -flattencfg -loop-simplifycfg -inject-tli-mappings -constprop -scalarizer -simple-loop-unswitch -sccp -insert-gcov-profiling -separate-const-offset-from-gep -mergeicmps -loop-guard-widening -loop-unroll -loop-deletion -loop-guard-widening -constmerge -bdce -libcalls-shrinkwrap -loop-distribute -simple-loop-unswitch -mergefunc -newgvn -loop-versioning-licm -always-inline -lowerswitch -loop-distribute -elim-avail-extern -newgvn -gvn-hoist -cross-dso-cfi -rpo-functionattrs -libcalls-shrinkwrap -dce -called-value-propagation -adce -mldst-motion -sroa -coro-cleanup -rewrite-statepoints-for-gc -insert-gcov-profiling -ee-instrument -simple-loop-unswitch -attributor -forceattrs -float2int -inject-tli-mappings -loop-data-prefetch -slsr -strip-nondebug -prune-eh -attributor -mergereturn -gvn -slsr -canonicalize-aliases -post-inline-ee-instrument -always-inline -bdce -licm -speculative-execution -tailcallelim -lower-matrix-intrinsics -coro-cleanup -loop-unroll -ipconstprop -inline -separate-const-offset-from-gep -loop-instsimplify -scalarizer -consthoist -nary-reassociate -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/bitcount,0.9933628318584071,15.541126012802124,opt -hotcoldsplit -globaldce -adce -loop-predication -ee-instrument -adce -always-inline -div-rem-pairs -loop-reduce -mergefunc -constprop -rewrite-statepoints-for-gc -gvn-hoist -sroa -nary-reassociate -coro-early -lower-guard-intrinsic -elim-avail-extern -sink -strip-dead-prototypes -loop-idiom -guard-widening -lowerswitch -mergefunc -inject-tli-mappings -redundant-dbg-inst-elim -gvn-hoist -separate-const-offset-from-gep -loop-load-elim -nary-reassociate -coro-cleanup -nary-reassociate -strip-nondebug -mldst-motion -globalopt -name-anon-globals -jump-threading -div-rem-pairs -lower-guard-intrinsic -lower-guard-intrinsic -guard-widening -strip-debug-declare -barrier -loop-reroll -reg2mem -strip -rpo-functionattrs -dce -ee-instrument -gvn-hoist -deadargelim -globalopt -loop-interchange -loop-interchange -sancov -div-rem-pairs -loop-guard-widening -loop-simplify -jump-threading -sink -loweratomic -lower-guard-intrinsic -mergeicmps -strip -lower-guard-intrinsic -inject-tli-mappings -jump-threading -loop-predication -infer-address-spaces -indvars -loop-simplifycfg -loop-vectorize -sink -loop-deletion -loop-vectorize -instcombine -lower-constant-intrinsics -strip -loop-versioning -gvn-hoist -partial-inliner -reassociate -inferattrs -loop-vectorize -redundant-dbg-inst-elim -lower-expect -break-crit-edges -loop-versioning-licm -forceattrs -strip-nondebug -inject-tli-mappings -reg2mem -loop-simplify -loop-predication -lower-expect -instnamer -flattencfg -instsimplify -cross-dso-cfi -barrier -loop-vectorize -tailcallelim -die -lcssa -instnamer -instsimplify -infer-address-spaces -inferattrs -argpromotion -loop-sink -flattencfg -memcpyopt -correlated-propagation -loop-fusion -insert-gcov-profiling -ipsccp -loop-simplify -redundant-dbg-inst-elim -mergeicmps -slsr -loop-data-prefetch -reg2mem -instcombine -lowerinvoke -die -gvn-hoist -globalsplit -strip-dead-prototypes -strip-nondebug -callsite-splitting -sroa -inject-tli-mappings -jump-threading -mldst-motion -loop-simplify -loop-simplify -guard-widening -loop-versioning-licm -loop-interchange -memcpyopt -cross-dso-cfi -insert-gcov-profiling -forceattrs -simplifycfg -mldst-motion -scalarizer -loop-vectorize -loweratomic -die -hotcoldsplit -consthoist -called-value-propagation -irce -constmerge -name-anon-globals -redundant-dbg-inst-elim -loop-distribute -prune-eh -loop-predication -insert-gcov-profiling -loop-simplifycfg -loweratomic -tailcallelim -instcombine -mergeicmps -div-rem-pairs -forceattrs -elim-avail-extern -constprop -lowerswitch -inline -lowerswitch -globaldce -forceattrs -rewrite-statepoints-for-gc -alignment-from-assumptions -irce -loop-fusion -indvars -loop-predication -sccp -canonicalize-aliases -prune-eh -functionattrs -nary-reassociate -loop-reduce -coro-cleanup -instcombine -lower-guard-intrinsic -irce -slsr -prune-eh -constprop -cross-dso-cfi -deadargelim -alignment-from-assumptions -name-anon-globals -prune-eh -early-cse-memssa -prune-eh -slp-vectorizer -early-cse-memssa -ee-instrument -loop-simplifycfg -libcalls-shrinkwrap -separate-const-offset-from-gep -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/bitcount,0.9955752212389379,12.356438875198364,opt -loop-predication -gvn-hoist -add-discriminators -prune-eh -loop-vectorize -globalsplit -callsite-splitting -mem2reg -loop-interchange -loop-simplify -infer-address-spaces -speculative-execution -float2int -coro-early -mergeicmps -cross-dso-cfi -loop-interchange -adce -loop-unroll-and-jam -instnamer -hotcoldsplit -coro-cleanup -lower-expect -loop-predication -infer-address-spaces -float2int -gvn -break-crit-edges -instnamer -loop-predication -called-value-propagation -argpromotion -callsite-splitting -instnamer -loop-interchange -loop-deletion -lower-guard-intrinsic -loop-predication -indvars -callsite-splitting -libcalls-shrinkwrap -elim-avail-extern -strip -pgo-memop-opt -callsite-splitting -aggressive-instcombine -sancov -loop-simplifycfg -forceattrs -sccp -lower-matrix-intrinsics -libcalls-shrinkwrap -pgo-memop-opt -gvn -slsr -redundant-dbg-inst-elim -strip-dead-prototypes -loop-distribute -coro-early -sroa -inferattrs -redundant-dbg-inst-elim -infer-address-spaces -correlated-propagation -loop-reroll -coro-split -strip-dead-prototypes -simple-loop-unswitch -pgo-memop-opt -strip -loop-distribute -instcombine -div-rem-pairs -consthoist -canonicalize-aliases -loop-sink -loop-guard-widening -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/bitcount,0.995575221238938,12.109670162200928,opt -lowerswitch -newgvn -redundant-dbg-inst-elim -loop-distribute -rewrite-statepoints-for-gc -canonicalize-aliases -globaldce -rpo-functionattrs -loop-distribute -loop-predication -coro-early -strip -irce -lowerinvoke -lowerswitch -globalopt -coro-cleanup -loop-unroll -argpromotion -loop-versioning -speculative-execution -die -add-discriminators -sancov -speculative-execution -strip-debug-declare -sancov -loop-vectorize -consthoist -gvn -globalopt -loop-interchange -flattencfg -loop-versioning -libcalls-shrinkwrap -ee-instrument -loop-fusion -loop-unroll-and-jam -infer-address-spaces -libcalls-shrinkwrap -globalopt -globaldce -dce -consthoist -loop-unroll -loop-interchange -coro-split -coro-elide -globaldce -instcombine -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.0022123893805308,12.428935766220093,opt -aggressive-instcombine -strip-nondebug -loop-instsimplify -scalarizer -loop-unroll -adce -infer-address-spaces -prune-eh -deadargelim -scalarizer -lower-matrix-intrinsics -coro-elide -name-anon-globals -loop-versioning-licm -tailcallelim -loweratomic -tailcallelim -simplifycfg -loop-simplifycfg -insert-gcov-profiling -gvn-hoist -coro-split -guard-widening -slsr -loop-vectorize -scalarizer -reg2mem -functionattrs -insert-gcov-profiling -inferattrs -slp-vectorizer -early-cse-memssa -irce -memcpyopt -dce -libcalls-shrinkwrap -aggressive-instcombine -dse -ipconstprop -consthoist -loop-guard-widening -lcssa -loop-deletion -loop-sink -reg2mem -mergefunc -inject-tli-mappings -div-rem-pairs -sink -always-inline -called-value-propagation -sink -float2int -coro-elide -insert-gcov-profiling -attributor -sink -coro-split -gvn-hoist -mergereturn -argpromotion -argpromotion -lower-expect -partial-inliner -globalsplit -lower-expect -licm -loop-instsimplify -die -redundant-dbg-inst-elim -lower-constant-intrinsics -mem2reg -elim-avail-extern -inferattrs -lower-matrix-intrinsics -lower-matrix-intrinsics -guard-widening -mergereturn -loop-unroll -lower-widenable-condition -loop-predication -strip -loop-versioning-licm -partial-inliner -insert-gcov-profiling -inline -scalarizer -adce -div-rem-pairs -indvars -rewrite-statepoints-for-gc -constprop -loop-data-prefetch -memcpyopt -loop-vectorize -mldst-motion -loweratomic -adce -lower-constant-intrinsics -sroa -loop-simplifycfg -jump-threading -licm -mldst-motion -indvars -simple-loop-unswitch -rpo-functionattrs -slp-vectorizer -constmerge -consthoist -loop-idiom -loop-guard-widening -pgo-memop-opt -functionattrs -constmerge -aggressive-instcombine -ee-instrument -nary-reassociate -newgvn -gvn-hoist -loop-distribute -div-rem-pairs -pgo-memop-opt -die -redundant-dbg-inst-elim -functionattrs -cross-dso-cfi -canonicalize-aliases -constprop -elim-avail-extern -mergefunc -rewrite-statepoints-for-gc -instcombine -loop-simplify -mem2reg -loop-data-prefetch -instnamer -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.0088495575221237,12.064459800720215,opt -loop-distribute -aggressive-instcombine -float2int -float2int -add-discriminators -functionattrs -float2int -libcalls-shrinkwrap -lowerswitch -consthoist -simple-loop-unswitch -slp-vectorizer -functionattrs -slsr -loop-sink -nary-reassociate -die -loop-deletion -memcpyopt -loop-deletion -break-crit-edges -lowerinvoke -inject-tli-mappings -loop-deletion -loop-fusion -barrier -memcpyopt -newgvn -loop-instsimplify -flattencfg -sink -forceattrs -irce -rewrite-statepoints-for-gc -barrier -break-crit-edges -coro-elide -lower-matrix-intrinsics -libcalls-shrinkwrap -name-anon-globals -slsr -callsite-splitting -lower-guard-intrinsic -loop-fusion -insert-gcov-profiling -partial-inliner -consthoist -prune-eh -ee-instrument -constmerge -lowerswitch -inject-tli-mappings -sroa -gvn-hoist -mergeicmps -tailcallelim -loop-guard-widening -indvars -deadargelim -tailcallelim -loop-interchange -globalsplit -lowerswitch -loop-idiom -redundant-dbg-inst-elim -coro-cleanup -sancov -loop-unroll -lower-widenable-condition -add-discriminators -barrier -scalarizer -nary-reassociate -constmerge -jump-threading -post-inline-ee-instrument -inject-tli-mappings -instcombine -coro-elide -callsite-splitting -rpo-functionattrs -jump-threading -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.0088495575221237,12.131162881851196,opt -sancov -coro-split -loop-idiom -libcalls-shrinkwrap -loweratomic -lower-widenable-condition -globalopt -speculative-execution -flattencfg -strip-dead-prototypes -consthoist -newgvn -strip-nondebug -callsite-splitting -inject-tli-mappings -prune-eh -irce -loop-unswitch -loop-simplifycfg -simplifycfg -loop-fusion -rewrite-statepoints-for-gc -deadargelim -lowerswitch -nary-reassociate -globalsplit -loop-versioning-licm -die -licm -lowerinvoke -speculative-execution -loop-guard-widening -newgvn -strip-dead-prototypes -newgvn -strip-nondebug -dse -coro-early -loop-unroll-and-jam -licm -coro-split -loop-idiom -constmerge -adce -partial-inliner -float2int -speculative-execution -globalsplit -slsr -loop-unroll-and-jam -prune-eh -float2int -instcombine -loop-reduce -loop-simplify -loop-unroll -newgvn -loop-guard-widening -dse -sroa -loop-fusion -ipconstprop -scalarizer -indvars -loop-unroll-and-jam -inline -flattencfg -sink -coro-elide -speculative-execution -lower-guard-intrinsic -sancov -gvn-hoist -coro-split -loop-predication -barrier -dse -jump-threading -loop-reduce -separate-const-offset-from-gep -loop-versioning-licm -flattencfg -instsimplify -called-value-propagation -instnamer -strip-dead-prototypes -irce -canonicalize-aliases -lower-matrix-intrinsics -inject-tli-mappings -infer-address-spaces -name-anon-globals -simple-loop-unswitch -die -partial-inliner -newgvn -add-discriminators -aggressive-instcombine -sink -loop-versioning -loop-data-prefetch -coro-split -sroa -attributor -loop-simplify -loop-unroll -correlated-propagation -partially-inline-libcalls -barrier -globalsplit -called-value-propagation -inferattrs -inferattrs -argpromotion -slsr -prune-eh -guard-widening -loop-idiom -irce -tailcallelim -lower-widenable-condition -inject-tli-mappings -float2int -pgo-memop-opt -indvars -strip-nondebug -loop-interchange -flattencfg -redundant-dbg-inst-elim -elim-avail-extern -coro-early -constmerge -sroa -gvn-hoist -ipsccp -scalarizer -lcssa -constmerge -libcalls-shrinkwrap -globalsplit -loop-interchange -sroa -deadargelim -rewrite-statepoints-for-gc -loop-predication -libcalls-shrinkwrap -flattencfg -gvn-hoist -prune-eh -lower-matrix-intrinsics -inline -canonicalize-aliases -ee-instrument -loop-load-elim -attributor -globaldce -nary-reassociate -barrier -loop-simplify -newgvn -loop-instsimplify -memcpyopt -aggressive-instcombine -instcombine -functionattrs -separate-const-offset-from-gep -loop-deletion -barrier -newgvn -loop-unroll-and-jam -loop-predication -post-inline-ee-instrument -coro-split -slp-vectorizer -loop-versioning-licm -simple-loop-unswitch -rpo-functionattrs -inferattrs -div-rem-pairs -indvars -loop-versioning-licm -dse -sroa -sink -indvars -gvn-hoist -guard-widening -sink -loop-unroll-and-jam -coro-early -globalsplit -coro-cleanup -always-inline -simplifycfg -memcpyopt -newgvn input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.008849557522124,12.092485666275024,opt -loop-guard-widening -loop-sink -licm -attributor -canonicalize-aliases -rewrite-statepoints-for-gc -loop-vectorize -loweratomic -aggressive-instcombine -cross-dso-cfi -deadargelim -mergereturn -functionattrs -loop-reroll -loop-distribute -prune-eh -inferattrs -insert-gcov-profiling -loop-interchange -lower-widenable-condition -adce -instcombine -rpo-functionattrs -inline -mergeicmps -constmerge -nary-reassociate -instcombine -instnamer -loop-data-prefetch -constmerge -loop-versioning-licm -attributor -inline -newgvn -speculative-execution -strip-nondebug -early-cse-memssa -instsimplify -loop-versioning -loop-instsimplify -sroa -separate-const-offset-from-gep -functionattrs -lower-guard-intrinsic -post-inline-ee-instrument -functionattrs -instsimplify -mergeicmps -partial-inliner -constmerge -inject-tli-mappings -strip-debug-declare -barrier -forceattrs -prune-eh -loop-distribute -irce -strip-nondebug -reassociate -loweratomic -constmerge -redundant-dbg-inst-elim -elim-avail-extern -add-discriminators -bdce -ipsccp -ipsccp -break-crit-edges -lcssa -loop-simplifycfg -loop-deletion -lowerinvoke -lower-guard-intrinsic -reassociate -loop-sink -called-value-propagation -strip-debug-declare -break-crit-edges -scalarizer -flattencfg -deadargelim -div-rem-pairs -dse -instsimplify -functionattrs -instcombine -partial-inliner -name-anon-globals -libcalls-shrinkwrap -loop-deletion -rewrite-statepoints-for-gc -early-cse-memssa -tailcallelim -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.0088495575221241,12.038225173950195,opt -strip -correlated-propagation -sroa -loop-versioning -mem2reg -add-discriminators -loop-predication -bdce -memcpyopt -sancov -loop-reroll -instcombine -partially-inline-libcalls -speculative-execution -loop-unroll -coro-cleanup -loop-versioning-licm -lower-widenable-condition -consthoist -simplifycfg -canonicalize-aliases -coro-early -break-crit-edges -loop-unswitch -rewrite-statepoints-for-gc -loop-unswitch -newgvn -coro-early -partial-inliner -coro-elide -bdce -instsimplify -coro-split -strip -flattencfg -inline -loop-guard-widening -ipsccp -loop-simplifycfg -globaldce -lcssa -adce -lower-expect -loop-simplifycfg -coro-cleanup -coro-split -globalsplit -mergefunc -loop-versioning-licm -libcalls-shrinkwrap -globalopt -functionattrs -licm -instcombine -sroa -infer-address-spaces -consthoist -partially-inline-libcalls -loop-data-prefetch -constmerge -strip-nondebug -globalopt -sccp -loop-unroll -ipsccp -loop-instsimplify -libcalls-shrinkwrap -speculative-execution -correlated-propagation -dce -strip-dead-prototypes -gvn -speculative-execution -inline -infer-address-spaces -constprop -float2int -functionattrs -loop-deletion -sroa -deadargelim -instsimplify -mergefunc -bdce -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0249363867684482,12.77646517753601,opt -hotcoldsplit -lowerswitch -canonicalize-aliases -mem2reg -speculative-execution -lower-expect -redundant-dbg-inst-elim -inferattrs -loop-vectorize -speculative-execution -aggressive-instcombine -loop-vectorize -loweratomic -lower-widenable-condition -guard-widening -early-cse-memssa -speculative-execution -lowerswitch -pgo-memop-opt -strip-dead-prototypes -lowerinvoke -always-inline -aggressive-instcombine -loop-sink -reg2mem -sroa -dce -coro-split -post-inline-ee-instrument -simplifycfg -redundant-dbg-inst-elim -globalopt -globaldce -loop-idiom -slp-vectorizer -globalopt -argpromotion -loop-versioning -jump-threading -argpromotion -strip-dead-prototypes -insert-gcov-profiling -lower-expect -strip-nondebug -globalsplit -loweratomic -coro-early -sancov -separate-const-offset-from-gep -loop-fusion -add-discriminators -lcssa -licm -lower-constant-intrinsics -libcalls-shrinkwrap -instcombine -argpromotion -jump-threading -hotcoldsplit -float2int -libcalls-shrinkwrap -elim-avail-extern -sroa -callsite-splitting -called-value-propagation -barrier -speculative-execution -redundant-dbg-inst-elim -slp-vectorizer -memcpyopt -lower-guard-intrinsic -argpromotion -flattencfg -always-inline -indvars -dse -loop-interchange -memcpyopt -mergereturn -lower-widenable-condition -scalarizer -ipconstprop -loop-unroll -loop-guard-widening -loop-reduce -attributor -indvars -early-cse-memssa -tailcallelim -sink -irce -slp-vectorizer -dce -prune-eh -name-anon-globals -load-store-vectorizer -slsr -sccp -coro-split -loop-rotate -strip-debug-declare -post-inline-ee-instrument -ee-instrument -memcpyopt -aggressive-instcombine -globaldce -strip-dead-prototypes -libcalls-shrinkwrap -strip-nondebug -rewrite-statepoints-for-gc -early-cse-memssa -canonicalize-aliases -callsite-splitting -die -instnamer -hotcoldsplit -lower-matrix-intrinsics -cross-dso-cfi -coro-cleanup -loop-versioning -correlated-propagation -newgvn -coro-split -ipconstprop -sancov -lowerinvoke -partial-inliner -scalarizer -loop-reroll -slsr -gvn -instcombine -loop-deletion -bdce -slsr -loop-rotate -alignment-from-assumptions -lower-matrix-intrinsics -loop-predication -loop-instsimplify -infer-address-spaces -instnamer -always-inline -lower-constant-intrinsics -loop-unroll -early-cse-memssa -adce -loop-reroll -cross-dso-cfi -forceattrs -callsite-splitting -div-rem-pairs -speculative-execution -redundant-dbg-inst-elim -loop-versioning -loop-data-prefetch -lower-expect -slsr -correlated-propagation -name-anon-globals -partial-inliner -dse -ipsccp -constmerge -pgo-memop-opt -loop-reduce -gvn-hoist -speculative-execution -lowerswitch -ee-instrument -globalsplit -guard-widening -load-store-vectorizer -loop-idiom -licm -separate-const-offset-from-gep -mergeicmps -simple-loop-unswitch -loop-predication -mldst-motion -loweratomic -bdce -early-cse-memssa -inferattrs -mergeicmps -consthoist -mergefunc -ee-instrument -sccp -break-crit-edges -lower-constant-intrinsics -mldst-motion -called-value-propagation -loweratomic -ipconstprop -sccp -deadargelim -loop-data-prefetch -loop-sink -separate-const-offset-from-gep -guard-widening -loop-fusion -gvn -slp-vectorizer -called-value-propagation -scalarizer -attributor -pgo-memop-opt -loop-reduce -instnamer -break-crit-edges -pgo-memop-opt -mldst-motion -adce -memcpyopt -partially-inline-libcalls -loop-simplifycfg -reassociate -lower-matrix-intrinsics -sccp -loop-idiom -insert-gcov-profiling -div-rem-pairs -mergeicmps -licm -add-discriminators -licm -strip-nondebug -flattencfg -loop-vectorize -aggressive-instcombine -loop-versioning -partially-inline-libcalls -loop-versioning -flattencfg -simplifycfg -infer-address-spaces -break-crit-edges -ipconstprop -coro-cleanup -early-cse-memssa -loop-versioning -aggressive-instcombine -loop-vectorize -mergereturn -speculative-execution -slp-vectorizer -indvars -loop-reroll -infer-address-spaces -sancov -loop-load-elim -instcombine -inline -inline -float2int -loop-vectorize -aggressive-instcombine -speculative-execution -mergereturn -indvars -loop-simplify -strip-debug-declare -sccp -consthoist -loop-unroll -jump-threading -alignment-from-assumptions -loop-versioning-licm -pgo-memop-opt -loop-unswitch -loop-deletion -reassociate -loop-versioning -ee-instrument -functionattrs -mldst-motion -lower-widenable-condition -flattencfg -coro-cleanup -strip-nondebug -ipsccp -inject-tli-mappings -loop-fusion -name-anon-globals -barrier -scalarizer -slp-vectorizer -strip-nondebug -sink -loop-unswitch -forceattrs -coro-cleanup -aggressive-instcombine -sink -deadargelim -infer-address-spaces -loop-versioning -loop-deletion -called-value-propagation -lower-constant-intrinsics -constmerge -slp-vectorizer -coro-elide -strip-dead-prototypes -partial-inliner -redundant-dbg-inst-elim -ipconstprop -loop-instsimplify -simplifycfg -loop-predication -instcombine input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0300254452926212,13.093162536621094,opt -ipsccp -scalarizer -mem2reg -break-crit-edges -loop-guard-widening -separate-const-offset-from-gep -inject-tli-mappings -lowerinvoke -rewrite-statepoints-for-gc -separate-const-offset-from-gep -inline -attributor -ee-instrument -loop-interchange -loop-distribute -loop-unroll -correlated-propagation -sccp -coro-early -loop-predication -loop-deletion -dce -loop-instsimplify -loop-unroll-and-jam -mergefunc -coro-cleanup -lower-matrix-intrinsics -lowerinvoke -ipconstprop -gvn-hoist -lower-widenable-condition -loop-rotate -gvn-hoist -separate-const-offset-from-gep -sroa -lower-constant-intrinsics -strip-debug-declare -loop-sink -adce -loop-interchange -coro-cleanup -loop-unroll-and-jam -loop-guard-widening -loop-fusion -coro-elide -post-inline-ee-instrument -irce -mergereturn -instcombine -load-store-vectorizer -lowerswitch -correlated-propagation -memcpyopt -strip-nondebug -cross-dso-cfi -loop-fusion -argpromotion -irce -lowerinvoke -slsr -elim-avail-extern -speculative-execution -loop-fusion -separate-const-offset-from-gep -loop-versioning -inline -loop-fusion -coro-split -loop-instsimplify -loweratomic -licm -lower-widenable-condition -loop-rotate -elim-avail-extern -globalsplit -loop-vectorize -loop-deletion -lower-widenable-condition -newgvn -loop-reroll -loop-versioning -libcalls-shrinkwrap -loop-predication -reg2mem -loop-rotate -strip-debug-declare -insert-gcov-profiling -strip-debug-declare -div-rem-pairs -globaldce -loop-versioning-licm -reg2mem -strip -separate-const-offset-from-gep -loop-unswitch -nary-reassociate -irce -mldst-motion -rpo-functionattrs -constmerge -mergefunc -bdce -consthoist -strip-debug-declare -simplifycfg -mem2reg -alignment-from-assumptions -loop-instsimplify -jump-threading -correlated-propagation -strip-debug-declare -break-crit-edges -constmerge -lower-constant-intrinsics -prune-eh -indvars -loweratomic -separate-const-offset-from-gep -prune-eh -name-anon-globals -early-cse-memssa -indvars -forceattrs -loop-rotate -load-store-vectorizer -globaldce -sancov -partial-inliner -instcombine -elim-avail-extern -bdce -irce -lcssa -mldst-motion -instsimplify -loop-guard-widening -loop-rotate -jump-threading -break-crit-edges -always-inline -post-inline-ee-instrument -partially-inline-libcalls -barrier -insert-gcov-profiling -simple-loop-unswitch -deadargelim -strip -strip -gvn -ipsccp -lowerinvoke -partial-inliner -lower-constant-intrinsics -called-value-propagation -loop-idiom -coro-cleanup -slp-vectorizer -instcombine -prune-eh -dce -elim-avail-extern -constprop -loop-fusion -deadargelim -loop-instsimplify -instcombine -lower-guard-intrinsic -break-crit-edges -loweratomic -cross-dso-cfi -partial-inliner -loop-interchange -loop-guard-widening -indvars -irce -lower-matrix-intrinsics -gvn -loop-unroll-and-jam -load-store-vectorizer -mem2reg -globaldce -loop-versioning -strip-dead-prototypes -loop-sink -strip-dead-prototypes -reassociate -indvars -lower-guard-intrinsic -loop-interchange -gvn -callsite-splitting -loop-interchange -sccp -attributor -loop-predication -constprop -speculative-execution -loop-idiom -name-anon-globals -coro-elide -elim-avail-extern -pgo-memop-opt -simplifycfg -sink -globalopt -mem2reg -reg2mem -constprop -name-anon-globals -argpromotion -coro-cleanup -jump-threading -called-value-propagation -reg2mem -rewrite-statepoints-for-gc -loop-sink -globalsplit -mldst-motion -lower-constant-intrinsics -callsite-splitting -barrier -infer-address-spaces -lowerswitch -consthoist -ee-instrument -add-discriminators -forceattrs -hotcoldsplit -loop-unroll -mergefunc -attributor -lowerswitch -coro-early -reassociate -lower-widenable-condition -prune-eh -loop-predication -ee-instrument -deadargelim -loop-distribute -newgvn -name-anon-globals -canonicalize-aliases -memcpyopt -dse -sancov -flattencfg -loweratomic -coro-cleanup -strip-nondebug -inject-tli-mappings -prune-eh -gvn -speculative-execution -correlated-propagation -loop-unswitch -strip -sroa -lowerinvoke -redundant-dbg-inst-elim -mem2reg -mergereturn -barrier -tailcallelim -loop-sink -pgo-memop-opt -lcssa -instsimplify -functionattrs -licm -strip -strip-dead-prototypes -lower-matrix-intrinsics -loop-sink -guard-widening -loop-versioning-licm -lower-constant-intrinsics -functionattrs -indvars -loop-unroll-and-jam -elim-avail-extern -loop-sink -globaldce -licm -pgo-memop-opt -instcombine -lower-guard-intrinsic -mldst-motion -jump-threading -callsite-splitting -coro-split -mergeicmps -insert-gcov-profiling -coro-cleanup -sccp -add-discriminators -early-cse-memssa -licm -div-rem-pairs -globaldce -functionattrs -loop-vectorize -div-rem-pairs -loop-predication -inferattrs -alignment-from-assumptions -dce -inject-tli-mappings -memcpyopt -lower-matrix-intrinsics -loop-predication -licm -newgvn -tailcallelim -adce -memcpyopt -early-cse-memssa -coro-elide -dce -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.033587786259542,12.856059074401855,opt -lower-matrix-intrinsics -lower-matrix-intrinsics -sink -dse -loop-interchange -scalarizer -cross-dso-cfi -instnamer -loop-fusion -lower-expect -break-crit-edges -infer-address-spaces -post-inline-ee-instrument -sancov -barrier -coro-split -ipsccp -loop-load-elim -lower-widenable-condition -strip-debug-declare -forceattrs -add-discriminators -loop-fusion -strip-debug-declare -lower-constant-intrinsics -load-store-vectorizer -deadargelim -loop-unroll-and-jam -loop-data-prefetch -gvn-hoist -deadargelim -sink -loop-load-elim -lower-widenable-condition -adce -slp-vectorizer -callsite-splitting -lower-expect -reassociate -instnamer -elim-avail-extern -strip-nondebug -lower-constant-intrinsics -lowerswitch -strip-debug-declare -irce -gvn-hoist -loop-simplify -loop-interchange -separate-const-offset-from-gep -loop-simplify -break-crit-edges -loop-data-prefetch -dce -mergefunc -redundant-dbg-inst-elim -instsimplify -deadargelim -mldst-motion -loop-guard-widening -loop-unroll -correlated-propagation -hotcoldsplit -gvn-hoist -mergefunc -loop-interchange -ee-instrument -correlated-propagation -alignment-from-assumptions -coro-early -loop-simplify -mldst-motion -loop-distribute -guard-widening -post-inline-ee-instrument -loop-reroll -dce -sroa -globalsplit -canonicalize-aliases -lower-widenable-condition -loop-load-elim -add-discriminators -coro-early -loop-vectorize -mergefunc -simple-loop-unswitch -alignment-from-assumptions -strip -constprop -div-rem-pairs -libcalls-shrinkwrap -simple-loop-unswitch -loop-idiom -gvn-hoist -newgvn -post-inline-ee-instrument -strip-dead-prototypes -instcombine -dse -partial-inliner -lower-widenable-condition -sccp -adce -speculative-execution -simplifycfg -slp-vectorizer -newgvn -mldst-motion -memcpyopt -slsr -load-store-vectorizer -mergeicmps -argpromotion -rpo-functionattrs -correlated-propagation -strip-dead-prototypes -memcpyopt -loop-predication -alignment-from-assumptions -adce -deadargelim -partially-inline-libcalls -tailcallelim -elim-avail-extern -lower-expect -globaldce -nary-reassociate -irce -loop-reroll -loop-distribute -loop-instsimplify -loop-reroll -lower-matrix-intrinsics -loop-data-prefetch -tailcallelim -loop-reduce -name-anon-globals -canonicalize-aliases -instnamer -memcpyopt -lower-guard-intrinsic -cross-dso-cfi -simple-loop-unswitch -memcpyopt -pgo-memop-opt -break-crit-edges -strip-debug-declare -lower-constant-intrinsics -flattencfg -loop-simplifycfg -globaldce -sink -loop-vectorize -reassociate -loop-instsimplify -callsite-splitting -globalsplit -lowerswitch -insert-gcov-profiling -slp-vectorizer -flattencfg -partial-inliner -ipsccp -elim-avail-extern -mergereturn -rewrite-statepoints-for-gc -loop-unroll-and-jam -loop-unswitch -strip-debug-declare -mergefunc -constmerge -redundant-dbg-inst-elim -barrier -alignment-from-assumptions -flattencfg -ee-instrument -nary-reassociate -loop-predication -bdce -slsr -elim-avail-extern -inject-tli-mappings -coro-elide -licm -infer-address-spaces -die -sccp -partially-inline-libcalls -loop-distribute -callsite-splitting -float2int -lower-widenable-condition -instsimplify -instcombine -ipconstprop -constprop -prune-eh -loop-guard-widening -ipconstprop -correlated-propagation -mergeicmps -loop-unswitch -ipconstprop -separate-const-offset-from-gep -separate-const-offset-from-gep -instnamer -die -inline -sancov -loop-interchange -canonicalize-aliases -sroa -loop-fusion -lowerinvoke -strip-dead-prototypes -loop-instsimplify -instnamer -lower-constant-intrinsics -gvn input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.033587786259542,13.356575012207031,opt -globaldce -infer-address-spaces -always-inline -loop-fusion -constprop -bdce -globaldce -sink -loweratomic -memcpyopt -loop-sink -lower-expect -newgvn -pgo-memop-opt -callsite-splitting -strip-debug-declare -jump-threading -loop-unswitch -loop-simplify -loop-simplify -inferattrs -loop-unswitch -separate-const-offset-from-gep -loop-predication -instnamer -alignment-from-assumptions -load-store-vectorizer -loop-data-prefetch -simple-loop-unswitch -elim-avail-extern -loop-unswitch -globalsplit -mem2reg -globalopt -reassociate -consthoist -gvn -sink -post-inline-ee-instrument -instcombine -dse -simplifycfg -flattencfg -load-store-vectorizer -load-store-vectorizer -float2int -loop-load-elim -tailcallelim -elim-avail-extern -coro-split -globaldce -licm -coro-split -strip-debug-declare -ee-instrument -prune-eh -loop-reroll -pgo-memop-opt -lowerinvoke -adce -loop-vectorize -scalarizer -sccp -loop-versioning-licm -always-inline -guard-widening -dse -deadargelim -libcalls-shrinkwrap -called-value-propagation -coro-elide -dce -lower-widenable-condition -loop-vectorize -correlated-propagation -loop-unroll -coro-elide -loop-instsimplify -coro-split -simple-loop-unswitch -loop-unroll -loop-simplifycfg -loop-deletion -lower-guard-intrinsic -globalopt -argpromotion -loop-simplifycfg -simplifycfg -argpromotion -mem2reg -gvn-hoist -lower-guard-intrinsic -guard-widening -separate-const-offset-from-gep -simple-loop-unswitch -hotcoldsplit -sink -newgvn -globalsplit -loop-guard-widening -correlated-propagation -slsr -prune-eh -inject-tli-mappings -break-crit-edges -coro-cleanup -licm -strip-dead-prototypes -loop-deletion -rpo-functionattrs -rpo-functionattrs -loop-interchange -licm -gvn -slsr -instnamer -instcombine -attributor -constprop -memcpyopt -coro-cleanup -cross-dso-cfi -mergeicmps -instnamer -always-inline -lcssa -separate-const-offset-from-gep -loop-simplify -argpromotion -licm -simple-loop-unswitch -argpromotion -loop-versioning -loop-distribute -globalsplit -sccp -lcssa -partial-inliner -redundant-dbg-inst-elim -loop-simplify -strip-dead-prototypes -memcpyopt -strip-dead-prototypes -slp-vectorizer -adce -loop-unroll-and-jam -instsimplify -mergereturn -loop-reroll -instcombine -coro-early -loop-reroll -memcpyopt -correlated-propagation -inline -slp-vectorizer -simple-loop-unswitch -coro-cleanup -strip-nondebug -slsr -nary-reassociate -loop-versioning -lower-widenable-condition -float2int -loop-predication -loop-versioning -strip -loweratomic -consthoist -separate-const-offset-from-gep -mergefunc -loop-versioning-licm -instsimplify -loop-unroll-and-jam -cross-dso-cfi -prune-eh -simple-loop-unswitch -loop-data-prefetch -elim-avail-extern -indvars -pgo-memop-opt -forceattrs -mem2reg -constmerge -dce -bdce -loop-distribute -loop-idiom -post-inline-ee-instrument -argpromotion -loop-vectorize -indvars -globaldce -instcombine input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0346055979643767,12.67380666732788,opt -constmerge -partially-inline-libcalls -correlated-propagation -coro-elide -lowerswitch -coro-split -functionattrs -add-discriminators -sroa -instcombine -slp-vectorizer -loop-versioning-licm -loop-distribute -name-anon-globals -loop-predication -cross-dso-cfi -lower-expect -float2int -lcssa -lowerswitch -forceattrs -reg2mem -hotcoldsplit -correlated-propagation -strip-dead-prototypes -globalsplit -coro-split -loop-reroll -alignment-from-assumptions -loop-sink -reg2mem -early-cse-memssa -lower-expect -loop-versioning -gvn-hoist -newgvn -loweratomic -alignment-from-assumptions -loop-vectorize -coro-split -loop-sink -instnamer -loop-unroll -tailcallelim -pgo-memop-opt -functionattrs -ipconstprop -sink -pgo-memop-opt -dce -hotcoldsplit -globalopt -attributor -strip -loop-reroll -cross-dso-cfi -aggressive-instcombine -strip-dead-prototypes -rpo-functionattrs -loop-sink -break-crit-edges -canonicalize-aliases -loop-unroll-and-jam -globaldce -hotcoldsplit -bdce -aggressive-instcombine -mergefunc -consthoist -always-inline -insert-gcov-profiling -correlated-propagation -div-rem-pairs -strip -prune-eh -mergeicmps -loop-interchange -globaldce -prune-eh -loop-vectorize -jump-threading -instnamer -insert-gcov-profiling -reg2mem -simple-loop-unswitch -nary-reassociate -forceattrs -loop-unroll-and-jam -globalopt -globalsplit -lowerinvoke -loop-load-elim -lower-widenable-condition -loop-guard-widening -simplifycfg -coro-elide -deadargelim -jump-threading -libcalls-shrinkwrap -loop-predication -loop-load-elim -attributor -called-value-propagation -instcombine -scalarizer -newgvn -globalsplit -insert-gcov-profiling -strip-nondebug -loop-interchange -pgo-memop-opt -libcalls-shrinkwrap -loop-guard-widening -break-crit-edges -loweratomic -newgvn -loop-instsimplify -loop-unswitch -sccp -always-inline -elim-avail-extern -lower-guard-intrinsic -rewrite-statepoints-for-gc -slp-vectorizer -mem2reg -forceattrs -sroa -functionattrs -loop-simplifycfg -coro-elide -globalsplit -elim-avail-extern -guard-widening -loop-idiom -irce -add-discriminators -separate-const-offset-from-gep -libcalls-shrinkwrap -mem2reg -add-discriminators -callsite-splitting -name-anon-globals -called-value-propagation -infer-address-spaces -loop-unroll -dce -mergefunc -flattencfg -deadargelim -sroa -lower-constant-intrinsics -loop-predication -rpo-functionattrs -tailcallelim -loop-data-prefetch -elim-avail-extern -load-store-vectorizer -mergeicmps -prune-eh -bdce -dce -globalopt -strip-debug-declare -strip-nondebug -slsr -loop-interchange -loop-reduce -lowerswitch -elim-avail-extern -globalopt -callsite-splitting -newgvn -lower-expect -ee-instrument -sancov -lowerswitch -licm -add-discriminators -gvn -early-cse-memssa -correlated-propagation -add-discriminators -memcpyopt -adce -mergereturn -strip-nondebug -callsite-splitting -break-crit-edges -loop-distribute -loop-simplifycfg -strip-nondebug -lcssa -mem2reg -attributor -dse -strip-debug-declare -strip -dce -loop-reduce -post-inline-ee-instrument -loop-distribute -loop-idiom -loop-unroll-and-jam -canonicalize-aliases -licm -deadargelim -loop-load-elim -speculative-execution -loop-unswitch -redundant-dbg-inst-elim -rpo-functionattrs -separate-const-offset-from-gep -flattencfg -die -lower-guard-intrinsic -loop-unroll-and-jam -lowerswitch -globalopt -coro-split -loop-reduce -loop-deletion -coro-split -mem2reg -adce -nary-reassociate -early-cse-memssa -float2int -newgvn -functionattrs -indvars -forceattrs -canonicalize-aliases -early-cse-memssa -slp-vectorizer -irce -loop-unroll -sccp -sink -globalsplit -strip-debug-declare -lower-expect -sancov -sancov -gvn-hoist -loop-reduce -barrier -newgvn -lowerswitch -ee-instrument -lower-constant-intrinsics -early-cse-memssa -loop-fusion -coro-elide -licm -callsite-splitting -dse -instnamer -aggressive-instcombine -newgvn -flattencfg -loop-deletion -strip-nondebug -load-store-vectorizer -speculative-execution -lower-constant-intrinsics -coro-elide -loop-simplifycfg -indvars -early-cse-memssa -strip-nondebug -loop-idiom -dce -hotcoldsplit -lower-guard-intrinsic -partially-inline-libcalls -alignment-from-assumptions -tailcallelim -hotcoldsplit -loop-simplifycfg -globalopt -constprop -ee-instrument -lcssa -functionattrs -loop-sink -loop-reduce -loop-vectorize -argpromotion -flattencfg -sroa -deadargelim -mem2reg -sccp -always-inline -lower-expect -ipconstprop -reassociate -slp-vectorizer -lowerinvoke -loop-vectorize -inject-tli-mappings -insert-gcov-profiling -correlated-propagation -loop-vectorize -ipconstprop -name-anon-globals -instcombine -loop-versioning-licm -rewrite-statepoints-for-gc -bdce -name-anon-globals -consthoist -float2int -infer-address-spaces -prune-eh -div-rem-pairs -simple-loop-unswitch -consthoist -lower-expect -mldst-motion -loop-simplifycfg -ee-instrument -loop-interchange -constmerge -consthoist -loop-unroll-and-jam -loop-distribute -jump-threading -loop-data-prefetch -mem2reg -instnamer -constprop -sink -loop-distribute -slsr -post-inline-ee-instrument -loop-vectorize -gvn-hoist -mldst-motion -constmerge -loop-reroll -indvars -forceattrs -die -insert-gcov-profiling -argpromotion -correlated-propagation -pgo-memop-opt -instcombine -licm -reassociate -coro-early -name-anon-globals -lower-widenable-condition -dce -loop-instsimplify -lower-constant-intrinsics -elim-avail-extern -loop-guard-widening -loop-simplifycfg -partial-inliner -gvn -irce -post-inline-ee-instrument -adce -constprop -callsite-splitting -loop-fusion -attributor -inferattrs -strip-dead-prototypes -inline -aggressive-instcombine -gvn-hoist -mergefunc -speculative-execution -die -forceattrs -insert-gcov-profiling -callsite-splitting -slsr -loop-simplify -loop-versioning-licm -add-discriminators -rpo-functionattrs -sccp -die -loop-interchange -strip -globaldce -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0417302798982189,12.396470785140991,opt -prune-eh -loop-idiom -nary-reassociate -post-inline-ee-instrument -loop-unswitch -slsr -reassociate -separate-const-offset-from-gep -loop-fusion -loop-deletion -coro-elide -slsr -forceattrs -mergeicmps -globaldce -elim-avail-extern -pgo-memop-opt -loop-predication -canonicalize-aliases -instsimplify -loop-fusion -simplifycfg -simple-loop-unswitch -attributor -canonicalize-aliases -loop-predication -licm -hotcoldsplit -ipsccp -indvars -partial-inliner -tailcallelim -coro-cleanup -lcssa -strip-dead-prototypes -sancov -scalarizer -float2int -loop-unswitch -strip-dead-prototypes -loop-versioning -strip-dead-prototypes -globaldce -callsite-splitting -gvn -mem2reg -instcombine -memcpyopt -functionattrs -add-discriminators -slsr -deadargelim -mergereturn -lcssa -loop-distribute -guard-widening -lower-expect -loop-idiom -licm -coro-split -strip-nondebug -rpo-functionattrs -loop-predication -hotcoldsplit -reassociate -lower-matrix-intrinsics -coro-cleanup -rewrite-statepoints-for-gc -lcssa -lowerswitch -lcssa -mem2reg -loop-simplify -strip-dead-prototypes -loop-vectorize -coro-early -loop-predication -attributor -reassociate -forceattrs -sccp -newgvn -add-discriminators -mldst-motion -loop-deletion -sink -loop-predication -newgvn -loop-data-prefetch -mergeicmps -loop-unroll -globalsplit -adce -argpromotion -rewrite-statepoints-for-gc -loop-simplifycfg -partial-inliner -loop-guard-widening -loop-load-elim -sroa -simplifycfg -consthoist -separate-const-offset-from-gep -globaldce -bdce -loop-instsimplify -canonicalize-aliases -barrier -ipconstprop -rpo-functionattrs -rpo-functionattrs -deadargelim -bdce -loweratomic -ipsccp -coro-early -loop-simplifycfg -load-store-vectorizer -argpromotion -gvn-hoist -indvars -globalsplit -gvn -coro-split -lowerinvoke -reassociate -rewrite-statepoints-for-gc -sccp -coro-early -bdce -strip-nondebug -infer-address-spaces -dse -simple-loop-unswitch -callsite-splitting -irce -mergefunc -sccp -infer-address-spaces -slp-vectorizer -argpromotion -called-value-propagation -deadargelim -flattencfg -hotcoldsplit -loop-distribute -partial-inliner -strip -instcombine input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.043765903307888,12.748835325241089,opt -rpo-functionattrs -constmerge -functionattrs -scalarizer -canonicalize-aliases -jump-threading -loop-simplify -lower-constant-intrinsics -loop-interchange -aggressive-instcombine -loop-versioning -float2int -newgvn -loop-simplify -partially-inline-libcalls -loop-distribute -irce -lower-widenable-condition -instcombine -licm -sccp -coro-cleanup -dse -partially-inline-libcalls -lower-guard-intrinsic -lower-matrix-intrinsics -gvn -alignment-from-assumptions -guard-widening -rewrite-statepoints-for-gc -consthoist -dce -rewrite-statepoints-for-gc -mldst-motion -loop-guard-widening -instsimplify -attributor -mergereturn -strip-debug-declare -ipconstprop -instnamer -alignment-from-assumptions -loop-unroll-and-jam -prune-eh -dse -loop-idiom -loop-unroll -add-discriminators -strip-debug-declare -globaldce -loop-versioning -name-anon-globals -argpromotion -gvn -constprop -attributor -rewrite-statepoints-for-gc -lcssa -mergefunc -ipsccp -loop-idiom -loop-fusion -loop-versioning -called-value-propagation -flattencfg -guard-widening -inline -functionattrs -barrier -insert-gcov-profiling -partially-inline-libcalls -name-anon-globals -loop-versioning -infer-address-spaces -strip -bdce -add-discriminators -name-anon-globals -constmerge -barrier -mem2reg -loop-simplifycfg -redundant-dbg-inst-elim -coro-split -loop-guard-widening -strip-dead-prototypes -slsr -mem2reg -alignment-from-assumptions -partial-inliner -irce -memcpyopt -strip-nondebug -early-cse-memssa -coro-cleanup -loop-sink -separate-const-offset-from-gep -inject-tli-mappings -early-cse-memssa -tailcallelim -loop-unroll -licm -loop-vectorize -prune-eh -partially-inline-libcalls -newgvn -loop-reroll -break-crit-edges -post-inline-ee-instrument -rewrite-statepoints-for-gc -rpo-functionattrs -libcalls-shrinkwrap -ipsccp -nary-reassociate -load-store-vectorizer -mldst-motion -post-inline-ee-instrument -always-inline -rpo-functionattrs -flattencfg -coro-cleanup -simple-loop-unswitch -aggressive-instcombine -simple-loop-unswitch -coro-early -ipsccp -loop-guard-widening -adce -div-rem-pairs -instcombine -lower-widenable-condition -sancov -dse -loop-simplifycfg -loop-predication -memcpyopt -dce -dse -infer-address-spaces -loop-rotate -callsite-splitting -break-crit-edges -dce -partially-inline-libcalls -bdce -ipsccp -redundant-dbg-inst-elim -loop-idiom -slp-vectorizer -mergereturn -reassociate -loop-deletion -loop-fusion -jump-threading -gvn-hoist -simplifycfg -simple-loop-unswitch -loop-versioning-licm -always-inline -irce -instcombine input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0478371501272268,12.708849906921387,opt -sink -loop-vectorize -consthoist -coro-cleanup -coro-early -scalarizer -sroa -guard-widening -consthoist -correlated-propagation -loop-guard-widening -loop-idiom -instcombine -newgvn -instnamer -lcssa -strip-dead-prototypes -canonicalize-aliases -lowerinvoke -reassociate -redundant-dbg-inst-elim -ipsccp -pgo-memop-opt -add-discriminators -loop-unroll -canonicalize-aliases -indvars -coro-early -forceattrs -loop-guard-widening -loop-guard-widening -lowerswitch -ipconstprop -loop-versioning-licm -lcssa -rewrite-statepoints-for-gc -indvars -indvars -coro-cleanup -partially-inline-libcalls -loop-deletion -mem2reg -elim-avail-extern -lcssa -memcpyopt -irce -early-cse-memssa -coro-early -loop-unroll -loop-guard-widening -name-anon-globals -separate-const-offset-from-gep -loop-predication -canonicalize-aliases -ipsccp -prune-eh -consthoist -adce -called-value-propagation -loop-sink -loop-deletion -jump-threading -loop-instsimplify -adce -loop-unroll -hotcoldsplit -libcalls-shrinkwrap -consthoist -partially-inline-libcalls -infer-address-spaces -slp-vectorizer -rpo-functionattrs -sink -instcombine -dse -constprop -argpromotion -infer-address-spaces -tailcallelim -newgvn -flattencfg -mergereturn -memcpyopt -loop-unroll-and-jam -coro-cleanup -reassociate -div-rem-pairs -ee-instrument -dse -simple-loop-unswitch -strip-dead-prototypes -memcpyopt -libcalls-shrinkwrap -correlated-propagation -loop-data-prefetch -strip -simple-loop-unswitch -partial-inliner -mergefunc -loop-unroll -lowerswitch -sink -lower-matrix-intrinsics -loop-deletion -inferattrs -constprop -loop-data-prefetch -mem2reg -strip-debug-declare -attributor -lower-expect -gvn-hoist -nary-reassociate -partially-inline-libcalls -globalsplit -pgo-memop-opt -lower-widenable-condition -sancov -early-cse-memssa -consthoist -inferattrs -consthoist -reg2mem -partial-inliner -name-anon-globals -loop-vectorize -strip-debug-declare -constmerge -loop-guard-widening -div-rem-pairs -scalarizer -pgo-memop-opt -ipsccp -sccp -rpo-functionattrs -instsimplify -constmerge -loop-load-elim -coro-cleanup -lower-constant-intrinsics -mem2reg -always-inline -tailcallelim -gvn-hoist -dse -attributor -lower-expect -lowerinvoke -bdce -newgvn -mem2reg -instcombine -globalopt -elim-avail-extern -rpo-functionattrs -slsr -slsr -loweratomic -always-inline -libcalls-shrinkwrap -sancov -deadargelim -mergefunc -globaldce -loop-data-prefetch -dse -separate-const-offset-from-gep -globalsplit -globalsplit -tailcallelim -newgvn -ee-instrument -sccp -loop-versioning-licm -loop-simplify -reassociate -loop-simplifycfg -globalsplit -reassociate -post-inline-ee-instrument -ee-instrument -loop-instsimplify -break-crit-edges -constmerge -gvn-hoist -newgvn -attributor -globaldce -separate-const-offset-from-gep -mergereturn -simplifycfg -instsimplify -load-store-vectorizer -loop-instsimplify -inferattrs -irce -loweratomic -gvn -adce -loop-interchange -consthoist -argpromotion -irce -loop-versioning -reg2mem -loop-simplifycfg -strip-nondebug -strip-dead-prototypes -loop-deletion -loop-simplifycfg -inferattrs -inferattrs -strip-debug-declare -coro-elide -loop-load-elim -adce -flattencfg -inject-tli-mappings -reassociate -mergeicmps -sccp -loop-versioning-licm -name-anon-globals -rewrite-statepoints-for-gc -licm -sccp -loop-guard-widening -loop-unroll -speculative-execution -lowerinvoke -loop-deletion -mergereturn -correlated-propagation -indvars -insert-gcov-profiling -nary-reassociate -coro-early -dce -loop-reduce -functionattrs -mergereturn -simplifycfg -ee-instrument -loop-unswitch -loop-distribute -speculative-execution -loop-instsimplify -gvn-hoist -reassociate -loop-reduce -loop-unroll -loop-data-prefetch -deadargelim -coro-split -mergefunc -sroa -loop-unroll -functionattrs -lowerswitch -lcssa -canonicalize-aliases -redundant-dbg-inst-elim -correlated-propagation -loop-data-prefetch -irce -slp-vectorizer -loop-data-prefetch -coro-split -loop-simplify -loop-distribute -indvars -div-rem-pairs -indvars -loop-guard-widening -instcombine -mergeicmps -loop-unswitch -attributor -sroa -loop-data-prefetch -gvn input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0498727735368956,12.672531366348267,opt -alignment-from-assumptions -loop-vectorize -attributor -speculative-execution -loop-guard-widening -called-value-propagation -consthoist -aggressive-instcombine -break-crit-edges -constprop -inferattrs -loop-versioning-licm -instnamer -rpo-functionattrs -break-crit-edges -strip -load-store-vectorizer -name-anon-globals -globalopt -post-inline-ee-instrument -correlated-propagation -insert-gcov-profiling -partial-inliner -loop-idiom -globaldce -memcpyopt -tailcallelim -globaldce -insert-gcov-profiling -sink -coro-cleanup -irce -loop-deletion -slp-vectorizer -loop-deletion -lowerswitch -flattencfg -partially-inline-libcalls -cross-dso-cfi -lower-expect -always-inline -loop-guard-widening -cross-dso-cfi -rewrite-statepoints-for-gc -indvars -aggressive-instcombine -strip-dead-prototypes -loop-reduce -newgvn -sroa -scalarizer -loop-instsimplify -argpromotion -instcombine -constprop -rewrite-statepoints-for-gc -coro-split -hotcoldsplit -callsite-splitting -globaldce -correlated-propagation -sancov -jump-threading -forceattrs -scalarizer -globalopt -called-value-propagation -functionattrs -instnamer -ee-instrument -constmerge -attributor -memcpyopt -coro-split -loop-versioning-licm -lowerinvoke -loop-versioning -partially-inline-libcalls -guard-widening -loop-unroll-and-jam -lower-expect -slp-vectorizer -barrier -loop-versioning-licm -simple-loop-unswitch -tailcallelim -strip-debug-declare -callsite-splitting -rewrite-statepoints-for-gc -gvn-hoist -ee-instrument -dse -cross-dso-cfi -lower-constant-intrinsics -alignment-from-assumptions -constmerge -loop-distribute -scalarizer -inferattrs -sccp -add-discriminators -break-crit-edges -dse -correlated-propagation -instcombine -loop-versioning -sroa -tailcallelim -gvn-hoist -gvn -float2int -simplifycfg -float2int -loop-versioning -constprop -div-rem-pairs -inline -slsr -loop-guard-widening -loop-unroll -loop-distribute -gvn-hoist -bdce -insert-gcov-profiling -coro-cleanup -slp-vectorizer -reassociate -simplifycfg -add-discriminators -coro-elide -loop-versioning -barrier -prune-eh -loop-unroll -inline -called-value-propagation -strip-dead-prototypes -reg2mem -sink -bdce -add-discriminators -partial-inliner -gvn -lower-constant-intrinsics -scalarizer -mem2reg -indvars -scalarizer -loop-load-elim -loop-idiom -instsimplify -correlated-propagation -lcssa -redundant-dbg-inst-elim -loop-instsimplify -early-cse-memssa -called-value-propagation -partially-inline-libcalls -redundant-dbg-inst-elim -infer-address-spaces -loop-unroll-and-jam -loop-versioning -loop-simplifycfg -dce -inject-tli-mappings -globalsplit -rpo-functionattrs -loop-unroll -loop-unroll -infer-address-spaces -dce -instnamer -load-store-vectorizer -constmerge -sccp -hotcoldsplit -lower-matrix-intrinsics -tailcallelim -functionattrs -sink -sroa -loop-idiom -mergefunc -adce -lower-widenable-condition -licm -dce -gvn -always-inline -canonicalize-aliases -memcpyopt -ipsccp -loop-sink -coro-split -loop-unroll-and-jam -jump-threading -slp-vectorizer -loop-idiom -gvn -canonicalize-aliases -argpromotion -deadargelim -hotcoldsplit -coro-split -constprop -newgvn -loop-sink -deadargelim -loop-interchange -loop-distribute -guard-widening -coro-split -barrier -mem2reg -mergefunc -adce -memcpyopt -barrier -adce -loop-versioning-licm -strip-nondebug -sink -prune-eh -instcombine input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0519083969465652,12.692818880081177,opt -gvn-hoist -elim-avail-extern -loop-reduce -sink -coro-early -callsite-splitting -instnamer -called-value-propagation -lower-matrix-intrinsics -loop-distribute -instnamer -cross-dso-cfi -nary-reassociate -globalopt -argpromotion -lower-matrix-intrinsics -redundant-dbg-inst-elim -gvn -lowerswitch -gvn-hoist -mergefunc -coro-elide -lower-constant-intrinsics -aggressive-instcombine -correlated-propagation -lower-matrix-intrinsics -slp-vectorizer -loop-data-prefetch -ipsccp -indvars -mergefunc -prune-eh -lower-guard-intrinsic -bdce -coro-early -loop-simplify -reg2mem -irce -cross-dso-cfi -loop-instsimplify -sroa -loop-deletion -simple-loop-unswitch -functionattrs -sccp -strip-dead-prototypes -dce -callsite-splitting -globalsplit -hotcoldsplit -forceattrs -separate-const-offset-from-gep -correlated-propagation -aggressive-instcombine -loop-simplify -lower-matrix-intrinsics -early-cse-memssa -mem2reg -sink -licm -barrier -cross-dso-cfi -mergeicmps -elim-avail-extern -rpo-functionattrs -consthoist -lcssa -lowerinvoke -aggressive-instcombine -reg2mem -reg2mem -sink -partially-inline-libcalls -simplifycfg -memcpyopt -elim-avail-extern -break-crit-edges -loop-simplify -callsite-splitting -name-anon-globals -loweratomic -indvars -early-cse-memssa -loop-unroll -partial-inliner -cross-dso-cfi -lower-matrix-intrinsics -early-cse-memssa -div-rem-pairs -elim-avail-extern -separate-const-offset-from-gep -speculative-execution -callsite-splitting -instnamer -globaldce -loop-rotate -lowerinvoke -consthoist -loop-idiom -loop-simplify -libcalls-shrinkwrap -irce -loop-distribute -lower-expect -mergefunc -slsr -barrier -nary-reassociate -dce -lower-guard-intrinsic -lower-guard-intrinsic -irce -strip -coro-elide -loop-data-prefetch -mergefunc -mergefunc -mergeicmps -lcssa -canonicalize-aliases -loop-simplify -jump-threading -float2int -loop-vectorize -loop-sink -prune-eh -div-rem-pairs -instsimplify -loop-vectorize -irce -float2int -coro-elide -barrier -early-cse-memssa -early-cse-memssa -argpromotion -inline -prune-eh -slp-vectorizer -mem2reg -guard-widening -adce -inferattrs -simplifycfg -loweratomic -instcombine -simple-loop-unswitch -indvars -loweratomic -lower-widenable-condition -aggressive-instcombine -dse -irce -lowerswitch -alignment-from-assumptions -loop-predication -strip-dead-prototypes -inline -flattencfg -die -lowerinvoke -irce -loop-data-prefetch -add-discriminators -ipsccp -div-rem-pairs -loop-reroll -reg2mem -loop-distribute -lower-constant-intrinsics -adce -mem2reg -libcalls-shrinkwrap -lowerswitch -insert-gcov-profiling -instcombine -rewrite-statepoints-for-gc -speculative-execution -coro-elide -scalarizer -rpo-functionattrs -ipconstprop -nary-reassociate -ee-instrument -ipconstprop -partial-inliner -loop-deletion -lcssa -mem2reg -strip -coro-elide -loop-idiom -mergeicmps -globalsplit -mergereturn -reassociate -bdce -canonicalize-aliases -cross-dso-cfi -deadargelim -constmerge -mergereturn -lcssa -loop-predication -aggressive-instcombine -loop-guard-widening -functionattrs -early-cse-memssa -loop-instsimplify -instnamer -load-store-vectorizer -adce -lower-constant-intrinsics -partial-inliner -strip-nondebug -loop-fusion -flattencfg -ipconstprop -coro-elide -forceattrs -loop-idiom -globalsplit -constprop -deadargelim -scalarizer -memcpyopt -globalsplit -div-rem-pairs -tailcallelim -alignment-from-assumptions -newgvn -mergeicmps -instsimplify -lower-matrix-intrinsics -loop-reduce -loop-deletion -post-inline-ee-instrument -coro-split -tailcallelim -canonicalize-aliases -break-crit-edges -canonicalize-aliases -indvars -die -loop-deletion -argpromotion -partially-inline-libcalls -loop-fusion -mergefunc -lower-guard-intrinsic -ipsccp -loop-reroll -div-rem-pairs -barrier -jump-threading -coro-elide -ee-instrument -lcssa -loweratomic -gvn -argpromotion -loop-predication -dce -instsimplify -loop-guard-widening -loop-deletion -argpromotion -constprop -instcombine -sancov -sink -hotcoldsplit -inject-tli-mappings -redundant-dbg-inst-elim -strip-nondebug -loop-versioning-licm -instsimplify -dce -partial-inliner -ipsccp -speculative-execution -sroa -infer-address-spaces -alignment-from-assumptions -lcssa -lcssa -scalarizer -ee-instrument -globalopt -lower-matrix-intrinsics -gvn-hoist -mergeicmps -infer-address-spaces -instcombine -globalopt -coro-early -float2int -mem2reg -sancov -sink -inject-tli-mappings -loweratomic -lower-widenable-condition -always-inline -simplifycfg -reg2mem -argpromotion -strip-dead-prototypes -gvn-hoist -constmerge -inline -early-cse-memssa -lower-widenable-condition -reg2mem -coro-elide -instcombine -mem2reg -dse -flattencfg -loop-unroll-and-jam -sroa -consthoist -mldst-motion -ee-instrument -mergereturn -infer-address-spaces -ee-instrument -gvn -rewrite-statepoints-for-gc -guard-widening -mergefunc -mergereturn -callsite-splitting -canonicalize-aliases -instnamer -alignment-from-assumptions -argpromotion -simplifycfg -flattencfg -loop-reduce -gvn -loop-deletion -loop-versioning -flattencfg -strip -cross-dso-cfi -instsimplify -attributor -early-cse-memssa -insert-gcov-profiling -separate-const-offset-from-gep -indvars -slp-vectorizer -newgvn -functionattrs -loop-guard-widening -lower-widenable-condition -rpo-functionattrs -mergeicmps -load-store-vectorizer -reassociate -div-rem-pairs -loop-simplifycfg -post-inline-ee-instrument -redundant-dbg-inst-elim -dse -coro-split -bdce -attributor -forceattrs -lower-constant-intrinsics -loop-guard-widening -instcombine -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.1169348539290735,23.584031105041504,opt -loop-reduce -mem2reg -instnamer -called-value-propagation -loop-idiom -globalopt -loop-versioning -loop-unroll-and-jam -loop-instsimplify -insert-gcov-profiling -loop-instsimplify -strip-nondebug -coro-split -globalopt -mem2reg -alignment-from-assumptions -pgo-memop-opt -sink -loop-interchange -loop-deletion -consthoist -hotcoldsplit -separate-const-offset-from-gep -mem2reg -dce -div-rem-pairs -newgvn -functionattrs -dce -loop-data-prefetch -lcssa -inferattrs -correlated-propagation -sancov -strip-nondebug -speculative-execution -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.1241212310576472,25.40641736984253,opt -rpo-functionattrs -mergeicmps -loop-predication -correlated-propagation -lowerinvoke -simplifycfg -post-inline-ee-instrument -pgo-memop-opt -inferattrs -ipconstprop -div-rem-pairs -loop-unroll-and-jam -mem2reg -mldst-motion -sroa -loop-vectorize -redundant-dbg-inst-elim -strip -infer-address-spaces -canonicalize-aliases -loop-versioning -aggressive-instcombine -strip-dead-prototypes -lower-guard-intrinsic -licm -loop-unroll -separate-const-offset-from-gep -inject-tli-mappings -loweratomic -inferattrs -lower-widenable-condition -dce -lowerinvoke -mergereturn -add-discriminators -cross-dso-cfi -coro-split -coro-split -speculative-execution -loop-instsimplify -rewrite-statepoints-for-gc -jump-threading -globalsplit -newgvn -nary-reassociate input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.1369317294172785,25.428560495376587,opt -globalsplit -sancov -simple-loop-unswitch -functionattrs -partially-inline-libcalls -globaldce -pgo-memop-opt -indvars -forceattrs -loop-reduce -coro-split -newgvn -loop-simplifycfg -inject-tli-mappings -bdce -forceattrs -simplifycfg -consthoist -functionattrs -indvars -memcpyopt -hotcoldsplit -rpo-functionattrs -newgvn -flattencfg -bdce -dce -always-inline -simple-loop-unswitch -loop-reroll -insert-gcov-profiling -callsite-splitting -mergeicmps -instnamer -constprop -consthoist -add-discriminators -separate-const-offset-from-gep -correlated-propagation -slp-vectorizer -memcpyopt -slp-vectorizer -instnamer -nary-reassociate -lower-constant-intrinsics -functionattrs -lower-guard-intrinsic -loop-guard-widening -irce -loop-deletion -sccp -reassociate -loop-guard-widening -speculative-execution -reg2mem -coro-split -pgo-memop-opt -strip-nondebug -cross-dso-cfi -mem2reg -inject-tli-mappings -loop-load-elim -loop-deletion -lower-widenable-condition -argpromotion -sroa -loop-versioning-licm -inferattrs -loop-guard-widening -loop-interchange -die -correlated-propagation -partially-inline-libcalls -lower-guard-intrinsic -loop-reduce -cross-dso-cfi -lower-guard-intrinsic -loop-predication -lower-matrix-intrinsics -consthoist -sancov -mergefunc -strip-debug-declare -coro-elide -instnamer -strip -licm -reassociate -canonicalize-aliases -loop-sink -redundant-dbg-inst-elim -ipconstprop -sroa -globalopt -consthoist -name-anon-globals -mergefunc -partial-inliner -gvn-hoist -ipconstprop -loop-deletion -redundant-dbg-inst-elim -reassociate -libcalls-shrinkwrap -instcombine -lower-expect -lowerinvoke -globalopt -mem2reg -sancov -hotcoldsplit -insert-gcov-profiling -loop-fusion -nary-reassociate -forceattrs -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.1409935947508203,24.855397701263428,opt -loop-unswitch -loop-versioning -loop-guard-widening -mldst-motion -mldst-motion -loop-idiom -loop-versioning-licm -constprop -reassociate -inferattrs -coro-cleanup -loop-simplifycfg -adce -add-discriminators -sroa -cross-dso-cfi -pgo-memop-opt -consthoist -callsite-splitting -loop-simplify -simple-loop-unswitch -callsite-splitting -alignment-from-assumptions -loop-fusion -post-inline-ee-instrument -dce -partial-inliner -ee-instrument -prune-eh -reassociate -irce -memcpyopt -functionattrs -tailcallelim -loop-vectorize -inject-tli-mappings -deadargelim -gvn -name-anon-globals -loop-data-prefetch -sccp -loop-versioning-licm -mergeicmps -always-inline -mergereturn -loop-rotate -loop-sink -coro-cleanup -nary-reassociate -loop-simplifycfg -dse -simplifycfg -loop-deletion -jump-threading -memcpyopt -globalsplit -loop-instsimplify -die -inferattrs -instcombine -coro-split -consthoist -dce -mergefunc -forceattrs -name-anon-globals -lower-widenable-condition -loop-simplify -pgo-memop-opt -jump-threading input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.1423996250585842,23.81988525390625,opt -simplifycfg -loop-simplify -gvn-hoist -early-cse-memssa -loop-instsimplify -correlated-propagation -functionattrs -simple-loop-unswitch -ipconstprop -loop-reduce -separate-const-offset-from-gep -tailcallelim -instnamer -loop-distribute -loop-load-elim -redundant-dbg-inst-elim -inject-tli-mappings -loop-deletion -loop-simplify -simplifycfg -ipsccp -elim-avail-extern -slsr -called-value-propagation -loop-deletion -loop-instsimplify -gvn-hoist -elim-avail-extern -canonicalize-aliases -reg2mem -break-crit-edges -lowerinvoke -loop-reduce -break-crit-edges -loop-instsimplify -rewrite-statepoints-for-gc -correlated-propagation -lower-guard-intrinsic -loop-sink -guard-widening -coro-early -loop-predication -simple-loop-unswitch -simplifycfg -canonicalize-aliases -reg2mem -globalsplit -strip-dead-prototypes -mergefunc -loop-predication -loop-unswitch -sink -loop-guard-widening -loop-predication -mergefunc -loop-instsimplify -lower-widenable-condition -sroa -gvn -instcombine -loop-fusion -globalsplit -ipsccp -partial-inliner -partially-inline-libcalls -alignment-from-assumptions -attributor -globalopt -early-cse-memssa -name-anon-globals -lower-constant-intrinsics -called-value-propagation -coro-early -deadargelim -loop-sink -break-crit-edges -rpo-functionattrs -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.1469301671613812,23.125929832458496,opt -load-store-vectorizer -sroa -lower-expect -mergeicmps -dse -globaldce -loop-interchange -gvn-hoist -simplifycfg -argpromotion -simplifycfg -lower-guard-intrinsic -coro-early -globaldce -loop-interchange -simple-loop-unswitch -libcalls-shrinkwrap -loop-simplify -loop-distribute -loop-guard-widening -scalarizer -scalarizer -strip-debug-declare -sancov -loop-simplify -slsr -instnamer -pgo-memop-opt -lower-guard-intrinsic -lower-constant-intrinsics -loop-unroll-and-jam -name-anon-globals -called-value-propagation -constmerge -mldst-motion -consthoist -canonicalize-aliases -redundant-dbg-inst-elim -memcpyopt -float2int -gvn -partially-inline-libcalls -loop-versioning -adce -speculative-execution -lower-guard-intrinsic -name-anon-globals -mergeicmps -loop-vectorize -adce -callsite-splitting -libcalls-shrinkwrap -add-discriminators -cross-dso-cfi -slp-vectorizer -newgvn -ipsccp -loop-vectorize -consthoist -always-inline -instsimplify -strip-debug-declare -functionattrs -early-cse-memssa -instcombine input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.1548195594438369,23.729283809661865,opt -correlated-propagation -break-crit-edges -separate-const-offset-from-gep -name-anon-globals -slsr -sancov -loop-sink -barrier -prune-eh -forceattrs -constprop -deadargelim -mem2reg -coro-split -simplifycfg -gvn-hoist -deadargelim -loop-guard-widening -sroa -constprop -globalopt -guard-widening -loop-guard-widening -consthoist -die -newgvn -jump-threading -sroa -aggressive-instcombine -loweratomic -indvars -coro-split -instcombine -slp-vectorizer -post-inline-ee-instrument -newgvn -dse input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.1548195594438382,24.505677223205566,opt -strip -break-crit-edges -loop-fusion -rewrite-statepoints-for-gc -redundant-dbg-inst-elim -div-rem-pairs -separate-const-offset-from-gep -memcpyopt -redundant-dbg-inst-elim -sroa -simple-loop-unswitch -sccp -instcombine -mem2reg -gvn -loop-sink -barrier -insert-gcov-profiling -globalopt -instnamer -forceattrs -loop-versioning-licm -mergeicmps -tailcallelim -indvars -coro-early -reassociate -post-inline-ee-instrument -globalopt -inferattrs -bdce -dce -loop-interchange -ipsccp -loop-interchange -argpromotion -sroa -argpromotion -separate-const-offset-from-gep -called-value-propagation -mergefunc -separate-const-offset-from-gep -simplifycfg -loop-simplifycfg -insert-gcov-profiling -loop-simplify -adce -rpo-functionattrs -break-crit-edges -strip-dead-prototypes -mergereturn -ipsccp -loweratomic -callsite-splitting -ipsccp -instnamer -forceattrs -slp-vectorizer -guard-widening -adce -deadargelim -loop-idiom -mldst-motion -load-store-vectorizer -indvars -inferattrs -loop-versioning -deadargelim -lcssa -simplifycfg -functionattrs -coro-cleanup -coro-cleanup -lower-widenable-condition -loop-fusion -sancov -post-inline-ee-instrument -mem2reg -loweratomic -loop-fusion -rewrite-statepoints-for-gc -correlated-propagation -sroa -indvars -coro-elide -licm -loop-load-elim -loop-unroll-and-jam -licm -loop-instsimplify -sroa -loop-versioning-licm -simple-loop-unswitch -functionattrs -canonicalize-aliases -libcalls-shrinkwrap -loop-deletion -loop-deletion -loop-versioning -mergefunc -loop-simplify -instcombine -coro-cleanup -correlated-propagation -prune-eh -globaldce -forceattrs -lower-constant-intrinsics -dce -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.1602093422902673,29.369541883468628,opt -name-anon-globals -float2int -constmerge -prune-eh -loop-guard-widening -loop-load-elim -dse -lower-constant-intrinsics -loop-instsimplify -ipsccp -tailcallelim -cross-dso-cfi -constprop -strip-debug-declare -coro-cleanup -loop-guard-widening -loop-simplifycfg -loop-reduce -loop-simplify -consthoist -barrier -canonicalize-aliases -gvn -rewrite-statepoints-for-gc -partially-inline-libcalls -post-inline-ee-instrument -instnamer -partially-inline-libcalls -sroa -loop-versioning -coro-early -bdce -loop-unroll-and-jam -sink -loop-versioning-licm -strip-debug-declare -newgvn -slp-vectorizer -loop-idiom -newgvn -simplifycfg -loweratomic -loop-instsimplify -sccp -coro-split -forceattrs -licm -licm -early-cse-memssa -rewrite-statepoints-for-gc -strip-dead-prototypes -functionattrs -functionattrs -lcssa -constmerge -loop-versioning -indvars -strip-dead-prototypes -consthoist -pgo-memop-opt -lower-expect -partially-inline-libcalls -canonicalize-aliases -sink -loop-guard-widening -speculative-execution -coro-early -rewrite-statepoints-for-gc -separate-const-offset-from-gep -tailcallelim -loop-versioning -cross-dso-cfi -coro-cleanup -gvn -aggressive-instcombine -loop-data-prefetch -sroa -lowerinvoke -sancov -loop-predication -strip-dead-prototypes -loop-distribute -guard-widening -loop-simplifycfg -globalopt -called-value-propagation -lower-expect -early-cse-memssa -mergereturn -loop-load-elim -coro-split -instcombine -name-anon-globals -insert-gcov-profiling -loop-unroll-and-jam -globalopt -strip-debug-declare -strip -separate-const-offset-from-gep -strip-debug-declare -partially-inline-libcalls -globalsplit -mergefunc -die -loop-versioning-licm -irce -loop-predication -gvn -loop-versioning -tailcallelim input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.1766911420090613,27.65174961090088,opt -pgo-memop-opt -coro-elide -coro-cleanup -pgo-memop-opt -slsr -lower-matrix-intrinsics -loop-deletion -loop-versioning-licm -post-inline-ee-instrument -strip-dead-prototypes -sink -adce -lower-guard-intrinsic -strip-nondebug -coro-early -mem2reg -constmerge -adce -strip-nondebug -mergeicmps -irce -slsr -irce -tailcallelim -ipsccp -die -memcpyopt -separate-const-offset-from-gep -loop-load-elim -gvn -reassociate -pgo-memop-opt -separate-const-offset-from-gep -loop-data-prefetch -early-cse-memssa -scalarizer -lcssa -aggressive-instcombine -lower-guard-intrinsic -loop-sink -die -tailcallelim -dse -nary-reassociate -load-store-vectorizer -dce -lower-guard-intrinsic -callsite-splitting -adce -loop-load-elim -rpo-functionattrs -strip-debug-declare -loop-unswitch -slp-vectorizer -sink -inject-tli-mappings -loop-idiom -lowerinvoke -sccp -load-store-vectorizer -loweratomic -inferattrs -constmerge -hotcoldsplit -cross-dso-cfi -mldst-motion -loop-sink -lower-constant-intrinsics -separate-const-offset-from-gep -loop-fusion -loop-vectorize -strip-nondebug -lowerinvoke -div-rem-pairs -aggressive-instcombine -insert-gcov-profiling -mergeicmps -instcombine -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/crc32,0.9921875,11.82210922241211,opt -instsimplify -instsimplify -loop-unswitch -partial-inliner -constprop -coro-split -slp-vectorizer -mergeicmps -callsite-splitting -mergereturn -sroa -attributor -name-anon-globals -aggressive-instcombine -scalarizer -globalopt -cross-dso-cfi -break-crit-edges -flattencfg -instnamer -loop-reduce -mergefunc -libcalls-shrinkwrap -sccp -loop-instsimplify -constprop -coro-split -indvars -deadargelim -loop-unroll -jump-threading -indvars -loop-guard-widening -loop-simplifycfg -deadargelim -bdce -constmerge -strip-nondebug -forceattrs -loop-reroll -inferattrs -mergefunc -sancov -speculative-execution -ipconstprop -speculative-execution -lower-guard-intrinsic -hotcoldsplit -lower-guard-intrinsic -forceattrs -adce -coro-cleanup -adce -pgo-memop-opt -slsr -dce -early-cse-memssa -ipconstprop -loop-predication -coro-elide -inject-tli-mappings -infer-address-spaces -argpromotion -float2int -separate-const-offset-from-gep -dce -loop-versioning-licm -coro-early -slp-vectorizer -adce -nary-reassociate -libcalls-shrinkwrap -instnamer -coro-early -add-discriminators -alignment-from-assumptions -lower-widenable-condition -rewrite-statepoints-for-gc -lower-widenable-condition -coro-early -argpromotion -pgo-memop-opt -inject-tli-mappings -lower-guard-intrinsic -mem2reg -lower-matrix-intrinsics -loop-sink -scalarizer -die -loop-fusion -slsr -coro-split -globaldce -inject-tli-mappings -ee-instrument -lower-constant-intrinsics -speculative-execution -dce -loop-reduce -strip -loop-unroll -prune-eh -callsite-splitting -post-inline-ee-instrument -instsimplify -mergefunc -adce -simplifycfg -callsite-splitting -gvn -globaldce -coro-early -early-cse-memssa -loop-data-prefetch -lower-expect -mergereturn -loop-vectorize -instnamer -sink -loop-versioning -cross-dso-cfi -instcombine -sancov -gvn-hoist -memcpyopt -loop-sink -nary-reassociate -loop-data-prefetch -lower-widenable-condition -add-discriminators -memcpyopt -mergefunc -inject-tli-mappings -sroa -barrier -loop-versioning -sccp -loop-data-prefetch -scalarizer -barrier -mergefunc -indvars -sccp -jump-threading -newgvn input.bc -o output.bc -benchmark://cBench-v1/crc32,0.9921875,11.96300196647644,opt -correlated-propagation -called-value-propagation -loop-versioning -slp-vectorizer -simple-loop-unswitch -always-inline -prune-eh -sroa -reg2mem -loop-idiom -nary-reassociate -prune-eh -reassociate -callsite-splitting -dce -loop-predication -float2int -partially-inline-libcalls -globaldce -coro-elide -rewrite-statepoints-for-gc -coro-split -tailcallelim -inferattrs -sancov -adce -lower-guard-intrinsic -loop-idiom -strip-nondebug -name-anon-globals -jump-threading -float2int -post-inline-ee-instrument -alignment-from-assumptions -loop-data-prefetch -tailcallelim -loop-load-elim -simple-loop-unswitch -sink -attributor -elim-avail-extern -aggressive-instcombine -break-crit-edges -lowerswitch -lowerinvoke -globalsplit -mergereturn -strip -indvars -loop-unroll-and-jam -loop-unroll -separate-const-offset-from-gep -infer-address-spaces -loop-versioning -loop-predication -loop-instsimplify -deadargelim -simplifycfg -strip-dead-prototypes -lowerinvoke -lower-constant-intrinsics -irce -inject-tli-mappings -partially-inline-libcalls -strip -constmerge -partial-inliner -pgo-memop-opt -infer-address-spaces -inline -irce -break-crit-edges -lower-matrix-intrinsics -globalsplit -slp-vectorizer -sroa -slp-vectorizer -loop-deletion -post-inline-ee-instrument -loop-unroll-and-jam -simple-loop-unswitch -mem2reg -mergereturn -sancov -loop-data-prefetch -simplifycfg -add-discriminators -gvn input.bc -o output.bc -benchmark://cBench-v1/crc32,0.9921875,12.11146593093872,opt -simple-loop-unswitch -loop-load-elim -nary-reassociate -nary-reassociate -slsr -post-inline-ee-instrument -lower-matrix-intrinsics -indvars -globalopt -mergereturn -coro-split -adce -simple-loop-unswitch -attributor -constmerge -strip-nondebug -separate-const-offset-from-gep -argpromotion -loop-interchange -gvn -strip-nondebug -add-discriminators -constmerge -mergeicmps -reg2mem -strip-debug-declare -speculative-execution -break-crit-edges -strip -loop-data-prefetch -name-anon-globals -globaldce -strip-dead-prototypes -loweratomic -sccp -partial-inliner -ee-instrument -aggressive-instcombine -scalarizer -forceattrs -argpromotion -argpromotion -instsimplify -strip-nondebug -ipconstprop -add-discriminators -loop-data-prefetch -globaldce -instsimplify -globalopt -alignment-from-assumptions -strip-dead-prototypes -newgvn -ee-instrument -strip-nondebug -loop-idiom -ipconstprop -guard-widening -correlated-propagation -gvn -lowerswitch -tailcallelim -barrier -dce -instnamer -loop-instsimplify -jump-threading -barrier -reg2mem -loop-vectorize -inline -loop-sink -mergefunc -licm -insert-gcov-profiling -constprop -aggressive-instcombine -lower-matrix-intrinsics -indvars -argpromotion -sroa -loop-data-prefetch -loop-predication -licm -loop-interchange -callsite-splitting -load-store-vectorizer -flattencfg -constmerge -reassociate -lower-matrix-intrinsics -jump-threading -loop-data-prefetch -coro-split -instcombine input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,11.723689317703247,opt -partially-inline-libcalls -inferattrs -mem2reg -scalarizer -always-inline -coro-elide -loop-reroll -constmerge -loop-reroll -globalsplit -early-cse-memssa -insert-gcov-profiling -sroa -insert-gcov-profiling -jump-threading -simple-loop-unswitch -adce -deadargelim -simplifycfg -sccp -rpo-functionattrs -instcombine input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,11.768340826034546,opt -strip -strip-debug-declare -prune-eh -add-discriminators -loop-interchange -infer-address-spaces -callsite-splitting -loop-interchange -loop-versioning -globalsplit -infer-address-spaces -rpo-functionattrs -attributor -loop-unswitch -guard-widening -deadargelim -loop-data-prefetch -loop-data-prefetch -newgvn -speculative-execution -instcombine -lower-guard-intrinsic -loop-sink -early-cse-memssa -loop-unroll -constmerge -inferattrs -called-value-propagation -lowerswitch -strip-nondebug -dce -redundant-dbg-inst-elim -sink -mergefunc -pgo-memop-opt -loop-distribute -sink -loop-deletion -name-anon-globals -lcssa -loop-idiom -irce -lowerswitch -loop-versioning-licm -bdce -prune-eh -rpo-functionattrs -loop-unroll-and-jam -loweratomic -libcalls-shrinkwrap -strip-dead-prototypes -strip-dead-prototypes -break-crit-edges -lower-expect -globaldce -slsr -adce -instcombine -insert-gcov-profiling -nary-reassociate -infer-address-spaces -prune-eh -load-store-vectorizer -argpromotion -ipconstprop -dse -tailcallelim -scalarizer -inferattrs -mldst-motion -slp-vectorizer -loop-fusion -reassociate -post-inline-ee-instrument -constprop -lcssa -globaldce -loweratomic -sancov -strip-dead-prototypes -lowerinvoke -mldst-motion -jump-threading -loop-predication -lower-matrix-intrinsics -load-store-vectorizer -globaldce -mergeicmps -float2int -loop-vectorize -gvn -tailcallelim -redundant-dbg-inst-elim -globalopt -irce -loop-load-elim -lcssa -called-value-propagation -speculative-execution -loop-instsimplify -simple-loop-unswitch -newgvn -reassociate -redundant-dbg-inst-elim -sroa -mergereturn -globalsplit -sroa -lower-matrix-intrinsics -called-value-propagation -mldst-motion -barrier -elim-avail-extern -dce -tailcallelim -loop-versioning -callsite-splitting -partially-inline-libcalls -aggressive-instcombine -simple-loop-unswitch -globaldce -dse -bdce -separate-const-offset-from-gep -mergeicmps -sancov -speculative-execution -elim-avail-extern -flattencfg -adce -forceattrs -flattencfg -loop-simplify -canonicalize-aliases -loop-load-elim -die -scalarizer -strip-dead-prototypes -cross-dso-cfi -lowerswitch -strip -nary-reassociate -slsr -bdce -instcombine -newgvn -float2int -cross-dso-cfi -canonicalize-aliases -loop-predication -partial-inliner -coro-elide -irce -globaldce -coro-elide -argpromotion -rewrite-statepoints-for-gc -reassociate -ipconstprop -early-cse-memssa -constmerge -coro-elide -loop-reroll -infer-address-spaces -coro-elide -coro-split -gvn-hoist -cross-dso-cfi -loop-versioning-licm -loop-distribute -tailcallelim -pgo-memop-opt -lower-guard-intrinsic -forceattrs -loop-interchange -nary-reassociate -sink -early-cse-memssa -coro-cleanup -loop-vectorize -loop-instsimplify -loop-versioning -mem2reg -lcssa -strip-nondebug -strip-dead-prototypes -coro-early -gvn -redundant-dbg-inst-elim -scalarizer -ipsccp -infer-address-spaces -instcombine -lower-matrix-intrinsics -irce -barrier -correlated-propagation -lower-constant-intrinsics -gvn-hoist -slp-vectorizer -loop-vectorize -loop-instsimplify -loop-instsimplify -instsimplify -deadargelim -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,11.806458950042725,opt -lcssa -strip -always-inline -prune-eh -argpromotion -scalarizer -ee-instrument -inject-tli-mappings -lcssa -lower-expect -coro-cleanup -partial-inliner -loop-sink -sink -ipsccp -forceattrs -globalsplit -correlated-propagation -loop-guard-widening -strip-nondebug -name-anon-globals -load-store-vectorizer -rewrite-statepoints-for-gc -mldst-motion -mldst-motion -speculative-execution -attributor -name-anon-globals -tailcallelim -loop-fusion -alignment-from-assumptions -newgvn -separate-const-offset-from-gep -div-rem-pairs -lower-constant-intrinsics -inferattrs -forceattrs -globalsplit -loop-simplifycfg -callsite-splitting -bdce -sroa -mergefunc -lowerswitch -sroa -flattencfg -mergefunc -mergefunc -elim-avail-extern -loop-unroll -flattencfg -inferattrs -reassociate -strip-debug-declare -ipconstprop -gvn-hoist -speculative-execution -instsimplify -loop-deletion -gvn-hoist -guard-widening -loop-interchange -bdce -lower-matrix-intrinsics -cross-dso-cfi -loop-versioning -redundant-dbg-inst-elim -loop-simplifycfg -libcalls-shrinkwrap -tailcallelim -jump-threading -globalsplit -div-rem-pairs -constprop -ipconstprop -rewrite-statepoints-for-gc -loop-load-elim -lowerswitch -inject-tli-mappings -insert-gcov-profiling -break-crit-edges -called-value-propagation -simplifycfg -inject-tli-mappings -add-discriminators -dce -aggressive-instcombine -instcombine input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,11.919891834259033,opt -globalsplit -loop-unroll-and-jam -barrier -partially-inline-libcalls -gvn-hoist -loop-interchange -loop-data-prefetch -lower-guard-intrinsic -lcssa -mem2reg -mergereturn -hotcoldsplit -newgvn -barrier -pgo-memop-opt -reassociate -simplifycfg -die -deadargelim -libcalls-shrinkwrap -lowerinvoke -mergeicmps -loop-vectorize -loop-fusion -mldst-motion -loop-vectorize -post-inline-ee-instrument -load-store-vectorizer -rpo-functionattrs -sancov -load-store-vectorizer -loop-fusion -lowerswitch -consthoist -libcalls-shrinkwrap -loop-versioning -globalsplit -post-inline-ee-instrument -constmerge -loop-guard-widening -adce -inject-tli-mappings -cross-dso-cfi -instcombine -float2int -loop-reroll -loop-vectorize -prune-eh -sccp -coro-elide -dce -elim-avail-extern -nary-reassociate -simplifycfg -gvn input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,11.926751136779785,opt -name-anon-globals -load-store-vectorizer -loop-versioning -float2int -bdce -float2int -loop-fusion -loop-distribute -loop-guard-widening -nary-reassociate -instsimplify -loop-interchange -sccp -lower-matrix-intrinsics -gvn-hoist -nary-reassociate -break-crit-edges -cross-dso-cfi -insert-gcov-profiling -prune-eh -loop-simplifycfg -loop-load-elim -mem2reg -die -strip-dead-prototypes -mergereturn -loop-vectorize -add-discriminators -loop-fusion -licm -strip-dead-prototypes -aggressive-instcombine -rewrite-statepoints-for-gc -ipsccp -deadargelim -loweratomic -reassociate -loop-predication -consthoist -div-rem-pairs -gvn-hoist -strip-dead-prototypes -lower-widenable-condition -correlated-propagation -inject-tli-mappings -ipconstprop -dse -reassociate -loop-unroll -barrier -strip -rpo-functionattrs -insert-gcov-profiling -gvn -instcombine -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,11.97989559173584,opt -coro-elide -loop-unroll -early-cse-memssa -loop-simplify -always-inline -lower-expect -loop-interchange -loop-versioning-licm -lower-matrix-intrinsics -indvars -loop-unroll -elim-avail-extern -partially-inline-libcalls -loop-guard-widening -constmerge -ee-instrument -loweratomic -div-rem-pairs -adce -loop-unroll -loop-deletion -reassociate -constmerge -memcpyopt -consthoist -reassociate -simple-loop-unswitch -correlated-propagation -globalopt -aggressive-instcombine -coro-elide -attributor -lower-constant-intrinsics -partially-inline-libcalls -coro-split -reassociate -loop-simplify -licm -hotcoldsplit -tailcallelim -flattencfg -lower-matrix-intrinsics -die -strip-dead-prototypes -rewrite-statepoints-for-gc -argpromotion -instsimplify -inferattrs -break-crit-edges -mergeicmps -coro-early -loop-vectorize -ipconstprop -loop-deletion -lowerinvoke -break-crit-edges -constprop -instcombine -inject-tli-mappings -loop-distribute -partial-inliner -loop-unroll-and-jam -guard-widening -instsimplify -reassociate -coro-early -lower-constant-intrinsics -newgvn -ipsccp -tailcallelim -coro-elide -sroa -loop-simplify -loop-guard-widening -loop-load-elim -loop-sink -lcssa -slp-vectorizer -loop-reduce -mergefunc -load-store-vectorizer -lower-guard-intrinsic -prune-eh -ipsccp -dse -reassociate -loop-guard-widening -mergereturn -lower-widenable-condition -constmerge -inferattrs -attributor -loop-interchange -ee-instrument -load-store-vectorizer -simplifycfg -aggressive-instcombine -simplifycfg -lowerswitch -newgvn -loop-reduce -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,12.256370306015015,opt -separate-const-offset-from-gep -coro-split -globalopt -attributor -irce -lowerinvoke -consthoist -globalopt -mergeicmps -lcssa -loop-deletion -argpromotion -name-anon-globals -strip-debug-declare -constprop -scalarizer -sroa -die -sink -slsr -consthoist -dse -barrier -lcssa -ipsccp -always-inline -pgo-memop-opt -infer-address-spaces -slp-vectorizer -lower-expect -infer-address-spaces -loop-fusion -loop-sink -mem2reg -loop-reduce -strip-debug-declare -coro-cleanup -strip -pgo-memop-opt -instsimplify -constmerge -loop-unroll-and-jam -lowerinvoke -loop-guard-widening -loop-load-elim -loop-simplify -constprop -early-cse-memssa -irce -div-rem-pairs -post-inline-ee-instrument -div-rem-pairs -ee-instrument -ee-instrument -div-rem-pairs -lowerswitch -lower-matrix-intrinsics -lower-expect -strip-debug-declare -prune-eh -prune-eh -early-cse-memssa -instcombine -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.9540816326530615,12.104652643203735,opt -loop-reduce -loop-sink -mem2reg -pgo-memop-opt -pgo-memop-opt -bdce -hotcoldsplit -sancov -slp-vectorizer -instsimplify -reassociate -newgvn -speculative-execution -libcalls-shrinkwrap -mem2reg -elim-avail-extern -loop-simplify -irce -ipsccp -indvars -flattencfg -indvars -jump-threading -sroa -simple-loop-unswitch -lower-expect -loop-distribute -constprop -pgo-memop-opt -coro-early -inferattrs -loop-data-prefetch -newgvn -functionattrs -instsimplify -argpromotion -instcombine input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.9693877551020408,12.26811695098877,opt -scalarizer -loop-sink -functionattrs -deadargelim -loop-simplifycfg -loop-sink -simple-loop-unswitch -slsr -pgo-memop-opt -loop-interchange -elim-avail-extern -indvars -loop-deletion -insert-gcov-profiling -mldst-motion -bdce -slsr -loop-unroll -speculative-execution -lower-expect -functionattrs -lower-widenable-condition -correlated-propagation -strip -loop-unroll -simple-loop-unswitch -dce -loop-vectorize -mldst-motion -tailcallelim -break-crit-edges -mergeicmps -insert-gcov-profiling -slp-vectorizer -lower-matrix-intrinsics -bdce -globaldce -name-anon-globals -ipconstprop -post-inline-ee-instrument -separate-const-offset-from-gep -loop-simplifycfg -gvn-hoist -sink -loop-sink -inject-tli-mappings -argpromotion -irce -coro-split -sink -loop-load-elim -lower-guard-intrinsic -early-cse-memssa -inferattrs -loop-predication -speculative-execution -licm -early-cse-memssa -forceattrs -infer-address-spaces -rpo-functionattrs -sroa -deadargelim -simple-loop-unswitch -correlated-propagation -strip-nondebug -loop-interchange -rpo-functionattrs -indvars -partial-inliner -lower-constant-intrinsics -early-cse-memssa -called-value-propagation -simplifycfg -loop-guard-widening -forceattrs -post-inline-ee-instrument -mem2reg -jump-threading -canonicalize-aliases -ee-instrument -newgvn -callsite-splitting -rpo-functionattrs -loweratomic -strip -loop-unroll-and-jam -prune-eh -instcombine -die -canonicalize-aliases -nary-reassociate -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.9693877551020409,11.962674379348755,opt -forceattrs -infer-address-spaces -rewrite-statepoints-for-gc -hotcoldsplit -add-discriminators -name-anon-globals -die -loweratomic -newgvn -mem2reg -dse -speculative-execution -memcpyopt -simplifycfg -insert-gcov-profiling -sroa -globaldce -pgo-memop-opt -tailcallelim -lower-constant-intrinsics -lower-expect -speculative-execution -instcombine input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.9693877551020409,12.425644397735596,opt -elim-avail-extern -rpo-functionattrs -jump-threading -loop-instsimplify -loop-simplify -alignment-from-assumptions -simple-loop-unswitch -inject-tli-mappings -load-store-vectorizer -sroa -instnamer -attributor -die -bdce -strip -always-inline -reassociate -loop-predication -coro-cleanup -sink -loop-unroll -scalarizer -mergeicmps -lcssa -instnamer -adce -coro-split -redundant-dbg-inst-elim -lcssa -constprop -elim-avail-extern -loop-unswitch -loop-unroll-and-jam -loweratomic -nary-reassociate -bdce -partially-inline-libcalls -gvn-hoist -inferattrs -irce -loop-unswitch -separate-const-offset-from-gep -sancov -ipsccp -constmerge -sroa -instnamer -redundant-dbg-inst-elim -loop-idiom -loop-distribute -slp-vectorizer -loop-vectorize -simple-loop-unswitch -float2int -sancov -sancov -slsr -called-value-propagation -loop-reduce -globaldce -scalarizer -prune-eh -loop-predication -lower-expect -loop-deletion -slsr -mem2reg -add-discriminators -loop-versioning -loop-reroll -forceattrs -lower-widenable-condition -loop-load-elim -coro-cleanup -partially-inline-libcalls -attributor -libcalls-shrinkwrap -loweratomic -called-value-propagation -instsimplify -loop-sink -called-value-propagation -jump-threading -load-store-vectorizer -sroa -constprop -slp-vectorizer -mldst-motion -guard-widening -gvn -loop-versioning-licm -dse -loop-predication -loop-reroll -hotcoldsplit -licm -mergereturn -sink -mergeicmps -div-rem-pairs -functionattrs -lower-expect -rpo-functionattrs -loop-predication -loop-data-prefetch -elim-avail-extern -always-inline -guard-widening -div-rem-pairs -prune-eh -strip -licm -reg2mem -loop-sink -rewrite-statepoints-for-gc -inject-tli-mappings -loop-sink -lower-matrix-intrinsics -strip-dead-prototypes -sroa -loop-sink -globaldce -barrier -post-inline-ee-instrument -dse -prune-eh -deadargelim -libcalls-shrinkwrap -rpo-functionattrs -forceattrs -name-anon-globals -sink -simplifycfg -gvn -loop-guard-widening -loop-guard-widening -slsr -loop-unroll -consthoist -loop-interchange -slsr -inferattrs -lower-widenable-condition -mem2reg -strip-debug-declare -simplifycfg -loop-reroll -lcssa -lower-constant-intrinsics -barrier -sancov -cross-dso-cfi -lower-expect -coro-elide -loop-load-elim -dse -simple-loop-unswitch -aggressive-instcombine -coro-elide -lower-guard-intrinsic -cross-dso-cfi -insert-gcov-profiling -early-cse-memssa -lowerinvoke -lower-expect -callsite-splitting -lowerinvoke -loop-reroll -load-store-vectorizer -guard-widening -rpo-functionattrs -instnamer -coro-cleanup -loop-versioning-licm -loop-data-prefetch -dce -coro-elide -loop-instsimplify -mergefunc -always-inline -instsimplify -ipsccp -instnamer -constprop -jump-threading -lower-expect -loop-fusion -ipsccp -coro-cleanup -break-crit-edges -ipsccp -loop-simplify -loop-unroll-and-jam -bdce -strip-debug-declare -dse -loop-reduce -slp-vectorizer -gvn -forceattrs -lowerswitch -rewrite-statepoints-for-gc -inject-tli-mappings -reassociate -licm -lowerswitch -name-anon-globals -pgo-memop-opt -dse -gvn-hoist -nary-reassociate -functionattrs -nary-reassociate -loop-deletion -loop-guard-widening -consthoist -barrier -loop-reroll -rpo-functionattrs -separate-const-offset-from-gep -strip-dead-prototypes -strip-debug-declare -instsimplify -nary-reassociate -mergefunc -lowerinvoke -flattencfg -loop-predication -reassociate -pgo-memop-opt -indvars -loop-distribute -mergefunc -aggressive-instcombine -coro-elide -loop-idiom -barrier -loop-vectorize -consthoist -simplifycfg -sroa -insert-gcov-profiling -lowerswitch -lcssa -instcombine input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.9744897959183674,12.125283002853394,opt -functionattrs -loop-distribute -callsite-splitting -dce -sancov -add-discriminators -argpromotion -simplifycfg -loop-reduce -ee-instrument -redundant-dbg-inst-elim -instnamer -reg2mem -sink -partially-inline-libcalls -strip-debug-declare -loop-unroll -loop-predication -callsite-splitting -slsr -libcalls-shrinkwrap -partially-inline-libcalls -deadargelim -dce -argpromotion -forceattrs -aggressive-instcombine -barrier -div-rem-pairs -lower-constant-intrinsics -globaldce -ipsccp -barrier -rewrite-statepoints-for-gc -loop-data-prefetch -memcpyopt -callsite-splitting -ee-instrument -loop-unswitch -indvars -strip -memcpyopt -scalarizer -constmerge -coro-early -loop-distribute -lower-expect -lower-expect -loop-instsimplify -argpromotion -reassociate -slp-vectorizer -pgo-memop-opt -insert-gcov-profiling -functionattrs -loop-unroll -loop-reduce -callsite-splitting -lower-widenable-condition -coro-elide -coro-early -newgvn -loop-instsimplify -lower-widenable-condition -gvn-hoist -jump-threading -sroa -strip -ipsccp -strip-dead-prototypes -adce -memcpyopt -load-store-vectorizer -partially-inline-libcalls -indvars -early-cse-memssa -hotcoldsplit -newgvn -guard-widening -loop-unroll-and-jam -tailcallelim -lcssa -ee-instrument -newgvn -loweratomic -lowerinvoke -flattencfg -instsimplify -loop-interchange -speculative-execution -reassociate -always-inline -instcombine -lower-matrix-intrinsics -loop-predication -guard-widening -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.9795918367346937,11.949142694473267,opt -instnamer -partially-inline-libcalls -loop-distribute -loop-predication -die -lower-expect -early-cse-memssa -rpo-functionattrs -redundant-dbg-inst-elim -separate-const-offset-from-gep -loop-load-elim -strip-nondebug -loop-versioning-licm -sancov -add-discriminators -float2int -loop-simplifycfg -inferattrs -alignment-from-assumptions -strip-debug-declare -loop-versioning -memcpyopt -indvars -loop-guard-widening -irce -guard-widening -loop-simplifycfg -lower-constant-intrinsics -argpromotion -loop-reroll -argpromotion -lowerinvoke -gvn-hoist -loop-unroll-and-jam -dse -sancov -newgvn -mem2reg -argpromotion -loop-load-elim -scalarizer -loop-sink -forceattrs -break-crit-edges -loop-unroll-and-jam -irce -canonicalize-aliases -memcpyopt -dce -mergereturn -adce -coro-elide -bdce -loop-predication -mem2reg -loop-reduce -simplifycfg -add-discriminators -scalarizer -libcalls-shrinkwrap -always-inline -reassociate -lower-constant-intrinsics -ipconstprop -aggressive-instcombine -called-value-propagation -gvn-hoist -die -loop-versioning-licm -loop-sink -mldst-motion -lower-guard-intrinsic -div-rem-pairs -mergeicmps -memcpyopt -loop-distribute -forceattrs -ipconstprop -rewrite-statepoints-for-gc -load-store-vectorizer -loop-versioning-licm -loop-reduce -simplifycfg -coro-elide -simple-loop-unswitch -loop-reroll -licm -loop-versioning -callsite-splitting -correlated-propagation -lower-guard-intrinsic -inferattrs -loop-guard-widening -cross-dso-cfi -name-anon-globals -loop-interchange -div-rem-pairs -dce -irce -loop-distribute -coro-early -loop-versioning -lower-guard-intrinsic -globalopt -loop-versioning-licm -instcombine -aggressive-instcombine -sink -jump-threading input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.9795918367346937,12.17411756515503,opt -dse -loop-reduce -gvn-hoist -float2int -libcalls-shrinkwrap -called-value-propagation -instnamer -sink -rpo-functionattrs -loop-fusion -loop-versioning-licm -loop-distribute -instsimplify -ipsccp -sancov -loop-distribute -dce -lowerswitch -newgvn -instsimplify -aggressive-instcombine -globalsplit -lower-widenable-condition -mergefunc -ipconstprop -sroa -die -loop-sink -loop-reroll -sroa -globaldce -loop-distribute -speculative-execution -add-discriminators -sccp -tailcallelim -partially-inline-libcalls -functionattrs -loop-reroll -loweratomic -forceattrs -globalsplit -loop-load-elim -consthoist -instcombine -deadargelim -loop-instsimplify -div-rem-pairs -dse -instcombine -coro-elide -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.9795918367346939,12.16299557685852,opt -loop-versioning -coro-early -scalarizer -bdce -nary-reassociate -partially-inline-libcalls -alignment-from-assumptions -div-rem-pairs -lcssa -newgvn -constmerge -forceattrs -alignment-from-assumptions -mem2reg -globaldce -mergefunc -separate-const-offset-from-gep -loop-unswitch -lower-widenable-condition -attributor -loop-versioning -alignment-from-assumptions -flattencfg -cross-dso-cfi -lower-constant-intrinsics -strip -instcombine -functionattrs -loop-vectorize -ipsccp -simplifycfg -attributor -aggressive-instcombine -lower-matrix-intrinsics -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.9795918367346939,12.400394678115845,opt -coro-early -ipconstprop -canonicalize-aliases -lower-constant-intrinsics -instnamer -early-cse-memssa -lower-constant-intrinsics -float2int -mergefunc -loop-load-elim -mergereturn -loop-unroll -loop-idiom -libcalls-shrinkwrap -rpo-functionattrs -lcssa -strip-dead-prototypes -scalarizer -loop-fusion -reassociate -bdce -coro-cleanup -inject-tli-mappings -reassociate -loop-fusion -globaldce -reg2mem -strip -ipconstprop -reg2mem -sink -loop-simplifycfg -aggressive-instcombine -loop-instsimplify -prune-eh -reg2mem -tailcallelim -early-cse-memssa -barrier -barrier -mldst-motion -loop-data-prefetch -forceattrs -loop-versioning -sink -strip-dead-prototypes -speculative-execution -loop-deletion -slp-vectorizer -ipsccp -jump-threading -pgo-memop-opt -coro-split -loop-unroll -lowerinvoke -callsite-splitting -scalarizer -loop-simplify -irce -instnamer -sroa -instsimplify -cross-dso-cfi -newgvn -rpo-functionattrs -loop-reduce -attributor -loop-simplifycfg -coro-split -sroa -lower-expect -coro-early -ee-instrument -strip -lower-matrix-intrinsics -gvn-hoist -strip-debug-declare -separate-const-offset-from-gep -sancov -newgvn -loop-fusion -slsr -gvn-hoist -loop-simplify -strip -loop-guard-widening -simple-loop-unswitch -sroa -forceattrs -slp-vectorizer -loop-idiom -strip-dead-prototypes -sancov -canonicalize-aliases -simple-loop-unswitch -scalarizer -guard-widening -ipsccp -inject-tli-mappings -aggressive-instcombine -licm -elim-avail-extern -loop-versioning-licm -float2int -gvn-hoist -coro-split -coro-early -loop-reduce -coro-elide -simplifycfg -partially-inline-libcalls -canonicalize-aliases -loop-versioning-licm -loop-data-prefetch -callsite-splitting -simple-loop-unswitch -deadargelim -loop-deletion -loop-vectorize -functionattrs -loweratomic -jump-threading -loop-reroll -guard-widening -pgo-memop-opt -reg2mem -coro-elide -slsr -separate-const-offset-from-gep -coro-cleanup -sancov -elim-avail-extern -deadargelim -mem2reg -instcombine -constmerge -reg2mem -instsimplify -lower-expect -callsite-splitting -globaldce -sroa -loop-fusion -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.9948979591836736,11.850993156433105,opt -strip -sroa -globaldce -coro-split -lower-constant-intrinsics -loop-versioning -lower-constant-intrinsics -load-store-vectorizer -cross-dso-cfi -dce -lower-widenable-condition -loop-reroll -barrier -dce -loop-distribute -cross-dso-cfi -always-inline -newgvn -strip-debug-declare -loop-reroll -loop-predication -jump-threading -prune-eh -memcpyopt -gvn-hoist -libcalls-shrinkwrap -elim-avail-extern -mldst-motion -loop-reroll -callsite-splitting -float2int -loop-guard-widening -correlated-propagation -lowerinvoke -strip-debug-declare -slp-vectorizer -sccp -instcombine -dce -barrier -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/ghostscript,0.977961552919373,340.80205249786377,opt -libcalls-shrinkwrap -loop-unroll-and-jam -constmerge -lowerinvoke -loweratomic -inject-tli-mappings -ipsccp -consthoist -instsimplify -indvars -loop-simplifycfg -loop-instsimplify -rewrite-statepoints-for-gc -rewrite-statepoints-for-gc -sccp -functionattrs -strip-debug-declare -coro-cleanup -lowerinvoke -die -cross-dso-cfi -loop-sink -loop-predication -loop-guard-widening -add-discriminators -loop-distribute -mergereturn -guard-widening -loop-simplify -instnamer -prune-eh -pgo-memop-opt -deadargelim -slp-vectorizer -called-value-propagation -lower-matrix-intrinsics -die -strip -jump-threading -inject-tli-mappings -newgvn -loop-predication -deadargelim -gvn -elim-avail-extern -dse -infer-address-spaces -instnamer -loweratomic -loop-data-prefetch -mem2reg -dse -instcombine -bdce -memcpyopt -instsimplify -dse -licm -loop-vectorize -jump-threading -sroa -loop-sink -argpromotion -loop-unroll -loop-fusion -coro-early -gvn-hoist -loop-sink -post-inline-ee-instrument -coro-early -early-cse-memssa -callsite-splitting -libcalls-shrinkwrap -loop-distribute -scalarizer -scalarizer -loop-load-elim -sink -instnamer -break-crit-edges -inject-tli-mappings -loop-versioning-licm -separate-const-offset-from-gep -lowerswitch -partially-inline-libcalls -memcpyopt -strip -strip-nondebug -loop-vectorize -canonicalize-aliases -bdce -mergereturn -instnamer -scalarizer -indvars -die -partial-inliner -slsr -coro-elide -load-store-vectorizer -post-inline-ee-instrument -strip-debug-declare -ipconstprop -rewrite-statepoints-for-gc -called-value-propagation -bdce -mergereturn -forceattrs -ipsccp -die -reassociate -tailcallelim -lower-widenable-condition -infer-address-spaces -break-crit-edges -insert-gcov-profiling -memcpyopt -callsite-splitting -die -inject-tli-mappings -hotcoldsplit -mergefunc -name-anon-globals -instcombine -inject-tli-mappings -instnamer -constmerge -post-inline-ee-instrument -sroa -constmerge -attributor -loop-data-prefetch -scalarizer -sccp -slp-vectorizer -scalarizer -forceattrs -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/ghostscript,0.9786958764238445,435.53417801856995,opt -load-store-vectorizer -loop-sink -jump-threading -flattencfg -memcpyopt -consthoist -ipsccp -correlated-propagation -sccp -die -die -loop-unroll -sink -slsr -canonicalize-aliases -loop-unroll -post-inline-ee-instrument -correlated-propagation -deadargelim -forceattrs -mem2reg -loop-instsimplify -globalsplit -mergeicmps -deadargelim -loop-deletion -correlated-propagation -constmerge -lower-expect -callsite-splitting -loweratomic -always-inline -strip-dead-prototypes -loop-distribute -dce -canonicalize-aliases -irce -coro-split -loop-vectorize -mergeicmps -coro-cleanup -lowerswitch -called-value-propagation -hotcoldsplit -globaldce -always-inline -slp-vectorizer -dce -coro-elide -argpromotion -mldst-motion -memcpyopt -forceattrs -rpo-functionattrs -loop-deletion -loop-unroll -mldst-motion -simplifycfg -lower-expect -slp-vectorizer -loop-load-elim -gvn -lower-guard-intrinsic -licm -irce -dse -loop-fusion -redundant-dbg-inst-elim -instcombine -mldst-motion -strip-debug-declare -add-discriminators -gvn -div-rem-pairs -instsimplify -tailcallelim -loop-reduce -loop-unroll-and-jam -inferattrs -break-crit-edges -coro-cleanup -ipconstprop -lower-matrix-intrinsics -ipsccp -loop-interchange -name-anon-globals -break-crit-edges -lower-expect -tailcallelim -rewrite-statepoints-for-gc -die -newgvn -guard-widening -break-crit-edges -loop-unroll -hotcoldsplit -loop-unroll -lcssa -cross-dso-cfi -loop-predication -loop-deletion -libcalls-shrinkwrap -forceattrs -called-value-propagation -die -barrier -die -attributor -sink -loop-versioning -bdce -pgo-memop-opt -loop-versioning-licm -inferattrs -loop-distribute -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/ghostscript,0.9787745539421807,293.76403188705444,opt -partially-inline-libcalls -newgvn -tailcallelim -sroa -instcombine -simplifycfg -slp-vectorizer input.bc -o output.bc -benchmark://cBench-v1/ghostscript,0.9810343471077269,331.94740438461304,opt -newgvn -partially-inline-libcalls -nary-reassociate -pgo-memop-opt -attributor -strip -loop-distribute -loop-fusion -reg2mem -redundant-dbg-inst-elim -loop-load-elim -loop-sink -pgo-memop-opt -loop-deletion -cross-dso-cfi -jump-threading -argpromotion -reassociate -inferattrs -slp-vectorizer -barrier -lower-widenable-condition -correlated-propagation -newgvn -loweratomic -ipconstprop -separate-const-offset-from-gep -consthoist -loop-fusion -loop-unroll -loop-idiom -gvn -lower-guard-intrinsic -load-store-vectorizer -name-anon-globals -loop-vectorize -ipconstprop -globalopt -reg2mem -loop-versioning -coro-cleanup -insert-gcov-profiling -separate-const-offset-from-gep -loop-unroll -forceattrs -sroa -strip -div-rem-pairs -mergereturn -rewrite-statepoints-for-gc -reg2mem -loop-data-prefetch -loop-unswitch -mem2reg -nary-reassociate -lower-expect -lower-matrix-intrinsics -libcalls-shrinkwrap -memcpyopt -sccp -loop-instsimplify -forceattrs -loop-guard-widening -sancov -loop-unroll-and-jam -alignment-from-assumptions -loop-unroll-and-jam -simple-loop-unswitch -slsr -sink -loop-unswitch -coro-cleanup -strip -licm -deadargelim -tailcallelim -argpromotion -rewrite-statepoints-for-gc -aggressive-instcombine -licm -loop-instsimplify -gvn -partial-inliner -inject-tli-mappings -loop-data-prefetch -tailcallelim -newgvn -always-inline -lower-widenable-condition -name-anon-globals -loop-data-prefetch -callsite-splitting -instsimplify -ipconstprop -instcombine -loop-unroll-and-jam -coro-split -strip-debug-declare -constmerge -newgvn -slp-vectorizer -add-discriminators -coro-elide -inject-tli-mappings -sroa -libcalls-shrinkwrap -float2int -inferattrs -guard-widening -indvars -loop-reduce -insert-gcov-profiling -speculative-execution -insert-gcov-profiling -cross-dso-cfi -slp-vectorizer -gvn-hoist -partial-inliner -prune-eh -indvars -inject-tli-mappings -coro-elide -loop-guard-widening -irce -constmerge -loop-vectorize -partially-inline-libcalls -functionattrs -infer-address-spaces -deadargelim -jump-threading -globalopt -lower-matrix-intrinsics -instcombine input.bc -o output.bc -benchmark://cBench-v1/ghostscript,0.9854839978669648,299.6495168209076,opt -loop-interchange -attributor -loop-versioning-licm -memcpyopt -coro-elide -add-discriminators -loop-reroll -flattencfg -simple-loop-unswitch -called-value-propagation -sancov -infer-address-spaces -ipsccp -attributor -strip-dead-prototypes -bdce -adce -inject-tli-mappings -attributor -strip-dead-prototypes -simple-loop-unswitch -strip -coro-elide -globalsplit -loop-idiom -guard-widening -dce -div-rem-pairs -redundant-dbg-inst-elim -die -loop-simplify -indvars -loop-simplify -tailcallelim -name-anon-globals -bdce -mergefunc -mem2reg -slsr -slsr -indvars -name-anon-globals -coro-split -newgvn -post-inline-ee-instrument -sccp -cross-dso-cfi -correlated-propagation -irce -gvn -load-store-vectorizer -instcombine -attributor -memcpyopt -instnamer -loop-load-elim -separate-const-offset-from-gep -strip-dead-prototypes -correlated-propagation -globaldce -alignment-from-assumptions -gvn-hoist -instnamer -bdce -globalsplit -argpromotion -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/ghostscript,0.9911312952942102,297.16990852355957,opt -sroa -instsimplify -strip-dead-prototypes -loop-unroll -guard-widening -float2int -pgo-memop-opt -lowerswitch -jump-threading -dce -strip -loop-sink -loop-predication -strip-nondebug -ee-instrument -sink -globalopt -float2int -lowerswitch -pgo-memop-opt -loop-distribute -coro-split -inferattrs -gvn -hotcoldsplit -loop-unroll -irce -instnamer -lcssa -constprop -separate-const-offset-from-gep -slsr -callsite-splitting -bdce -sancov -consthoist -div-rem-pairs -bdce -dse -strip-debug-declare -mergereturn -inject-tli-mappings -load-store-vectorizer -sink -adce -partially-inline-libcalls -indvars -globalsplit -called-value-propagation -globalsplit -mergereturn -pgo-memop-opt -lower-matrix-intrinsics -always-inline -post-inline-ee-instrument -licm -speculative-execution -indvars -coro-cleanup -irce -loop-fusion -barrier -mergefunc -loop-sink -jump-threading -alignment-from-assumptions -loop-interchange -partially-inline-libcalls -loop-reroll -memcpyopt -sink -strip-dead-prototypes -libcalls-shrinkwrap -name-anon-globals -reassociate -speculative-execution -mergereturn -strip-debug-declare -mldst-motion -rewrite-statepoints-for-gc -loop-reroll -add-discriminators -argpromotion -scalarizer -post-inline-ee-instrument -always-inline -strip-debug-declare -tailcallelim -loop-reduce -separate-const-offset-from-gep -loop-unroll-and-jam -called-value-propagation -flattencfg -canonicalize-aliases -loop-predication -separate-const-offset-from-gep -dse -add-discriminators -ee-instrument -attributor -lower-expect -add-discriminators -break-crit-edges -loop-predication -lowerswitch -forceattrs -loop-versioning -loop-versioning-licm -memcpyopt -reassociate -functionattrs -libcalls-shrinkwrap -lowerswitch -partially-inline-libcalls -alignment-from-assumptions -loop-load-elim -lower-matrix-intrinsics -infer-address-spaces -loop-distribute -separate-const-offset-from-gep -insert-gcov-profiling -elim-avail-extern -div-rem-pairs -canonicalize-aliases -ee-instrument -lower-constant-intrinsics -gvn -separate-const-offset-from-gep -alignment-from-assumptions -elim-avail-extern -prune-eh -jump-threading -alignment-from-assumptions -coro-early -instcombine -jump-threading -name-anon-globals -lower-expect -ipconstprop -newgvn -loop-interchange -name-anon-globals -sccp -newgvn -name-anon-globals -flattencfg -sroa -dce -constmerge -lowerswitch -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/ghostscript,0.9913017632506052,329.5422034263611,opt -strip-dead-prototypes -lower-widenable-condition -loop-instsimplify -name-anon-globals -canonicalize-aliases -simplifycfg -loop-predication -canonicalize-aliases -partially-inline-libcalls -loop-predication -loop-interchange -loop-vectorize -pgo-memop-opt -adce -loop-sink -scalarizer -called-value-propagation -lower-constant-intrinsics -loop-unswitch -gvn -globalopt -sink -loop-idiom -pgo-memop-opt -loop-sink -flattencfg -rpo-functionattrs -loop-simplify -loop-idiom -loop-versioning-licm -load-store-vectorizer -coro-early -inferattrs -loop-versioning-licm -die -redundant-dbg-inst-elim -float2int -libcalls-shrinkwrap -loop-reduce -simplifycfg -deadargelim -slp-vectorizer -canonicalize-aliases -name-anon-globals -mldst-motion -rewrite-statepoints-for-gc -aggressive-instcombine -lower-matrix-intrinsics -inferattrs -loop-reduce -redundant-dbg-inst-elim -loop-load-elim -simplifycfg -alignment-from-assumptions -mergereturn -irce -coro-early -forceattrs -slsr -lower-widenable-condition -irce -div-rem-pairs -barrier -gvn -tailcallelim -globaldce -ipconstprop -instcombine -mldst-motion -simple-loop-unswitch -jump-threading -globalopt -globalopt -rewrite-statepoints-for-gc -scalarizer -simple-loop-unswitch -nary-reassociate -loop-distribute -loop-predication -coro-early -lower-widenable-condition -lower-widenable-condition -loop-fusion -loop-rotate -loop-load-elim -lower-expect -mldst-motion -slp-vectorizer -break-crit-edges -guard-widening -coro-early -inferattrs -newgvn -rewrite-statepoints-for-gc -licm -slp-vectorizer -gvn -strip-dead-prototypes -simplifycfg -sink -reassociate -loop-reduce -mem2reg -early-cse-memssa -loop-load-elim -sroa -add-discriminators -indvars -alignment-from-assumptions -attributor -separate-const-offset-from-gep -ee-instrument -lower-widenable-condition -globalopt -loop-sink -pgo-memop-opt -called-value-propagation -sccp -hotcoldsplit -loop-load-elim -mergereturn -pgo-memop-opt -instcombine -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/ghostscript,0.9960224143507793,278.31543612480164,opt -reassociate -loop-deletion -dse -coro-cleanup -reg2mem -loop-predication -ipconstprop -cross-dso-cfi -loop-unroll -dce -lower-matrix-intrinsics -bdce -lcssa -loop-unswitch -deadargelim -coro-early -always-inline -memcpyopt -loop-idiom -barrier -dce -add-discriminators -loop-reduce -bdce -sccp -lower-matrix-intrinsics -globalopt -consthoist -sroa -sink -reassociate -aggressive-instcombine -insert-gcov-profiling -jump-threading -coro-elide -div-rem-pairs -strip-dead-prototypes -elim-avail-extern -loop-interchange -float2int -coro-early -loop-distribute -licm -coro-elide -deadargelim -licm -load-store-vectorizer -hotcoldsplit -attributor -div-rem-pairs -called-value-propagation -loop-rotate -globalsplit -instcombine -slsr -strip-nondebug -coro-elide -prune-eh -argpromotion -instsimplify -loop-simplifycfg -callsite-splitting -guard-widening -attributor -loop-interchange -loweratomic -loop-reroll -loop-idiom -coro-cleanup -sccp -libcalls-shrinkwrap -globalsplit -sccp -jump-threading -mergefunc -simplifycfg -mergeicmps -nary-reassociate -lower-guard-intrinsic -lcssa -cross-dso-cfi -early-cse-memssa -infer-address-spaces -bdce -slp-vectorizer input.bc -o output.bc -benchmark://cBench-v1/ghostscript,1.0014642760357022,562.3493282794952,opt -jump-threading -flattencfg -mergereturn -die -sroa -loop-predication -reassociate -loop-instsimplify -gvn -flattencfg -bdce -simplifycfg -insert-gcov-profiling -loweratomic -lowerinvoke -loop-guard-widening -loop-idiom -called-value-propagation -coro-cleanup -tailcallelim -partially-inline-libcalls -ipconstprop -elim-avail-extern -hotcoldsplit -loop-idiom -mergereturn -attributor -loop-sink -die -licm -lower-constant-intrinsics -alignment-from-assumptions -instsimplify -canonicalize-aliases -loop-versioning -loop-versioning-licm -loop-distribute -reassociate -coro-cleanup -lower-guard-intrinsic -loop-data-prefetch -mldst-motion -adce -callsite-splitting -tailcallelim -loop-idiom -coro-split -functionattrs -mldst-motion -flattencfg -deadargelim -rpo-functionattrs -lowerswitch -loop-simplify -reg2mem -dse -cross-dso-cfi -gvn-hoist -gvn-hoist -memcpyopt -libcalls-shrinkwrap -hotcoldsplit -loop-reroll -coro-cleanup -aggressive-instcombine -gvn-hoist -loop-idiom -slp-vectorizer -redundant-dbg-inst-elim -globalsplit -loop-unroll -loop-idiom -loop-instsimplify -loop-data-prefetch -ipconstprop -sccp -loop-instsimplify -post-inline-ee-instrument -sroa -loop-simplify -loop-simplify -irce -simplifycfg -lcssa -loop-fusion -ipsccp -loop-versioning-licm -partially-inline-libcalls -partially-inline-libcalls -argpromotion -float2int -newgvn -div-rem-pairs -instnamer -coro-split -lcssa -lower-widenable-condition -indvars -jump-threading -scalarizer -float2int -loop-instsimplify -correlated-propagation -barrier -hotcoldsplit -load-store-vectorizer -instcombine -irce -elim-avail-extern -loop-versioning-licm -correlated-propagation -redundant-dbg-inst-elim -coro-split -sancov -instcombine -constmerge -float2int -globaldce -die -redundant-dbg-inst-elim -lower-matrix-intrinsics -argpromotion -lower-constant-intrinsics -loop-fusion -div-rem-pairs -insert-gcov-profiling -insert-gcov-profiling -strip-debug-declare -loop-deletion -cross-dso-cfi -loop-unroll-and-jam -gvn -ipconstprop -loop-versioning -loop-interchange -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/ghostscript,1.0049654256016645,283.5457594394684,opt -lowerinvoke -scalarizer -adce -coro-split -early-cse-memssa -post-inline-ee-instrument -flattencfg -loop-instsimplify -loweratomic -memcpyopt -elim-avail-extern -sroa -loop-fusion -loop-sink -sancov -speculative-execution -die -newgvn -mergefunc -loop-data-prefetch -jump-threading -loop-predication -coro-elide -coro-split -redundant-dbg-inst-elim -mem2reg -redundant-dbg-inst-elim -loop-reduce -coro-elide -jump-threading -sancov -dce -constmerge -nary-reassociate -attributor -instnamer -lower-expect -alignment-from-assumptions -loop-simplify -simple-loop-unswitch -sccp -instcombine -canonicalize-aliases -loop-versioning -simplifycfg -slsr -loop-distribute -instcombine -loop-simplify -loop-guard-widening -insert-gcov-profiling -jump-threading -prune-eh -constmerge -infer-address-spaces -ee-instrument -loop-load-elim -div-rem-pairs -lower-constant-intrinsics -sccp -coro-split -mem2reg -lcssa -jump-threading -load-store-vectorizer -early-cse-memssa -strip-dead-prototypes -dse -consthoist -irce -add-discriminators -lowerinvoke -loop-fusion -tailcallelim -loop-interchange -sroa -mem2reg -adce -guard-widening -partially-inline-libcalls -loop-fusion -lower-guard-intrinsic -add-discriminators -post-inline-ee-instrument -slp-vectorizer -partially-inline-libcalls -rpo-functionattrs -cross-dso-cfi -strip -lower-matrix-intrinsics -separate-const-offset-from-gep -gvn-hoist -lower-widenable-condition -instcombine input.bc -o output.bc -benchmark://cBench-v1/gsm,1.0170567729083666,23.498672485351562,opt -licm -inline -attributor -loop-load-elim -globalsplit -forceattrs -gvn -coro-early -add-discriminators -coro-early -early-cse-memssa -loop-unroll -argpromotion -libcalls-shrinkwrap -dse -div-rem-pairs -jump-threading -loop-deletion -lower-expect -coro-cleanup -aggressive-instcombine -mldst-motion -nary-reassociate -dce -sroa -instnamer -loop-reduce -guard-widening -post-inline-ee-instrument -guard-widening -loop-unroll-and-jam -loop-idiom -globalopt -irce -lowerinvoke -cross-dso-cfi -hotcoldsplit -lowerinvoke -speculative-execution -loop-predication -strip -deadargelim -functionattrs -deadargelim -speculative-execution -instcombine -called-value-propagation -simplifycfg -loop-reroll -float2int -deadargelim -dse -dce -flattencfg -bdce -gvn -mem2reg -lower-matrix-intrinsics -forceattrs -callsite-splitting -loop-predication -inject-tli-mappings -strip-debug-declare -coro-early -lower-widenable-condition -gvn -load-store-vectorizer -loop-simplifycfg -forceattrs -deadargelim -called-value-propagation -canonicalize-aliases -prune-eh -argpromotion -loop-deletion -simplifycfg -indvars -dce -inferattrs -loop-simplify -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/gsm,1.0220368525896417,15.433346271514893,opt -constmerge -break-crit-edges -inline -mergefunc -loop-reduce -lower-expect -ipconstprop -guard-widening -break-crit-edges -adce -indvars -loop-predication -simplifycfg -mergefunc -memcpyopt -insert-gcov-profiling -separate-const-offset-from-gep -functionattrs -bdce -float2int -tailcallelim -partial-inliner -lower-matrix-intrinsics -loop-unswitch -mem2reg -strip -name-anon-globals -instcombine -redundant-dbg-inst-elim -instnamer -loop-deletion -prune-eh -called-value-propagation -simple-loop-unswitch -strip -loop-unswitch -lower-constant-intrinsics -pgo-memop-opt -consthoist -loweratomic -lower-widenable-condition -loop-versioning -loop-unroll-and-jam -strip-dead-prototypes -loop-instsimplify -gvn-hoist -rewrite-statepoints-for-gc -early-cse-memssa -lowerinvoke -licm -instsimplify -add-discriminators -slsr -lower-matrix-intrinsics -inferattrs -globalsplit -ipconstprop -instcombine -loop-load-elim -hotcoldsplit -correlated-propagation -dce -insert-gcov-profiling -rewrite-statepoints-for-gc -irce -loop-sink -inject-tli-mappings -lower-widenable-condition -strip-nondebug -always-inline -loop-data-prefetch -loop-data-prefetch -name-anon-globals -strip -dce -loop-interchange -constmerge -loop-instsimplify -infer-address-spaces -cross-dso-cfi -licm -irce -barrier -coro-cleanup -add-discriminators -loop-simplify -coro-elide -rewrite-statepoints-for-gc -reg2mem -adce -loop-data-prefetch -break-crit-edges -infer-address-spaces -licm -loop-predication -ipconstprop -dce -sroa -adce -strip -lower-widenable-condition -loop-rotate -lcssa -mergefunc -pgo-memop-opt -sancov -loop-rotate -consthoist -aggressive-instcombine -loop-distribute -strip -loop-distribute -pgo-memop-opt -loweratomic -sancov -irce -lower-expect -adce -loop-idiom -irce -die -gvn -loop-instsimplify -loop-unroll-and-jam -indvars -functionattrs -slsr -mldst-motion -dce -ipconstprop -inject-tli-mappings -correlated-propagation -reg2mem -loop-idiom -loop-interchange -sancov -sancov -argpromotion -globalsplit -memcpyopt -rpo-functionattrs -loop-guard-widening -lower-guard-intrinsic -loop-unroll-and-jam -insert-gcov-profiling -attributor -libcalls-shrinkwrap -slsr -loop-idiom -redundant-dbg-inst-elim -die -cross-dso-cfi -argpromotion -load-store-vectorizer -gvn-hoist -loop-unroll -reassociate -rpo-functionattrs -loop-fusion -loop-reroll -lowerswitch -mergereturn -loop-deletion -add-discriminators -correlated-propagation -lower-guard-intrinsic -strip-nondebug -coro-cleanup -loop-data-prefetch -insert-gcov-profiling -loop-unroll -guard-widening -sroa -simplifycfg -constprop -die -load-store-vectorizer -separate-const-offset-from-gep -tailcallelim -loop-deletion -always-inline -float2int -coro-cleanup -libcalls-shrinkwrap -sroa -elim-avail-extern -libcalls-shrinkwrap -separate-const-offset-from-gep -lower-guard-intrinsic -canonicalize-aliases -slp-vectorizer input.bc -o output.bc -benchmark://cBench-v1/gsm,1.027390438247013,14.184420108795166,opt -newgvn -lower-constant-intrinsics -inline -constprop -functionattrs -inferattrs -inject-tli-mappings -reg2mem -die -sroa -loop-idiom -loop-unroll-and-jam -lcssa -loop-deletion -loop-load-elim -constmerge -mergeicmps -strip-debug-declare -consthoist -inject-tli-mappings -dce -cross-dso-cfi -instcombine -mergereturn -libcalls-shrinkwrap -redundant-dbg-inst-elim -simplifycfg -constprop -aggressive-instcombine -loop-guard-widening -dce -correlated-propagation -gvn -always-inline -guard-widening -hotcoldsplit -add-discriminators -mldst-motion -globalopt -instsimplify -attributor -prune-eh -mem2reg -guard-widening -argpromotion -consthoist -sccp -always-inline -loop-unroll-and-jam -memcpyopt -infer-address-spaces -lcssa -ee-instrument -lower-widenable-condition -speculative-execution -canonicalize-aliases -lower-expect -guard-widening -reassociate -argpromotion -libcalls-shrinkwrap -loop-versioning-licm -instcombine -loop-interchange -gvn -reassociate -globaldce -div-rem-pairs -early-cse-memssa -instsimplify -tailcallelim -loop-versioning-licm -mldst-motion -alignment-from-assumptions -sancov -loop-instsimplify -speculative-execution -loop-simplify -lcssa -gvn -gvn-hoist -memcpyopt -loop-versioning-licm -inject-tli-mappings -partial-inliner -slsr -mem2reg -always-inline -name-anon-globals -rpo-functionattrs -callsite-splitting -loop-reroll -loop-idiom -strip -sink -gvn -strip-nondebug -loop-guard-widening -loop-distribute -early-cse-memssa -newgvn -correlated-propagation -mem2reg -instcombine -loop-data-prefetch -dce -lowerswitch -loop-versioning-licm -loop-vectorize -mergefunc -sroa -loop-idiom -loop-interchange -speculative-execution -loop-deletion -loop-vectorize -add-discriminators -loop-unroll-and-jam -instnamer -gvn -instsimplify -mergefunc -div-rem-pairs -instsimplify -nary-reassociate -add-discriminators -dce -constprop -gvn-hoist -loop-simplify -loop-unroll-and-jam -lower-guard-intrinsic -name-anon-globals -sroa -lowerswitch -strip-debug-declare -deadargelim -memcpyopt -die -separate-const-offset-from-gep -early-cse-memssa -post-inline-ee-instrument -rewrite-statepoints-for-gc -mergereturn -coro-split -instcombine -guard-widening -prune-eh -nary-reassociate -mldst-motion -ee-instrument -slp-vectorizer -loop-instsimplify -infer-address-spaces -post-inline-ee-instrument -redundant-dbg-inst-elim -loop-interchange -libcalls-shrinkwrap -coro-early -loop-reduce -irce -indvars -loop-interchange -early-cse-memssa -adce -prune-eh -load-store-vectorizer -indvars -coro-split -inject-tli-mappings -mldst-motion -adce -slp-vectorizer -loop-simplify -loweratomic -dce -called-value-propagation -instnamer -float2int -bdce -simple-loop-unswitch -ipsccp input.bc -o output.bc -benchmark://cBench-v1/gsm,1.0277639442231072,15.189532041549683,opt -argpromotion -mldst-motion -globaldce -globaldce -alignment-from-assumptions -sink -lower-widenable-condition -argpromotion -loop-versioning -lcssa -instcombine -argpromotion -loop-predication -loop-distribute -tailcallelim -lower-matrix-intrinsics -redundant-dbg-inst-elim -ipsccp -deadargelim -loweratomic -loop-unroll-and-jam -loop-rotate -loop-vectorize -reassociate -add-discriminators -loop-versioning -loop-versioning -slsr -inferattrs -instnamer -strip-debug-declare -aggressive-instcombine -coro-split -mergereturn -loop-sink -add-discriminators -bdce -ipsccp -forceattrs -globalopt -strip-dead-prototypes -inject-tli-mappings -early-cse-memssa -lower-widenable-condition -canonicalize-aliases -lower-matrix-intrinsics -sroa -slp-vectorizer -insert-gcov-profiling -mem2reg -mergeicmps -redundant-dbg-inst-elim -add-discriminators -reg2mem -strip-debug-declare -lower-expect -loop-deletion -redundant-dbg-inst-elim -break-crit-edges -ipsccp -redundant-dbg-inst-elim -jump-threading -mergereturn -coro-early -loop-fusion -indvars -float2int -strip-dead-prototypes -bdce -loop-versioning -attributor -inline -loop-instsimplify -mldst-motion -called-value-propagation -die -lower-guard-intrinsic -globalsplit -scalarizer -barrier -loop-fusion -inferattrs -instcombine -sroa -strip-dead-prototypes -reassociate -lower-widenable-condition -mergereturn -loop-interchange -loop-sink -newgvn -speculative-execution -reg2mem -aggressive-instcombine -argpromotion -loop-idiom -inferattrs -elim-avail-extern -load-store-vectorizer -dse -inject-tli-mappings -loop-reroll -rewrite-statepoints-for-gc -irce -coro-split -dse -instcombine -irce -inline -loop-distribute -elim-avail-extern -loop-versioning -load-store-vectorizer -always-inline -ipconstprop -called-value-propagation -strip-dead-prototypes -rpo-functionattrs -loop-load-elim -constmerge -partially-inline-libcalls -loop-unswitch -pgo-memop-opt -sroa -lower-matrix-intrinsics -loop-simplify -bdce -bdce -name-anon-globals -mem2reg -break-crit-edges -lower-guard-intrinsic -loop-fusion -rpo-functionattrs -strip-nondebug -sroa -sink -instsimplify -loop-guard-widening -coro-cleanup -speculative-execution -alignment-from-assumptions -simplifycfg -instsimplify -argpromotion -constprop -consthoist -memcpyopt -ipsccp -coro-elide -dse -lowerinvoke -sroa -lower-guard-intrinsic -slp-vectorizer -argpromotion -alignment-from-assumptions -elim-avail-extern -coro-cleanup -constprop -constprop -alignment-from-assumptions -loop-unswitch -sccp -speculative-execution -post-inline-ee-instrument -lower-expect -lower-expect -instsimplify -lower-constant-intrinsics -lower-constant-intrinsics -mldst-motion -simplifycfg -loop-simplify -sancov -loop-distribute -strip-dead-prototypes -load-store-vectorizer -consthoist -called-value-propagation -post-inline-ee-instrument -mergereturn -memcpyopt -irce -strip-dead-prototypes -lower-guard-intrinsic -strip-dead-prototypes -div-rem-pairs -strip-debug-declare -alignment-from-assumptions -loop-idiom -lower-guard-intrinsic -loop-idiom -aggressive-instcombine -infer-address-spaces -loop-sink -hotcoldsplit -coro-split -lower-widenable-condition -loop-instsimplify -newgvn -argpromotion -partial-inliner -early-cse-memssa -pgo-memop-opt -reg2mem -die -loop-versioning-licm -post-inline-ee-instrument -argpromotion -tailcallelim -loop-unroll-and-jam -jump-threading -rewrite-statepoints-for-gc -guard-widening -instnamer -inferattrs -nary-reassociate -sroa -argpromotion -deadargelim -early-cse-memssa -redundant-dbg-inst-elim -functionattrs -ee-instrument -ipconstprop -ee-instrument -dse -post-inline-ee-instrument -tailcallelim -reg2mem -loop-fusion -sccp -die -sroa -loop-deletion -functionattrs -sccp -rpo-functionattrs -coro-early -constprop -loop-simplify -instcombine -ipconstprop -loop-vectorize -mergeicmps -sroa -loweratomic -globalsplit -libcalls-shrinkwrap -always-inline -alignment-from-assumptions -speculative-execution -rpo-functionattrs -dce -globaldce -libcalls-shrinkwrap -sroa -constmerge -lower-expect -ipsccp -loop-versioning-licm -insert-gcov-profiling -always-inline -dce -lower-matrix-intrinsics -loop-reroll -slp-vectorizer -mldst-motion -div-rem-pairs -gvn-hoist -mldst-motion -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/gsm,1.028261952191235,14.138127088546753,opt -add-discriminators -lower-matrix-intrinsics -coro-elide -loop-guard-widening -alignment-from-assumptions -canonicalize-aliases -dse -constprop -loop-data-prefetch -always-inline -loop-simplify -ee-instrument -loop-simplifycfg -ipconstprop -separate-const-offset-from-gep -loop-interchange -inject-tli-mappings -reassociate -loop-unroll -ipsccp -inferattrs -gvn-hoist -ipconstprop -mergeicmps -mldst-motion -indvars -inject-tli-mappings -early-cse-memssa -simple-loop-unswitch -early-cse-memssa -float2int -loop-vectorize -loop-simplify -ipconstprop -loop-reduce -indvars -loop-instsimplify -aggressive-instcombine -slsr -inject-tli-mappings -sroa -slp-vectorizer -flattencfg -gvn -attributor -loop-guard-widening -separate-const-offset-from-gep -newgvn -float2int -sancov -ee-instrument -called-value-propagation -instsimplify -coro-split -functionattrs -insert-gcov-profiling -separate-const-offset-from-gep -div-rem-pairs -loop-load-elim -tailcallelim -irce -simple-loop-unswitch -memcpyopt -slsr -loop-unroll -instcombine -name-anon-globals -early-cse-memssa -argpromotion -deadargelim -loop-deletion -lower-guard-intrinsic -separate-const-offset-from-gep -jump-threading -inject-tli-mappings -adce -mem2reg -called-value-propagation -gvn-hoist -nary-reassociate -attributor -loop-fusion -post-inline-ee-instrument -dse -adce -redundant-dbg-inst-elim -insert-gcov-profiling -break-crit-edges -post-inline-ee-instrument -lcssa -slsr -ee-instrument -gvn -bdce -lowerinvoke -sink -inferattrs -instcombine -add-discriminators -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/gsm,1.0292579681274896,14.405534267425537,opt -deadargelim -insert-gcov-profiling -loweratomic -inferattrs -bdce -forceattrs -lower-constant-intrinsics -instcombine -callsite-splitting -prune-eh -lower-expect -speculative-execution -ipsccp -strip-debug-declare -loop-idiom -loop-unswitch -rpo-functionattrs -loop-fusion -redundant-dbg-inst-elim -loop-reduce -libcalls-shrinkwrap -newgvn -flattencfg -loop-instsimplify -rpo-functionattrs -early-cse-memssa -loop-guard-widening -prune-eh -instnamer -coro-early -loop-versioning-licm -forceattrs -dse -add-discriminators -lcssa -flattencfg -called-value-propagation -loop-data-prefetch -loop-unroll-and-jam -instnamer -loop-idiom -globalopt -lower-matrix-intrinsics -cross-dso-cfi -loop-unroll-and-jam -gvn -ee-instrument -speculative-execution -loop-unroll-and-jam -slsr -loop-load-elim -cross-dso-cfi -div-rem-pairs -loop-interchange -sroa -instsimplify -loop-deletion -libcalls-shrinkwrap -dse -loop-distribute -adce -instnamer -insert-gcov-profiling -mergereturn -cross-dso-cfi -loweratomic -mergeicmps -ipconstprop -always-inline -instsimplify -loop-reduce -functionattrs -lower-guard-intrinsic -loop-data-prefetch -mem2reg -jump-threading -loop-simplify -ipsccp -reassociate -separate-const-offset-from-gep -licm -simplifycfg -jump-threading -loop-idiom -loop-deletion -callsite-splitting -instcombine -lower-constant-intrinsics -ipsccp -strip-dead-prototypes -constprop -ipconstprop -partial-inliner -flattencfg -lower-expect -load-store-vectorizer -sancov -loop-simplify -ipconstprop -globalsplit -lower-widenable-condition -flattencfg -irce -instcombine -loweratomic -strip-dead-prototypes -flattencfg -dse -gvn-hoist -mem2reg -rewrite-statepoints-for-gc -ee-instrument -partially-inline-libcalls -gvn -break-crit-edges -rpo-functionattrs -name-anon-globals -coro-early -scalarizer -dse -loop-simplify -always-inline -always-inline -lcssa -bdce -always-inline -loop-interchange -slsr -elim-avail-extern -instnamer -nary-reassociate -forceattrs -name-anon-globals -constprop -correlated-propagation -sccp -aggressive-instcombine -redundant-dbg-inst-elim -reg2mem -loop-versioning-licm -break-crit-edges -ipsccp -inject-tli-mappings -elim-avail-extern -mergefunc -libcalls-shrinkwrap -speculative-execution -alignment-from-assumptions -coro-elide -strip-dead-prototypes -insert-gcov-profiling -lower-guard-intrinsic -infer-address-spaces -coro-split -lower-matrix-intrinsics -insert-gcov-profiling -alignment-from-assumptions -lower-matrix-intrinsics -break-crit-edges -rewrite-statepoints-for-gc -strip-dead-prototypes -globaldce -dse -loop-data-prefetch -reg2mem -ipconstprop -partially-inline-libcalls -indvars -argpromotion -argpromotion -constprop -attributor -strip-nondebug -strip -lower-expect -libcalls-shrinkwrap -guard-widening -loop-sink -simple-loop-unswitch -slsr -separate-const-offset-from-gep -loweratomic -coro-elide -rewrite-statepoints-for-gc -loop-versioning -loop-data-prefetch -reg2mem -loop-fusion -inline -infer-address-spaces -loop-sink -memcpyopt -strip -gvn -instcombine -loop-load-elim -instnamer -strip-dead-prototypes -adce -lower-matrix-intrinsics -loop-guard-widening -lower-matrix-intrinsics -partially-inline-libcalls -tailcallelim -correlated-propagation -aggressive-instcombine -deadargelim -loop-interchange -globalsplit -strip-nondebug -aggressive-instcombine -mem2reg -globalopt -dse -correlated-propagation -dce -mergeicmps -instsimplify -forceattrs -callsite-splitting -scalarizer -redundant-dbg-inst-elim -called-value-propagation -name-anon-globals -separate-const-offset-from-gep -loop-versioning -loop-sink -loop-simplify -add-discriminators -ee-instrument -loop-versioning -lower-widenable-condition -instnamer -slp-vectorizer -loop-load-elim -loop-unroll -loop-versioning-licm -loop-distribute -sancov -loop-predication -name-anon-globals -loop-guard-widening -bdce -guard-widening -instsimplify -constprop -loop-vectorize -canonicalize-aliases -prune-eh -coro-early -loop-versioning-licm -loop-interchange -loop-guard-widening -loop-load-elim -infer-address-spaces -libcalls-shrinkwrap -globalopt -loop-reroll -name-anon-globals -lowerswitch -simplifycfg -adce -gvn -ipsccp -strip -forceattrs -instcombine -sccp -loop-simplifycfg -dce -tailcallelim -loop-data-prefetch -gvn -slsr -mergereturn -strip-debug-declare -alignment-from-assumptions -globaldce -lcssa -loop-vectorize -loop-load-elim -sccp -loop-data-prefetch -dse -loop-vectorize -loop-fusion -loop-data-prefetch -globalsplit -gvn-hoist -loop-versioning-licm -loop-interchange -mergefunc -deadargelim -memcpyopt -rpo-functionattrs -aggressive-instcombine -lower-guard-intrinsic -load-store-vectorizer -loop-load-elim -rewrite-statepoints-for-gc -load-store-vectorizer -aggressive-instcombine -die -lower-expect -mergefunc -strip-dead-prototypes -attributor -insert-gcov-profiling -loop-versioning-licm -float2int -infer-address-spaces -loop-instsimplify -slsr -loop-versioning -globalsplit -lcssa -ipconstprop -partially-inline-libcalls -alignment-from-assumptions -lower-guard-intrinsic -coro-elide -loop-sink -called-value-propagation -forceattrs -partial-inliner -loop-rotate input.bc -o output.bc -benchmark://cBench-v1/gsm,1.0334910358565736,14.459441900253296,opt -hotcoldsplit -scalarizer -instsimplify -loop-instsimplify -coro-split -aggressive-instcombine -loop-idiom -loop-predication -instsimplify -partially-inline-libcalls -canonicalize-aliases -inferattrs -loop-simplify -correlated-propagation -simple-loop-unswitch -bdce -coro-split -sccp -float2int -simplifycfg -mldst-motion -loop-simplify -float2int -sroa -globaldce -instnamer -slp-vectorizer -loop-vectorize -simple-loop-unswitch -guard-widening -coro-early -div-rem-pairs -loop-simplifycfg -lower-widenable-condition -attributor -newgvn -loop-interchange -globalsplit -lowerinvoke -canonicalize-aliases -dse -reassociate -div-rem-pairs -mldst-motion -mldst-motion -canonicalize-aliases -lower-widenable-condition -loop-interchange -sancov -infer-address-spaces -infer-address-spaces -loweratomic -tailcallelim -loop-load-elim -loop-simplify -mergefunc -alignment-from-assumptions -mergefunc -speculative-execution -aggressive-instcombine -loop-reroll -ee-instrument -bdce -float2int -gvn-hoist -argpromotion -coro-split -newgvn -slsr -ipconstprop -globalsplit -dse -jump-threading -instsimplify -newgvn -ee-instrument -gvn-hoist -gvn-hoist -loop-predication -post-inline-ee-instrument -instcombine -dse input.bc -o output.bc -benchmark://cBench-v1/gsm,1.0352340637450197,15.297012329101562,opt -insert-gcov-profiling -lower-matrix-intrinsics -loop-instsimplify -gvn -memcpyopt -lower-guard-intrinsic -called-value-propagation -loop-predication -lower-guard-intrinsic -loop-simplify -called-value-propagation -slp-vectorizer -lower-constant-intrinsics -speculative-execution -barrier -loop-sink -name-anon-globals -gvn-hoist -deadargelim -lowerinvoke -deadargelim -loop-instsimplify -loop-instsimplify -guard-widening -strip-debug-declare -hotcoldsplit -adce -attributor -die -insert-gcov-profiling -infer-address-spaces -die -loop-versioning -loop-interchange -slsr -instnamer -correlated-propagation -coro-elide -lower-guard-intrinsic -lowerswitch -loop-unroll -libcalls-shrinkwrap -loop-predication -loop-idiom -simplifycfg -early-cse-memssa -loop-reroll -lower-expect -break-crit-edges -loop-load-elim -gvn-hoist -ipsccp -sancov -loop-unswitch -canonicalize-aliases -early-cse-memssa -inferattrs -strip-nondebug -newgvn -early-cse-memssa -guard-widening -loop-unswitch -mergefunc -callsite-splitting -correlated-propagation -hotcoldsplit -gvn-hoist -globaldce -loop-interchange -instnamer -newgvn -mergereturn -lowerswitch -cross-dso-cfi -always-inline -pgo-memop-opt -flattencfg -loop-interchange -mem2reg -mergeicmps -loop-versioning-licm -consthoist -loop-simplify -irce -inferattrs -mergeicmps -early-cse-memssa -coro-elide -loop-unroll -speculative-execution -coro-elide -lower-guard-intrinsic -simple-loop-unswitch -redundant-dbg-inst-elim -globaldce -insert-gcov-profiling -loop-versioning-licm -instnamer -adce -gvn -loop-fusion -loop-deletion -lower-expect -adce -jump-threading -loop-interchange -instsimplify -insert-gcov-profiling -inferattrs -mergereturn -inferattrs -add-discriminators -coro-split -irce -newgvn -separate-const-offset-from-gep -dse -coro-elide -memcpyopt -loop-idiom -lower-guard-intrinsic -strip -irce -globalopt -loop-versioning -barrier -early-cse-memssa -gvn-hoist -strip -tailcallelim -sccp -lower-matrix-intrinsics -lower-guard-intrinsic -callsite-splitting -indvars -consthoist -early-cse-memssa -loop-guard-widening -speculative-execution -argpromotion -strip -insert-gcov-profiling -post-inline-ee-instrument -loop-unroll-and-jam -slsr -newgvn -prune-eh -argpromotion -constmerge -speculative-execution -redundant-dbg-inst-elim -loop-instsimplify -loop-reroll -instcombine -coro-early -lower-expect -post-inline-ee-instrument -loop-distribute -slp-vectorizer -pgo-memop-opt -loop-predication -slp-vectorizer -simplifycfg -forceattrs -coro-split -lower-guard-intrinsic -instsimplify -sink -coro-early -early-cse-memssa -aggressive-instcombine -jump-threading -separate-const-offset-from-gep -mem2reg -rewrite-statepoints-for-gc -sccp -slp-vectorizer -loop-reroll -coro-elide -cross-dso-cfi -gvn-hoist -jump-threading -coro-split -loop-versioning-licm -constprop -gvn -indvars -loop-sink -prune-eh -mergeicmps -tailcallelim -indvars -elim-avail-extern -lower-guard-intrinsic -instcombine input.bc -o output.bc -benchmark://cBench-v1/gsm,1.048057768924303,16.46152639389038,opt -coro-split -lower-matrix-intrinsics -add-discriminators -mergeicmps -lower-constant-intrinsics -loop-unroll-and-jam -redundant-dbg-inst-elim -inject-tli-mappings -barrier -argpromotion -barrier -canonicalize-aliases -separate-const-offset-from-gep -mem2reg -loop-data-prefetch -loop-guard-widening -simplifycfg -consthoist -loop-idiom -deadargelim -loop-sink -lower-expect -lower-constant-intrinsics -reassociate -instcombine -newgvn -globaldce -lowerinvoke -mergefunc -loop-instsimplify -strip-nondebug -prune-eh -constprop -dse -sancov -loop-unroll-and-jam -float2int -canonicalize-aliases -barrier -constprop -loop-fusion -slp-vectorizer -loop-simplifycfg -name-anon-globals -strip-nondebug -strip -sancov -flattencfg -correlated-propagation -redundant-dbg-inst-elim -sroa -strip-dead-prototypes -lowerswitch -callsite-splitting -post-inline-ee-instrument -newgvn -loop-versioning -dce -prune-eh -globalsplit -loop-unroll-and-jam -cross-dso-cfi -die -sink -adce -redundant-dbg-inst-elim -barrier -dse -memcpyopt -loop-data-prefetch -loop-unswitch -gvn -loop-fusion -sancov -slp-vectorizer -loweratomic -break-crit-edges -indvars -sink -loop-fusion -loop-predication -mergeicmps -aggressive-instcombine -loop-versioning-licm -barrier -add-discriminators -guard-widening -early-cse-memssa -early-cse-memssa -strip-dead-prototypes -pgo-memop-opt -lowerswitch -add-discriminators -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/gsm,1.050921314741036,13.954805850982666,opt -newgvn -loop-instsimplify -mergereturn -memcpyopt -loop-reduce -sroa -elim-avail-extern -lower-guard-intrinsic -guard-widening -dce -loop-vectorize -reassociate -argpromotion -loop-instsimplify -loop-instsimplify -coro-early -instcombine -lower-widenable-condition -attributor -always-inline -name-anon-globals -indvars -always-inline -globalopt -lowerswitch -inferattrs -loop-simplify -ipconstprop -speculative-execution -globalsplit -sancov -gvn-hoist -called-value-propagation -mldst-motion -dse -loop-data-prefetch -inferattrs -lower-guard-intrinsic -loop-reroll -early-cse-memssa -called-value-propagation -separate-const-offset-from-gep -sink -strip-nondebug -ipconstprop -lower-matrix-intrinsics -loop-fusion -loop-versioning-licm -aggressive-instcombine -prune-eh -loop-sink -guard-widening -jump-threading -lower-matrix-intrinsics -mergefunc -loop-guard-widening -lower-widenable-condition -loop-simplifycfg -newgvn -mem2reg -lcssa -loop-interchange -functionattrs -loop-unroll-and-jam -coro-cleanup -break-crit-edges -lower-matrix-intrinsics -name-anon-globals -tailcallelim -loop-simplify -bdce -redundant-dbg-inst-elim -inferattrs -hotcoldsplit -simplifycfg -ipsccp -ipsccp -float2int -loop-sink -functionattrs -licm -div-rem-pairs -alignment-from-assumptions -div-rem-pairs -deadargelim -rewrite-statepoints-for-gc -loop-unswitch -loop-guard-widening -cross-dso-cfi -instnamer -hotcoldsplit -consthoist -lowerinvoke -functionattrs -lower-guard-intrinsic -aggressive-instcombine -nary-reassociate -lower-constant-intrinsics -canonicalize-aliases -loop-predication -bdce -gvn -infer-address-spaces -slp-vectorizer -gvn -lower-matrix-intrinsics -reassociate -nary-reassociate -attributor -mergefunc -loop-idiom -loop-simplifycfg -lower-matrix-intrinsics -reassociate -lower-matrix-intrinsics -loop-distribute -instcombine input.bc -o output.bc -benchmark://cBench-v1/ispell,0.9370865587614357,15.787727355957031,opt -lcssa -simplifycfg -loop-load-elim -slsr -libcalls-shrinkwrap -globalopt -simplifycfg -loop-instsimplify -adce -simplifycfg -strip-dead-prototypes -hotcoldsplit -dce -aggressive-instcombine -loop-unroll-and-jam -loop-data-prefetch -ipconstprop -functionattrs -coro-early -loop-unroll -lower-matrix-intrinsics -loop-simplify -pgo-memop-opt -bdce -name-anon-globals -loop-load-elim -lower-matrix-intrinsics -coro-cleanup -prune-eh -correlated-propagation -strip-debug-declare -coro-early -jump-threading -cross-dso-cfi -sroa -loweratomic -insert-gcov-profiling -post-inline-ee-instrument -partial-inliner -prune-eh -loop-load-elim -add-discriminators -inject-tli-mappings -lower-widenable-condition -coro-split -deadargelim -prune-eh -loop-unroll -rewrite-statepoints-for-gc -inject-tli-mappings -sccp -strip-debug-declare -mergereturn -load-store-vectorizer -lower-matrix-intrinsics -instcombine -attributor -loop-simplify -mldst-motion -reassociate -lower-constant-intrinsics -simplifycfg -coro-split -loop-data-prefetch -loweratomic -argpromotion -cross-dso-cfi -canonicalize-aliases -bdce -loop-fusion -tailcallelim -adce -alignment-from-assumptions -callsite-splitting -add-discriminators -barrier -reassociate -newgvn input.bc -o output.bc -benchmark://cBench-v1/ispell,0.9480647431386349,15.543245077133179,opt -coro-elide -dce -mergereturn -slp-vectorizer -gvn-hoist -lowerswitch -mergefunc -lowerinvoke -alignment-from-assumptions -lcssa -loop-reduce -loop-reduce -scalarizer -infer-address-spaces -constprop -partial-inliner -scalarizer -die -mergefunc -strip-debug-declare -loweratomic -prune-eh -early-cse-memssa -jump-threading -globalsplit -flattencfg -loop-vectorize -instsimplify -lower-matrix-intrinsics -callsite-splitting -irce -strip-debug-declare -mergefunc -aggressive-instcombine -deadargelim -gvn-hoist -coro-cleanup -early-cse-memssa -loop-distribute -loop-unswitch -gvn -loop-guard-widening -loop-versioning-licm -mem2reg -globalsplit -cross-dso-cfi -loop-sink -aggressive-instcombine -instcombine -mergefunc -loop-sink -dce -guard-widening -loop-vectorize -lower-guard-intrinsic -loop-sink -name-anon-globals -coro-early -loop-guard-widening -loop-versioning -simplifycfg -libcalls-shrinkwrap -separate-const-offset-from-gep -libcalls-shrinkwrap -loop-versioning -alignment-from-assumptions -loop-versioning -gvn -coro-cleanup -sancov -loweratomic -speculative-execution -loop-versioning -reg2mem -redundant-dbg-inst-elim -loop-sink -loop-sink -strip-nondebug -pgo-memop-opt -coro-split -coro-early -name-anon-globals -consthoist -correlated-propagation -callsite-splitting -guard-widening -loop-guard-widening -guard-widening -barrier -loop-vectorize -add-discriminators -ipsccp -instnamer -coro-early -constprop -infer-address-spaces -add-discriminators -rewrite-statepoints-for-gc -slsr -inferattrs -dce -loweratomic -globaldce -inject-tli-mappings -deadargelim -nary-reassociate -slp-vectorizer -mem2reg -correlated-propagation -constmerge -strip-nondebug -adce -partial-inliner -tailcallelim -ipsccp -mem2reg -aggressive-instcombine -jump-threading -sccp -guard-widening -name-anon-globals -gvn -strip -div-rem-pairs -loop-unroll -globalsplit -partially-inline-libcalls -simplifycfg -correlated-propagation input.bc -o output.bc -benchmark://cBench-v1/ispell,0.9583391977480648,16.2684326171875,opt -jump-threading -loop-reduce -lower-expect -insert-gcov-profiling -add-discriminators -rpo-functionattrs -deadargelim -break-crit-edges -loop-distribute -flattencfg -early-cse-memssa -constmerge -float2int -slp-vectorizer -jump-threading -strip -loop-unroll -strip-nondebug -lower-expect -newgvn -globalsplit -separate-const-offset-from-gep -mem2reg -ipsccp -simplifycfg -sroa -loop-versioning-licm -flattencfg -pgo-memop-opt -float2int -loop-unroll -lower-constant-intrinsics -memcpyopt -deadargelim -libcalls-shrinkwrap -loop-distribute -constprop -loop-simplify -gvn -slsr -sink -canonicalize-aliases -slsr -lower-constant-intrinsics -loop-idiom -indvars -hotcoldsplit -rewrite-statepoints-for-gc -globalopt -loop-simplifycfg -rpo-functionattrs -lower-constant-intrinsics -strip-nondebug -ee-instrument -aggressive-instcombine -lower-guard-intrinsic -loop-reroll -attributor -add-discriminators -instcombine input.bc -o output.bc -benchmark://cBench-v1/ispell,0.9601688951442646,16.670270681381226,opt -globalopt -newgvn -loop-interchange -lower-constant-intrinsics -lower-widenable-condition -strip-nondebug -cross-dso-cfi -slp-vectorizer -canonicalize-aliases -consthoist -gvn -mem2reg -coro-split -sroa -instsimplify -mergefunc -loop-predication -ee-instrument -ee-instrument -gvn-hoist -mem2reg -loop-predication -rewrite-statepoints-for-gc -callsite-splitting -elim-avail-extern -loop-predication -infer-address-spaces -elim-avail-extern -lower-guard-intrinsic -loop-reroll -mem2reg -loop-versioning-licm -mergefunc -loop-fusion -loop-vectorize -licm -always-inline -simplifycfg -loop-versioning -sancov -loop-idiom -lower-guard-intrinsic -loop-distribute -loop-unroll -coro-cleanup -break-crit-edges -coro-early -instcombine -attributor -float2int -sancov -inject-tli-mappings -loop-guard-widening -strip-nondebug -simple-loop-unswitch -loop-distribute -gvn -always-inline -coro-elide -adce -loop-interchange -slsr -libcalls-shrinkwrap -strip-dead-prototypes -partially-inline-libcalls -prune-eh -lower-expect -globalsplit -loop-instsimplify -strip-debug-declare -div-rem-pairs -load-store-vectorizer -ee-instrument -sroa -strip-dead-prototypes -sccp -instnamer -inferattrs -irce -sroa -loop-data-prefetch -lower-expect -redundant-dbg-inst-elim -div-rem-pairs -canonicalize-aliases -inject-tli-mappings -consthoist -loop-unroll -callsite-splitting -barrier -coro-split -cross-dso-cfi -jump-threading input.bc -o output.bc -benchmark://cBench-v1/ispell,0.9607318789584799,15.463008642196655,opt -speculative-execution -barrier -prune-eh -early-cse-memssa -inferattrs -coro-elide -loop-vectorize -ipsccp -rpo-functionattrs -globaldce -loop-versioning-licm -name-anon-globals -called-value-propagation -gvn -reassociate -mem2reg -early-cse-memssa -post-inline-ee-instrument -attributor -div-rem-pairs -irce -sccp -bdce -simplifycfg -gvn-hoist -instcombine input.bc -o output.bc -benchmark://cBench-v1/ispell,0.9653764954257565,16.424754858016968,opt -loop-unroll -speculative-execution -loop-load-elim -newgvn -lower-widenable-condition -insert-gcov-profiling -loop-versioning-licm -indvars -inject-tli-mappings -loop-simplify -die -infer-address-spaces -early-cse-memssa -barrier -loop-guard-widening -reassociate -rewrite-statepoints-for-gc -coro-early -globalopt -scalarizer -ee-instrument -forceattrs -loop-simplify -rpo-functionattrs -loop-load-elim -lower-matrix-intrinsics -constmerge -dce -loop-reduce -jump-threading -correlated-propagation -separate-const-offset-from-gep -loop-instsimplify -lowerinvoke -loop-unroll -rewrite-statepoints-for-gc -constmerge -functionattrs -insert-gcov-profiling -lower-expect -strip -lowerswitch -newgvn -globaldce -instcombine -instsimplify -lowerswitch -lower-matrix-intrinsics -strip-debug-declare -coro-early -mldst-motion -coro-cleanup -sroa -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/ispell,0.9655172413793099,16.854193210601807,opt -loop-distribute -redundant-dbg-inst-elim -elim-avail-extern -sancov -lowerinvoke -mldst-motion -elim-avail-extern -reg2mem -dce -lower-guard-intrinsic -canonicalize-aliases -slsr -lower-expect -always-inline -sink -bdce -dce -loop-deletion -redundant-dbg-inst-elim -called-value-propagation -bdce -globalsplit -lower-constant-intrinsics -ipsccp -inferattrs -speculative-execution -mergeicmps -slsr -nary-reassociate -prune-eh -rewrite-statepoints-for-gc -alignment-from-assumptions -strip -strip-nondebug -sink -sink -sroa -newgvn -rpo-functionattrs -name-anon-globals -loop-interchange -loop-versioning -licm -mldst-motion -functionattrs -add-discriminators -lower-expect -ipconstprop -libcalls-shrinkwrap -called-value-propagation -lowerinvoke -loop-distribute -loop-data-prefetch -loop-versioning-licm -gvn -globalopt -coro-early -instcombine -coro-split -coro-cleanup -loop-data-prefetch -speculative-execution -barrier -partially-inline-libcalls -speculative-execution -sancov -loop-simplify -loop-simplify -mergereturn -bdce -dse -constmerge -argpromotion -memcpyopt -mergefunc -cross-dso-cfi -loop-sink -speculative-execution -newgvn -insert-gcov-profiling -coro-cleanup -instcombine -loop-unroll-and-jam -coro-early -licm -canonicalize-aliases -strip-dead-prototypes -add-discriminators -scalarizer -dse -aggressive-instcombine -loop-fusion -ee-instrument -hotcoldsplit -rpo-functionattrs -lower-expect -globaldce -loop-load-elim -rpo-functionattrs -div-rem-pairs -sccp -loop-vectorize -loop-instsimplify -loop-vectorize -lower-guard-intrinsic -globalopt -coro-early -loop-reroll -partially-inline-libcalls -redundant-dbg-inst-elim -rewrite-statepoints-for-gc -elim-avail-extern -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/ispell,0.9809992962702324,16.816142797470093,opt -loop-idiom -scalarizer -lower-widenable-condition -lcssa -loop-reduce -lower-widenable-condition -coro-elide -lower-widenable-condition -lower-guard-intrinsic -coro-split -loop-reduce -cross-dso-cfi -pgo-memop-opt -newgvn -canonicalize-aliases -tailcallelim -inferattrs -reg2mem -loop-guard-widening -sccp -called-value-propagation -post-inline-ee-instrument -strip-dead-prototypes -called-value-propagation -sancov -strip-dead-prototypes -mergereturn -globalsplit -strip-dead-prototypes -sccp -reg2mem -loop-instsimplify -prune-eh -functionattrs -mergeicmps -tailcallelim -alignment-from-assumptions -simple-loop-unswitch -coro-elide -loop-deletion -ipsccp -loop-unroll-and-jam -mldst-motion -div-rem-pairs -strip-dead-prototypes -reassociate -always-inline -float2int -alignment-from-assumptions -loop-versioning-licm -slsr -deadargelim -sccp -redundant-dbg-inst-elim -reassociate -load-store-vectorizer -consthoist -early-cse-memssa -loop-predication -indvars -jump-threading -consthoist -load-store-vectorizer -argpromotion -mergereturn -coro-early -correlated-propagation -adce -mem2reg -loop-deletion -infer-address-spaces -lowerinvoke -gvn -coro-split -loop-instsimplify -coro-early -canonicalize-aliases -instnamer -barrier -callsite-splitting -simplifycfg -cross-dso-cfi -inject-tli-mappings -instcombine input.bc -o output.bc -benchmark://cBench-v1/ispell,0.9884588318085854,17.402209043502808,opt -bdce -speculative-execution -post-inline-ee-instrument -globalopt -separate-const-offset-from-gep -canonicalize-aliases -coro-early -gvn -loop-unroll-and-jam -load-store-vectorizer -float2int -cross-dso-cfi -newgvn -mem2reg -loop-unroll -elim-avail-extern -coro-elide -cross-dso-cfi -scalarizer -early-cse-memssa -instnamer -insert-gcov-profiling -ee-instrument -simplifycfg -loop-load-elim -div-rem-pairs -lower-guard-intrinsic -attributor -guard-widening -add-discriminators -coro-elide -loop-versioning -loop-vectorize -strip -correlated-propagation -dse -prune-eh -loop-predication -float2int -loop-versioning-licm -div-rem-pairs -loop-unroll-and-jam -lower-guard-intrinsic -loop-simplifycfg -strip-debug-declare -instcombine -coro-cleanup -coro-split -tailcallelim -correlated-propagation -instnamer -early-cse-memssa -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/ispell,1.0002814919071077,16.02399444580078,opt -mem2reg -early-cse-memssa -sancov -always-inline -strip-debug-declare -forceattrs -forceattrs -nary-reassociate -early-cse-memssa -loop-vectorize -newgvn -ipconstprop -div-rem-pairs -dse -strip-dead-prototypes -barrier -dce -simple-loop-unswitch -barrier -inject-tli-mappings -nary-reassociate -callsite-splitting -simplifycfg -instsimplify -loop-guard-widening -break-crit-edges -strip-debug-declare -mergefunc -loop-fusion -loop-interchange -dse -post-inline-ee-instrument -loop-load-elim -globalopt -simplifycfg -loop-deletion -guard-widening -lower-expect -newgvn -instcombine -strip-dead-prototypes -hotcoldsplit -strip-dead-prototypes -tailcallelim -forceattrs -strip-debug-declare -ipsccp -nary-reassociate -loop-predication -flattencfg -called-value-propagation -attributor -loop-simplify -scalarizer -mergeicmps -add-discriminators -coro-early -libcalls-shrinkwrap -mem2reg -deadargelim -loop-idiom -mergefunc -sroa -speculative-execution -globalopt -early-cse-memssa -lower-constant-intrinsics -argpromotion -instcombine -sink -die -lower-expect -lowerinvoke -lowerinvoke -div-rem-pairs -loop-simplify -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,0.9791053104752456,49.419673442840576,opt -break-crit-edges -add-discriminators -lcssa -loop-unroll-and-jam -nary-reassociate -mldst-motion -licm -inferattrs -mem2reg -rpo-functionattrs -callsite-splitting -cross-dso-cfi -loop-distribute -reg2mem -barrier -lowerswitch -separate-const-offset-from-gep -coro-early -newgvn -simple-loop-unswitch -lowerswitch -cross-dso-cfi -dce -infer-address-spaces -canonicalize-aliases -inferattrs -instcombine -sroa -called-value-propagation -strip-dead-prototypes -inferattrs -callsite-splitting -tailcallelim -slp-vectorizer -functionattrs -simplifycfg -ipconstprop -name-anon-globals -coro-cleanup -constprop -loweratomic -globaldce -hotcoldsplit -div-rem-pairs -div-rem-pairs -mergeicmps -constmerge -functionattrs -mldst-motion -memcpyopt -argpromotion -strip -simplifycfg -strip-dead-prototypes -speculative-execution -bdce input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,0.9851815109898626,40.56418228149414,opt -lowerinvoke -mem2reg -gvn-hoist -functionattrs -irce -instsimplify -insert-gcov-profiling -loweratomic -aggressive-instcombine -lcssa -infer-address-spaces -barrier -insert-gcov-profiling -nary-reassociate -adce -loop-guard-widening -libcalls-shrinkwrap -irce -coro-early -licm -rewrite-statepoints-for-gc -die -hotcoldsplit -lowerinvoke -consthoist -globalsplit -div-rem-pairs -globalsplit -loop-deletion -loop-idiom -loop-unroll-and-jam -loop-predication -coro-cleanup -sroa -lower-widenable-condition -coro-early -globalopt -jump-threading -lower-matrix-intrinsics -loop-interchange -licm -die -functionattrs -loop-versioning-licm -post-inline-ee-instrument -simple-loop-unswitch -strip-nondebug -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,0.9937377933471805,39.32756042480469,opt -dse -indvars -sccp -lowerinvoke -loop-unswitch -functionattrs -constmerge -coro-early -lower-expect -loop-unroll-and-jam -called-value-propagation -rpo-functionattrs -aggressive-instcombine -attributor -cross-dso-cfi -lower-widenable-condition -dce -rewrite-statepoints-for-gc -sroa -constmerge -partially-inline-libcalls -loop-unroll -elim-avail-extern -loop-idiom -barrier -libcalls-shrinkwrap -loop-sink -redundant-dbg-inst-elim -coro-elide -loop-unswitch -argpromotion -simple-loop-unswitch -nary-reassociate -loop-reroll -loop-predication -insert-gcov-profiling -strip-debug-declare -cross-dso-cfi -loop-sink -forceattrs -strip-nondebug -sccp -tailcallelim -irce -loop-predication -loop-unroll -loop-reroll -simplifycfg -loop-simplifycfg -early-cse-memssa -add-discriminators -loop-deletion -load-store-vectorizer -strip-dead-prototypes -div-rem-pairs -callsite-splitting -loop-deletion -cross-dso-cfi -float2int -loop-sink -lcssa -indvars -consthoist -infer-address-spaces -slp-vectorizer -loop-sink -redundant-dbg-inst-elim -loop-unswitch -attributor -add-discriminators -libcalls-shrinkwrap -simplifycfg -globalopt -nary-reassociate -globalopt -mergereturn -instcombine -early-cse-memssa -deadargelim -jump-threading input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,0.9965588864432526,37.86662936210632,opt -irce -dse -rewrite-statepoints-for-gc -mldst-motion -ee-instrument -strip-debug-declare -inject-tli-mappings -coro-split -prune-eh -strip-dead-prototypes -gvn -lower-matrix-intrinsics -coro-split -loop-fusion -lower-expect -mem2reg -loop-load-elim -redundant-dbg-inst-elim -memcpyopt -loop-simplify -loop-deletion -instcombine -constmerge -inferattrs -sancov -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,0.9974889171342651,37.16405701637268,opt -always-inline -loop-idiom -post-inline-ee-instrument -simple-loop-unswitch -prune-eh -aggressive-instcombine -licm -lower-guard-intrinsic -licm -mem2reg -coro-split -name-anon-globals -correlated-propagation -infer-address-spaces -instcombine -instcombine -inject-tli-mappings -elim-avail-extern -loweratomic -scalarizer -loop-simplify -correlated-propagation -coro-elide -rewrite-statepoints-for-gc -mergefunc -strip-dead-prototypes -rpo-functionattrs -hotcoldsplit -lowerinvoke -functionattrs -lower-guard-intrinsic -loop-load-elim -newgvn -separate-const-offset-from-gep -float2int -sroa -loop-guard-widening -sroa -slp-vectorizer -coro-cleanup -coro-cleanup -rewrite-statepoints-for-gc -loop-interchange -irce -lower-widenable-condition -jump-threading -tailcallelim -strip -aggressive-instcombine -lowerswitch -prune-eh -mem2reg -constmerge -sink -loop-reroll -loop-predication -reassociate -post-inline-ee-instrument -ipsccp -speculative-execution -correlated-propagation -float2int -strip-debug-declare -post-inline-ee-instrument -partially-inline-libcalls -lower-constant-intrinsics -adce -canonicalize-aliases -irce -dce -simple-loop-unswitch -bdce -mergereturn -speculative-execution -post-inline-ee-instrument -loop-fusion -dce -gvn -die -mem2reg -loop-interchange -indvars -instsimplify input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.004588151408996,41.63024926185608,opt -strip-nondebug -loop-predication -elim-avail-extern -loop-versioning-licm -newgvn -loop-distribute -always-inline -deadargelim -loop-load-elim -loop-guard-widening -mem2reg -loop-instsimplify -strip-dead-prototypes -indvars -lcssa -tailcallelim -strip -sancov -strip-debug-declare -separate-const-offset-from-gep -mergefunc -deadargelim -cross-dso-cfi -irce -coro-split -loop-versioning-licm -inject-tli-mappings -instsimplify -loop-reroll -mergefunc -correlated-propagation -sccp -lower-matrix-intrinsics -sink -load-store-vectorizer -ipconstprop -correlated-propagation -loop-guard-widening -callsite-splitting -lower-widenable-condition -strip-nondebug -callsite-splitting -coro-cleanup -constmerge -div-rem-pairs -simplifycfg -constprop -loop-unroll -ipconstprop -early-cse-memssa -cross-dso-cfi -lower-guard-intrinsic -consthoist -loop-load-elim -consthoist -globalopt -lower-guard-intrinsic -break-crit-edges -nary-reassociate -loop-idiom -sccp -loweratomic -flattencfg -aggressive-instcombine -speculative-execution -loop-instsimplify -mergereturn -attributor -loop-simplifycfg -aggressive-instcombine -correlated-propagation -instnamer -newgvn -sink -globalopt -coro-elide -speculative-execution -ipconstprop -loop-distribute -loop-unroll -loop-deletion -loop-interchange -globalopt -libcalls-shrinkwrap -gvn -jump-threading -alignment-from-assumptions -lower-matrix-intrinsics -separate-const-offset-from-gep -div-rem-pairs -consthoist -instcombine -simple-loop-unswitch -always-inline -loop-idiom -bdce -ee-instrument -infer-address-spaces -sancov -simple-loop-unswitch -ipconstprop -always-inline -barrier -guard-widening -cross-dso-cfi -libcalls-shrinkwrap -loop-unroll -redundant-dbg-inst-elim -inferattrs -guard-widening -strip -div-rem-pairs -alignment-from-assumptions -instsimplify -separate-const-offset-from-gep -div-rem-pairs -instcombine -loop-sink -loop-reroll -pgo-memop-opt -reg2mem -lowerinvoke -dse -loop-simplifycfg -partial-inliner -mem2reg -post-inline-ee-instrument -sink -bdce -post-inline-ee-instrument -sink -loop-versioning-licm -coro-early -strip -partially-inline-libcalls -mem2reg -rewrite-statepoints-for-gc -coro-split -instcombine -early-cse-memssa -partial-inliner -gvn-hoist -loop-idiom -partially-inline-libcalls -strip-nondebug -globaldce -loop-unroll -loop-versioning-licm -break-crit-edges -loop-interchange -irce -mergeicmps -strip -reassociate -constmerge -early-cse-memssa -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.0055181821000094,42.71349883079529,opt -lower-matrix-intrinsics -aggressive-instcombine -rpo-functionattrs -deadargelim -inferattrs -reassociate -mergeicmps -functionattrs -mergefunc -loop-distribute -slsr -adce -name-anon-globals -mergereturn -strip-debug-declare -slsr -gvn-hoist -correlated-propagation -simple-loop-unswitch -irce -loop-versioning-licm -sroa -lower-widenable-condition -adce -loop-predication -jump-threading -coro-early -loop-reroll -load-store-vectorizer -always-inline -barrier -instcombine -lower-widenable-condition -aggressive-instcombine -jump-threading -callsite-splitting -die -canonicalize-aliases -globalsplit -ee-instrument -speculative-execution -argpromotion -newgvn -forceattrs -called-value-propagation -coro-cleanup -jump-threading input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.00750224757417,40.76293182373047,opt -loop-instsimplify -lower-constant-intrinsics -simple-loop-unswitch -loop-interchange -indvars -add-discriminators -newgvn -lower-matrix-intrinsics -break-crit-edges -mergeicmps -loop-unroll-and-jam -lowerinvoke -instnamer -reg2mem -inferattrs -loop-unswitch -flattencfg -called-value-propagation -lowerinvoke -alignment-from-assumptions -correlated-propagation -ipsccp -add-discriminators -loop-reduce -loop-idiom -jump-threading -forceattrs -loop-load-elim -called-value-propagation -globaldce -ipsccp -loop-simplifycfg -loop-deletion -always-inline -loop-simplifycfg -correlated-propagation -loop-reduce -attributor -globalopt -loweratomic -loop-versioning-licm -deadargelim -irce -loop-reduce -canonicalize-aliases -infer-address-spaces -indvars -simple-loop-unswitch -reg2mem -rpo-functionattrs -ipsccp -instsimplify -infer-address-spaces -redundant-dbg-inst-elim -rewrite-statepoints-for-gc -mem2reg -speculative-execution -instcombine -lower-widenable-condition -slp-vectorizer -simplifycfg -deadargelim -sroa -instcombine -bdce -slp-vectorizer -aggressive-instcombine -lowerinvoke -lowerinvoke -mergereturn -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.0162135350466563,37.60094594955444,opt -post-inline-ee-instrument -inject-tli-mappings -die -hotcoldsplit -loop-interchange -loop-versioning -sroa -forceattrs -strip -gvn-hoist -argpromotion -loop-reroll -argpromotion -canonicalize-aliases -globalsplit -instcombine -inferattrs -post-inline-ee-instrument -strip-dead-prototypes -mldst-motion -loop-sink -die -loweratomic -flattencfg -speculative-execution -early-cse-memssa -pgo-memop-opt -lower-guard-intrinsic -add-discriminators -mergefunc -loop-data-prefetch -elim-avail-extern -indvars -attributor -simple-loop-unswitch -loop-fusion -ipsccp -attributor -strip-nondebug -simplifycfg -slp-vectorizer input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.0305050066652195,43.867016553878784,opt -bdce -attributor -guard-widening -instsimplify -mem2reg -loop-instsimplify -flattencfg -rewrite-statepoints-for-gc -globalsplit -loop-idiom -lower-constant-intrinsics -die -loop-guard-widening -gvn-hoist -loop-distribute -licm -lower-widenable-condition -functionattrs -jump-threading -rpo-functionattrs -bdce -div-rem-pairs -gvn -sccp -lcssa -sccp -libcalls-shrinkwrap -coro-split -instnamer -newgvn -inferattrs -forceattrs -correlated-propagation -mem2reg -dse -dse -licm -partially-inline-libcalls -ipsccp -loop-unroll-and-jam -lower-guard-intrinsic -lower-matrix-intrinsics -gvn -indvars -attributor -licm -libcalls-shrinkwrap -mldst-motion -sccp -rpo-functionattrs -flattencfg -nary-reassociate -strip-nondebug -loop-simplifycfg -loop-versioning-licm -lcssa -lower-expect -mergefunc -name-anon-globals -strip-debug-declare -ipconstprop -licm -strip-dead-prototypes -loop-deletion -separate-const-offset-from-gep -partially-inline-libcalls -correlated-propagation -mergereturn -deadargelim -newgvn -loop-deletion -instcombine -lower-widenable-condition -dse -jump-threading -mem2reg -always-inline -pgo-memop-opt -mergereturn -loop-data-prefetch -loop-versioning-licm -simplifycfg -speculative-execution -licm -functionattrs -die -prune-eh -functionattrs -libcalls-shrinkwrap -globalopt -rpo-functionattrs -irce -loweratomic -loop-simplify -lower-matrix-intrinsics -loop-unroll-and-jam -flattencfg -reassociate -loop-simplify -slsr -partially-inline-libcalls -loop-data-prefetch -div-rem-pairs -loop-instsimplify -called-value-propagation -loop-distribute -ipsccp -memcpyopt -dce -guard-widening -ee-instrument -cross-dso-cfi -instsimplify input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,0.9849319037960012,44.77920889854431,opt -always-inline -simple-loop-unswitch -scalarizer -coro-elide -coro-early -constmerge -sccp -lower-matrix-intrinsics -dce -scalarizer -ipconstprop -loop-sink -instnamer -sccp -mergeicmps -newgvn -simplifycfg -ipconstprop -lower-expect -strip-debug-declare -sink -constprop -sroa -flattencfg -strip -strip -lcssa -consthoist -coro-early -attributor -slp-vectorizer -cross-dso-cfi -lower-widenable-condition -coro-split -constprop -mldst-motion -constmerge -functionattrs -forceattrs -mergefunc -aggressive-instcombine -slsr -lower-expect -loop-load-elim -forceattrs -rpo-functionattrs -sancov -loweratomic -licm -lower-expect -loop-simplify -loop-guard-widening -strip-dead-prototypes -ipconstprop -inferattrs -sancov -sccp -always-inline -rewrite-statepoints-for-gc -loop-vectorize -loop-versioning -mldst-motion -speculative-execution -loop-vectorize -loop-predication -ee-instrument -coro-elide -gvn input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,0.9866383334943173,41.430155515670776,opt -coro-early -callsite-splitting -float2int -libcalls-shrinkwrap -sccp -forceattrs -lower-guard-intrinsic -gvn-hoist -called-value-propagation -loop-idiom -gvn -prune-eh -indvars -post-inline-ee-instrument -loweratomic -sroa -sroa -lower-constant-intrinsics -lowerswitch -canonicalize-aliases -newgvn -argpromotion -float2int -insert-gcov-profiling -loop-reroll -nary-reassociate -gvn-hoist -lower-constant-intrinsics -loop-simplify -separate-const-offset-from-gep -ipsccp -simplifycfg -libcalls-shrinkwrap -newgvn -bdce input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,0.9939148073022314,41.397254943847656,opt -attributor -speculative-execution -sink -called-value-propagation -canonicalize-aliases -irce -lower-constant-intrinsics -dse -lowerswitch -functionattrs -globalopt -separate-const-offset-from-gep -instnamer -elim-avail-extern -hotcoldsplit -lower-constant-intrinsics -jump-threading -lowerswitch -inferattrs -jump-threading -lower-expect -instsimplify -gvn -dse -called-value-propagation -lcssa -memcpyopt -correlated-propagation -newgvn -reg2mem -elim-avail-extern -called-value-propagation -div-rem-pairs -loop-unswitch -redundant-dbg-inst-elim -ipconstprop -speculative-execution -loop-unroll-and-jam -loop-guard-widening -loop-fusion -mergeicmps -globaldce -lowerinvoke -ee-instrument -mem2reg -loop-load-elim -constmerge -lowerswitch -loop-deletion -attributor -lower-expect -newgvn -ee-instrument -forceattrs -strip -loop-versioning-licm -deadargelim -loop-distribute -early-cse-memssa -break-crit-edges -constmerge -lowerswitch -globalsplit -globaldce -always-inline -loop-simplifycfg -mergereturn -loop-interchange -bdce -aggressive-instcombine -guard-widening -irce -gvn-hoist -always-inline -reg2mem -gvn -globalopt -loop-fusion -lower-guard-intrinsic -flattencfg -sccp -div-rem-pairs -mergereturn -separate-const-offset-from-gep -loop-fusion -div-rem-pairs -rewrite-statepoints-for-gc -loweratomic -callsite-splitting -float2int -functionattrs -loop-data-prefetch -infer-address-spaces -instcombine -infer-address-spaces -loop-fusion -ipconstprop -lower-constant-intrinsics -sink -lower-constant-intrinsics -coro-early -loop-distribute -ipsccp -sink -instnamer -mem2reg -loop-idiom -loop-idiom -coro-cleanup -coro-split -jump-threading -globalsplit -instnamer -instcombine input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,0.994140184809556,38.051066637039185,opt -loop-load-elim -loop-data-prefetch -coro-split -redundant-dbg-inst-elim -loop-distribute -mem2reg -speculative-execution -loop-predication -jump-threading -mem2reg -gvn -sccp -forceattrs -cross-dso-cfi -loop-data-prefetch -loweratomic -elim-avail-extern -bdce -flattencfg -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,0.9964261566695642,48.110989570617676,opt -argpromotion -strip -gvn -lowerswitch -post-inline-ee-instrument -loop-vectorize -strip-debug-declare -libcalls-shrinkwrap -float2int -tailcallelim -adce -instsimplify -prune-eh -dse -add-discriminators -mergereturn -prune-eh -cross-dso-cfi -loop-vectorize -instsimplify -loop-vectorize -deadargelim -reassociate -loweratomic -indvars -globalopt -lcssa -bdce -licm -memcpyopt -newgvn -jump-threading -ipsccp -pgo-memop-opt -loop-sink -instcombine -called-value-propagation -nary-reassociate -loop-fusion -loop-reroll -mergereturn -alignment-from-assumptions -lower-guard-intrinsic -dce -loweratomic -flattencfg -inject-tli-mappings -jump-threading -separate-const-offset-from-gep -instcombine -flattencfg -memcpyopt -mldst-motion -loop-unroll-and-jam -loweratomic -sccp -reassociate -loop-rotate -inject-tli-mappings -loop-guard-widening -alignment-from-assumptions -called-value-propagation -strip-nondebug -slsr -instsimplify -strip-debug-declare -lowerinvoke -functionattrs -elim-avail-extern -gvn -mergereturn -strip -deadargelim -prune-eh -barrier -instsimplify -strip-nondebug -separate-const-offset-from-gep -tailcallelim -jump-threading -redundant-dbg-inst-elim -instnamer -reassociate -partially-inline-libcalls -instcombine -ee-instrument -instnamer -globalopt -inferattrs -adce -rpo-functionattrs -called-value-propagation -constmerge -add-discriminators -add-discriminators -globaldce -ipsccp -sroa -coro-early -elim-avail-extern -guard-widening -argpromotion -instnamer -loop-instsimplify -attributor -ipconstprop -alignment-from-assumptions -name-anon-globals -globalsplit -mldst-motion -lowerswitch -loop-deletion -slsr -dse -redundant-dbg-inst-elim -simplifycfg -mldst-motion -rewrite-statepoints-for-gc -loop-data-prefetch -lower-expect -licm -simple-loop-unswitch -loop-fusion -loop-data-prefetch -post-inline-ee-instrument -mergefunc -loop-reroll -ipsccp -functionattrs -lower-matrix-intrinsics -strip-nondebug -guard-widening -partially-inline-libcalls -infer-address-spaces -called-value-propagation -mergefunc -sccp -cross-dso-cfi -indvars -argpromotion -loop-reroll -elim-avail-extern -inferattrs -partially-inline-libcalls -slp-vectorizer -deadargelim -loop-versioning-licm -post-inline-ee-instrument -ee-instrument -deadargelim -loop-data-prefetch -bdce -loop-predication -loop-distribute -slsr -hotcoldsplit -instnamer -instsimplify -loop-deletion -globaldce -name-anon-globals -ee-instrument -coro-split -die -consthoist -pgo-memop-opt -lower-widenable-condition -strip-nondebug -jump-threading -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.0002575742940853,327.2070269584656,opt -insert-gcov-profiling -lcssa -gvn -called-value-propagation -mergefunc -loop-load-elim -strip-debug-declare -indvars -loop-versioning -loop-unroll-and-jam -strip-debug-declare -loop-deletion -constprop -ipconstprop -argpromotion -lower-constant-intrinsics -globalsplit -sroa -rpo-functionattrs -sink -adce -float2int -name-anon-globals -loop-sink -loop-sink -guard-widening -barrier -loop-sink -forceattrs -mergeicmps -mergeicmps -load-store-vectorizer -bdce -float2int -loop-data-prefetch -mergeicmps -partially-inline-libcalls -alignment-from-assumptions -loop-idiom -scalarizer -instsimplify -ipconstprop -loop-interchange -ipsccp -memcpyopt -instcombine -loweratomic -instsimplify -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.0043787629994525,40.50717830657959,opt -sccp -coro-split -mem2reg -lower-matrix-intrinsics -loop-sink -instcombine -rpo-functionattrs -redundant-dbg-inst-elim -coro-early -strip-debug-declare -inferattrs -elim-avail-extern -rewrite-statepoints-for-gc -indvars -lowerinvoke -consthoist -ee-instrument -elim-avail-extern -mem2reg -add-discriminators -globalsplit -argpromotion -mergereturn -partially-inline-libcalls -sroa -mergereturn -reassociate -scalarizer -inferattrs -pgo-memop-opt -loop-unroll-and-jam -loop-instsimplify -functionattrs -inject-tli-mappings -lowerinvoke -slsr -consthoist -libcalls-shrinkwrap -lowerswitch -correlated-propagation -lower-constant-intrinsics -break-crit-edges -called-value-propagation -coro-split -loop-distribute -div-rem-pairs -guard-widening -nary-reassociate -indvars -aggressive-instcombine -dse -sccp -loop-guard-widening -constmerge -globalsplit -loop-sink -constprop -barrier -ipsccp -loop-reroll -ipsccp -strip-nondebug -called-value-propagation -sink -load-store-vectorizer -lower-constant-intrinsics -flattencfg -speculative-execution -early-cse-memssa -lower-expect -reassociate -ipconstprop -instsimplify -loop-instsimplify -reassociate -partial-inliner -slsr -mem2reg -infer-address-spaces -loop-instsimplify -irce -always-inline -cross-dso-cfi -lower-matrix-intrinsics -loop-simplify -loop-load-elim -ipconstprop -elim-avail-extern -ipsccp -loop-vectorize -die -hotcoldsplit -hotcoldsplit -sancov -scalarizer -loop-guard-widening -called-value-propagation -break-crit-edges -loop-guard-widening -loop-guard-widening -loop-versioning-licm -instcombine -loop-deletion -canonicalize-aliases -loop-interchange -consthoist -aggressive-instcombine -attributor -adce -mergeicmps -coro-cleanup -redundant-dbg-inst-elim -mergefunc -dce -elim-avail-extern -load-store-vectorizer -loop-guard-widening -elim-avail-extern -simplifycfg -lcssa -strip -called-value-propagation -lowerswitch -rpo-functionattrs -strip-nondebug -ipconstprop -mergefunc -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.0189317106152807,39.96248817443848,opt -mem2reg -adce -post-inline-ee-instrument -mergereturn -mergereturn -loop-vectorize -float2int -float2int -globalopt -simplifycfg -sccp -redundant-dbg-inst-elim -forceattrs -slsr -insert-gcov-profiling -bdce -lower-expect -functionattrs -instcombine -rpo-functionattrs -float2int -tailcallelim -loop-data-prefetch -lcssa -forceattrs -speculative-execution -always-inline -scalarizer -instsimplify -barrier -instcombine -globaldce -guard-widening -loweratomic -strip-dead-prototypes -forceattrs -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.0236002446955792,40.084962129592896,opt -ipconstprop -simple-loop-unswitch -loop-fusion -sroa -jump-threading -loop-idiom -loop-distribute -functionattrs -loop-distribute -lowerswitch -strip-debug-declare -indvars -barrier -mergefunc -redundant-dbg-inst-elim -add-discriminators -simple-loop-unswitch -licm -consthoist -instsimplify -inject-tli-mappings -loop-data-prefetch -redundant-dbg-inst-elim -rewrite-statepoints-for-gc -slp-vectorizer -inferattrs -callsite-splitting -correlated-propagation -alignment-from-assumptions -early-cse-memssa -mergefunc -sroa -scalarizer -loop-data-prefetch -prune-eh -inject-tli-mappings -rewrite-statepoints-for-gc -indvars -tailcallelim -instnamer -name-anon-globals -argpromotion -loop-instsimplify -argpromotion -ee-instrument -forceattrs -lcssa -loop-simplifycfg -indvars -inferattrs -loop-load-elim -gvn -reassociate -partially-inline-libcalls -sancov -instcombine -bdce -loop-data-prefetch -lower-guard-intrinsic -strip-dead-prototypes -strip-nondebug -simplifycfg -prune-eh -sccp -functionattrs -consthoist -libcalls-shrinkwrap -strip-dead-prototypes -coro-cleanup -die -prune-eh -gvn -lower-constant-intrinsics input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.0255964454747417,36.70538592338562,opt -bdce -dse -memcpyopt -inject-tli-mappings -die -globaldce -strip-debug-declare -prune-eh -reg2mem -coro-early -die -lower-widenable-condition -lower-constant-intrinsics -instnamer -loweratomic -attributor -rewrite-statepoints-for-gc -coro-split -lower-guard-intrinsic -separate-const-offset-from-gep -sroa -loop-distribute -mergefunc -early-cse-memssa -instsimplify -simplifycfg -instcombine -scalarizer -separate-const-offset-from-gep -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/lame,1.0058073331815074,34.02283263206482,opt -gvn-hoist -instcombine -loop-load-elim -strip-nondebug -instsimplify -sroa -sancov -inferattrs -add-discriminators -loop-vectorize -loop-load-elim -lower-expect -newgvn -early-cse-memssa -instcombine -lower-constant-intrinsics -slsr -jump-threading input.bc -o output.bc -benchmark://cBench-v1/lame,1.0103241478782359,66.14738416671753,opt -loop-distribute -early-cse-memssa -loop-load-elim -jump-threading -break-crit-edges -jump-threading -gvn -rpo-functionattrs -ee-instrument -loop-fusion -loop-unswitch -loop-reroll -mergereturn -correlated-propagation -deadargelim -float2int -guard-widening -reassociate -loop-interchange -name-anon-globals -div-rem-pairs -barrier -tailcallelim -pgo-memop-opt -lower-widenable-condition -coro-split -loop-interchange -constprop -dse -reassociate -add-discriminators -elim-avail-extern -loop-distribute -lower-constant-intrinsics -lower-matrix-intrinsics -dse -hotcoldsplit -loop-distribute -redundant-dbg-inst-elim -indvars -constmerge -mergefunc -break-crit-edges -loop-simplifycfg -jump-threading -lowerswitch -flattencfg -instcombine -memcpyopt -sccp -ipsccp -loop-sink -separate-const-offset-from-gep -strip -pgo-memop-opt -adce -constprop -lcssa -lowerinvoke -simple-loop-unswitch -simple-loop-unswitch -called-value-propagation -loop-versioning -loop-fusion -memcpyopt -simplifycfg -lowerinvoke -ipsccp -consthoist -loop-deletion -licm -scalarizer -consthoist -insert-gcov-profiling -loop-interchange -loop-versioning -inferattrs -inject-tli-mappings -cross-dso-cfi -adce -tailcallelim -tailcallelim -dse -simple-loop-unswitch -ipsccp -load-store-vectorizer -loop-deletion -elim-avail-extern -break-crit-edges -loop-idiom -simplifycfg -inject-tli-mappings -loop-instsimplify -callsite-splitting -infer-address-spaces -dce -slp-vectorizer -pgo-memop-opt -loop-fusion -loop-fusion -aggressive-instcombine -rpo-functionattrs -instcombine -loop-unswitch -break-crit-edges -name-anon-globals -loop-guard-widening -bdce -deadargelim -licm -break-crit-edges -newgvn -globaldce -instsimplify -scalarizer -ipconstprop -strip-dead-prototypes -bdce -mem2reg -globalsplit -div-rem-pairs -flattencfg -die -dce -pgo-memop-opt -tailcallelim -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/lame,1.012373794883474,38.40332770347595,opt -loop-guard-widening -separate-const-offset-from-gep -slsr -loop-data-prefetch -loop-load-elim -load-store-vectorizer -mem2reg -instcombine -globaldce -globalopt -break-crit-edges -ipsccp -dse -loop-load-elim -loop-reroll -loop-rotate -loop-idiom -redundant-dbg-inst-elim -mergeicmps -bdce -load-store-vectorizer -load-store-vectorizer -inject-tli-mappings -die -loop-vectorize -barrier -div-rem-pairs -deadargelim -libcalls-shrinkwrap -mergefunc -early-cse-memssa -nary-reassociate -rpo-functionattrs -loop-predication -early-cse-memssa -instnamer -called-value-propagation -loweratomic -loop-reroll -ee-instrument -loop-deletion -functionattrs -loop-fusion -break-crit-edges -mergefunc -lower-widenable-condition -slp-vectorizer -globaldce -bdce -globaldce -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/lame,1.0212176421468158,64.10320901870728,opt -indvars -loop-data-prefetch -float2int -attributor -sancov -reassociate -lcssa -ee-instrument -deadargelim -simplifycfg -lowerinvoke -loop-simplify -always-inline -loop-simplify -mergefunc -die -gvn-hoist -speculative-execution -early-cse-memssa -attributor -loop-simplifycfg -lowerinvoke -loop-interchange -irce -gvn-hoist -instsimplify -forceattrs -loop-predication -loop-rotate -loop-distribute -prune-eh -correlated-propagation -rewrite-statepoints-for-gc -globalsplit -die -ipconstprop -loop-unswitch -lower-constant-intrinsics -hotcoldsplit -lower-widenable-condition -redundant-dbg-inst-elim -loop-vectorize -add-discriminators -newgvn -constmerge -instcombine -globaldce -dse -mem2reg -irce -bdce -consthoist -strip-nondebug -coro-split -mergeicmps -strip -loop-simplifycfg -functionattrs -mergereturn -coro-cleanup -licm -simplifycfg -loop-distribute -loweratomic -coro-elide -ipsccp -loop-deletion -lower-guard-intrinsic -newgvn -sink -newgvn -loop-deletion -lowerinvoke -gvn-hoist -globalopt -loop-distribute -insert-gcov-profiling -loop-unroll-and-jam -sroa -always-inline -loop-deletion -loop-simplify -callsite-splitting -flattencfg -lower-expect -post-inline-ee-instrument -coro-cleanup -speculative-execution -float2int -instcombine -newgvn input.bc -o output.bc -benchmark://cBench-v1/lame,1.0235709405602367,43.15250539779663,opt -instcombine -simple-loop-unswitch -functionattrs -simple-loop-unswitch -post-inline-ee-instrument -loop-simplify -instsimplify -bdce -always-inline -lcssa -float2int -functionattrs -ipsccp -globalsplit -nary-reassociate -coro-early -lowerinvoke -coro-early -loop-simplifycfg -lower-guard-intrinsic -mem2reg -bdce -loweratomic -always-inline -instnamer -elim-avail-extern -post-inline-ee-instrument -simple-loop-unswitch -die -strip-dead-prototypes -slsr -barrier -strip-debug-declare -loop-versioning -slsr -gvn -mem2reg -irce -load-store-vectorizer -speculative-execution -loop-idiom -licm -loop-guard-widening -licm -callsite-splitting -div-rem-pairs -ipsccp -loop-instsimplify -always-inline -licm -add-discriminators -div-rem-pairs -libcalls-shrinkwrap -indvars -mldst-motion -dse -sroa -loop-versioning-licm -loop-deletion -gvn-hoist -loop-versioning -lower-guard-intrinsic -die -float2int -correlated-propagation -loop-versioning -strip-nondebug -hotcoldsplit -functionattrs -slsr -inferattrs -constprop -loop-unroll-and-jam -lower-widenable-condition -loop-unswitch -mergereturn -early-cse-memssa -mldst-motion -prune-eh -loop-predication -loop-versioning-licm -loop-data-prefetch -consthoist -inferattrs -indvars -forceattrs -guard-widening -tailcallelim -sccp -load-store-vectorizer -coro-cleanup -strip-debug-declare -jump-threading -callsite-splitting -prune-eh -globaldce -instcombine -mem2reg -nary-reassociate -mergeicmps -insert-gcov-profiling -partially-inline-libcalls -globalopt -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/lame,1.0259621953996811,53.347551345825195,opt -mldst-motion -coro-elide -loop-vectorize -loop-versioning -libcalls-shrinkwrap -ipconstprop -early-cse-memssa -simple-loop-unswitch -sink -bdce -forceattrs -elim-avail-extern -loop-guard-widening -hotcoldsplit -instcombine -lowerinvoke -aggressive-instcombine -aggressive-instcombine -instcombine -lower-constant-intrinsics -dse -argpromotion -libcalls-shrinkwrap -slp-vectorizer -loop-deletion -coro-cleanup -aggressive-instcombine -separate-const-offset-from-gep -nary-reassociate -libcalls-shrinkwrap -alignment-from-assumptions -constprop -loop-reroll -separate-const-offset-from-gep -jump-threading -coro-cleanup -consthoist -load-store-vectorizer -licm -slp-vectorizer -loop-deletion -adce -correlated-propagation -newgvn -loop-reroll -slp-vectorizer -loop-simplifycfg -inject-tli-mappings -sroa -load-store-vectorizer -strip-debug-declare -lower-guard-intrinsic -aggressive-instcombine -simple-loop-unswitch -lcssa -loop-interchange -slsr -ipsccp -die -loop-reroll -called-value-propagation -globalsplit -consthoist -prune-eh -simple-loop-unswitch -loop-reroll -mergefunc -guard-widening -loop-distribute -float2int -loop-simplify -loop-predication -loweratomic -loop-versioning -inject-tli-mappings -coro-split -lcssa -loop-distribute -forceattrs -flattencfg -instcombine -callsite-splitting -post-inline-ee-instrument -constprop -mldst-motion -jump-threading -consthoist -rewrite-statepoints-for-gc -coro-elide -irce -ipsccp -float2int -globaldce -loop-simplify -cross-dso-cfi -guard-widening -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/lame,1.0276322781446898,78.09253025054932,opt -coro-elide -coro-elide -cross-dso-cfi -nary-reassociate -alignment-from-assumptions -called-value-propagation -div-rem-pairs -nary-reassociate -lower-matrix-intrinsics -canonicalize-aliases -loop-unswitch -pgo-memop-opt -mldst-motion -strip-dead-prototypes -alignment-from-assumptions -simplifycfg -speculative-execution -called-value-propagation -loop-interchange -infer-address-spaces -attributor -prune-eh -deadargelim -indvars -strip-dead-prototypes -instnamer -loop-load-elim -ipsccp -strip-dead-prototypes -nary-reassociate -constmerge -dce -cross-dso-cfi -loop-vectorize -lower-guard-intrinsic -loop-predication -always-inline -coro-cleanup -gvn -correlated-propagation -cross-dso-cfi -aggressive-instcombine -newgvn -mem2reg -mergefunc -reassociate -simple-loop-unswitch -slp-vectorizer -scalarizer -instcombine -sancov -globaldce -simplifycfg -lower-expect -memcpyopt -argpromotion -add-discriminators -loop-distribute -dse input.bc -o output.bc -benchmark://cBench-v1/lame,1.0294541865937905,36.18445158004761,opt -mldst-motion -redundant-dbg-inst-elim -loop-unroll-and-jam -sroa -loweratomic -loop-reroll -loweratomic -nary-reassociate -partially-inline-libcalls -sccp -instsimplify -mergefunc -globalsplit -attributor -forceattrs -lowerinvoke -redundant-dbg-inst-elim -die -dse -inferattrs -loop-unswitch -licm -functionattrs -irce -memcpyopt -redundant-dbg-inst-elim -name-anon-globals -speculative-execution -sancov -ipconstprop -canonicalize-aliases -jump-threading -sink -loop-simplifycfg -float2int -loop-idiom -callsite-splitting -lower-guard-intrinsic -loop-idiom -libcalls-shrinkwrap -gvn -instcombine -mem2reg -ipconstprop -attributor -argpromotion -bdce -speculative-execution -prune-eh -cross-dso-cfi -dce -mldst-motion -mldst-motion -reassociate -mergeicmps -mergefunc -loop-versioning-licm -insert-gcov-profiling -lowerswitch -div-rem-pairs -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/lame,1.0310863129127756,42.606950998306274,opt -loop-vectorize -loop-predication -loop-predication -lower-expect -rpo-functionattrs -loop-deletion -loop-reroll -lowerswitch -strip-dead-prototypes -elim-avail-extern -constmerge -partial-inliner -sancov -loop-versioning-licm -nary-reassociate -add-discriminators -gvn -break-crit-edges -guard-widening -coro-cleanup -correlated-propagation -instcombine -forceattrs -constprop -instcombine -globaldce -memcpyopt -alignment-from-assumptions -irce -nary-reassociate -functionattrs -loop-idiom -coro-split -newgvn -lower-widenable-condition -loop-idiom -instsimplify -instnamer -reg2mem -instnamer -memcpyopt -loop-simplifycfg -loop-unroll -loop-vectorize -globaldce -reassociate -inferattrs -coro-split -alignment-from-assumptions -deadargelim -lower-matrix-intrinsics -loop-unroll-and-jam -load-store-vectorizer -deadargelim -slsr -globaldce -globaldce -bdce -die -slsr -sroa -loop-idiom -newgvn -insert-gcov-profiling -name-anon-globals -loop-unswitch -functionattrs -coro-early -loop-fusion -simplifycfg -callsite-splitting -instcombine -newgvn -lower-widenable-condition -licm -ipconstprop -nary-reassociate -dce -slsr -argpromotion -alignment-from-assumptions -sccp -argpromotion -irce -called-value-propagation -globalsplit -loop-fusion -globaldce -called-value-propagation -lower-expect -coro-elide -loop-deletion -licm -loop-simplifycfg -ipsccp -reassociate -canonicalize-aliases -consthoist -ee-instrument -ipconstprop -newgvn -die -globaldce -elim-avail-extern -loop-guard-widening -redundant-dbg-inst-elim -simple-loop-unswitch -prune-eh -lower-guard-intrinsic -inject-tli-mappings -tailcallelim -functionattrs -memcpyopt -div-rem-pairs -mldst-motion -name-anon-globals -forceattrs -callsite-splitting -name-anon-globals -aggressive-instcombine -alignment-from-assumptions -slp-vectorizer -speculative-execution -licm -forceattrs -loop-deletion -div-rem-pairs -callsite-splitting -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/lame,1.0456615805055796,35.40720820426941,opt -strip-debug-declare -consthoist -sroa -loop-interchange -loop-fusion -speculative-execution -lower-matrix-intrinsics -strip -instcombine -gvn -name-anon-globals -gvn -loop-vectorize -slp-vectorizer -mergereturn -break-crit-edges -instsimplify -lcssa -deadargelim -loop-predication -licm -irce -lower-expect -loop-versioning -instcombine -gvn -coro-split -rpo-functionattrs -simplifycfg -lower-guard-intrinsic -bdce input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9866518353726363,11.925774574279785,opt -gvn-hoist -loop-unroll -loop-simplifycfg -consthoist -lower-constant-intrinsics -cross-dso-cfi -irce -bdce -strip-nondebug -mergefunc -rewrite-statepoints-for-gc -forceattrs -lowerinvoke -coro-elide -ipsccp -loop-versioning-licm -strip-dead-prototypes -libcalls-shrinkwrap -sink -loweratomic -early-cse-memssa -loop-vectorize -alignment-from-assumptions -break-crit-edges -loop-interchange -loop-distribute -strip -break-crit-edges -infer-address-spaces -canonicalize-aliases -always-inline -loop-unroll-and-jam -called-value-propagation -loweratomic -infer-address-spaces -memcpyopt -globalopt -mergereturn -licm -bdce -coro-early -simplifycfg -rpo-functionattrs -strip-dead-prototypes -pgo-memop-opt -barrier -mldst-motion -consthoist -insert-gcov-profiling -mergereturn -flattencfg -pgo-memop-opt -functionattrs -loop-sink -loop-reduce -redundant-dbg-inst-elim -post-inline-ee-instrument -insert-gcov-profiling -barrier -sancov -mem2reg -functionattrs -correlated-propagation -lower-expect -gvn-hoist -gvn -strip-dead-prototypes -instsimplify -strip -add-discriminators -lower-guard-intrinsic -ipsccp -inferattrs -reassociate -dce -prune-eh -jump-threading -adce input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9866518353726363,12.079885959625244,opt -loop-reduce -lower-guard-intrinsic -reg2mem -coro-split -loop-instsimplify -lower-constant-intrinsics -loop-reduce -coro-cleanup -canonicalize-aliases -elim-avail-extern -ee-instrument -jump-threading -correlated-propagation -lower-expect -loop-instsimplify -mldst-motion -functionattrs -div-rem-pairs -infer-address-spaces -loop-unswitch -instnamer -libcalls-shrinkwrap -loop-distribute -functionattrs -globalopt -loop-distribute -strip-dead-prototypes -libcalls-shrinkwrap -nary-reassociate -loop-simplify -lower-expect -coro-split -ipsccp -inferattrs -gvn -argpromotion -add-discriminators -lower-matrix-intrinsics -irce -globaldce -instnamer -simplifycfg -early-cse-memssa -functionattrs -instcombine -loop-unroll-and-jam -loop-deletion -gvn-hoist -jump-threading -coro-elide -tailcallelim -lower-guard-intrinsic -div-rem-pairs -attributor -adce -coro-elide -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9877641824249167,12.29286503791809,opt -slp-vectorizer -globalopt -load-store-vectorizer -dse -loop-vectorize -mem2reg -deadargelim -rewrite-statepoints-for-gc -loop-idiom -prune-eh -lower-constant-intrinsics -alignment-from-assumptions -loop-guard-widening -float2int -functionattrs -functionattrs -slp-vectorizer -mergereturn -ipsccp -consthoist -mldst-motion -instsimplify -speculative-execution -mldst-motion -simplifycfg -memcpyopt -loop-versioning -sink -loop-reroll -early-cse-memssa -coro-cleanup -loop-versioning-licm -loop-unroll -dce -guard-widening -dce -functionattrs -loop-guard-widening -speculative-execution -coro-early -div-rem-pairs -correlated-propagation -jump-threading -pgo-memop-opt -scalarizer -coro-cleanup -newgvn input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9877641824249169,12.073808193206787,opt -functionattrs -libcalls-shrinkwrap -loop-interchange -ipsccp -gvn -lower-widenable-condition -sroa -lower-guard-intrinsic -adce -loop-versioning-licm -licm -coro-cleanup -sccp -sancov -dse -barrier -infer-address-spaces -loop-interchange -licm -loop-unroll-and-jam -lower-expect -ipsccp -rewrite-statepoints-for-gc -mergefunc -loop-versioning-licm -coro-split -loop-instsimplify -rpo-functionattrs -early-cse-memssa -flattencfg -called-value-propagation -instcombine -infer-address-spaces -loop-versioning -guard-widening -gvn -globaldce -partially-inline-libcalls -nary-reassociate -indvars -inject-tli-mappings -loop-vectorize -lowerswitch -coro-early -ipconstprop -alignment-from-assumptions -bdce -aggressive-instcombine -loop-simplifycfg -globalopt -speculative-execution -lower-guard-intrinsic -memcpyopt -gvn -sancov -coro-early -loop-guard-widening -slp-vectorizer -mergefunc -loop-reduce -load-store-vectorizer -loop-fusion -lower-expect -callsite-splitting -inject-tli-mappings -scalarizer -die -coro-cleanup -simplifycfg -loop-sink -lower-widenable-condition -inject-tli-mappings -dse -libcalls-shrinkwrap -strip -ipsccp -gvn -constprop -die -ee-instrument -gvn -tailcallelim input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9888765294771972,13.508204936981201,opt -globalopt -mldst-motion -scalarizer -float2int -barrier -loop-simplify -elim-avail-extern -loop-reduce -die -newgvn -loop-fusion -cross-dso-cfi -loop-versioning-licm -infer-address-spaces -loop-distribute -slp-vectorizer -deadargelim -loop-simplifycfg -coro-elide -partial-inliner -hotcoldsplit -gvn -simplifycfg -correlated-propagation -sancov -mergereturn -lowerswitch -attributor -nary-reassociate -die -barrier -loop-reroll -loop-load-elim -libcalls-shrinkwrap -break-crit-edges -separate-const-offset-from-gep -adce -gvn -licm -die -globalsplit -post-inline-ee-instrument -float2int -bdce -loop-guard-widening -post-inline-ee-instrument -strip-nondebug -mergefunc -bdce -break-crit-edges -inject-tli-mappings -strip -sccp -jump-threading -loop-versioning-licm -constprop -functionattrs -indvars -mergereturn -flattencfg -instcombine -loop-distribute -mem2reg -loop-deletion -loop-unroll-and-jam -strip-dead-prototypes -coro-early -lcssa -rewrite-statepoints-for-gc -partially-inline-libcalls -loop-fusion -bdce -strip-nondebug -loop-reroll -functionattrs -lowerswitch -mldst-motion -jump-threading -newgvn -bdce -reg2mem -div-rem-pairs -name-anon-globals -lower-guard-intrinsic -sancov -instnamer -add-discriminators -always-inline -mergefunc -loop-load-elim -loop-reroll -loop-unroll -load-store-vectorizer -slp-vectorizer -loop-sink -elim-avail-extern -strip-nondebug -constprop -pgo-memop-opt -ee-instrument -loop-rotate -sink -coro-split -lcssa -dse -early-cse-memssa -pgo-memop-opt -lower-matrix-intrinsics -globalopt -newgvn -mergefunc -loop-distribute -loop-interchange -partial-inliner -loop-versioning -coro-elide -globalsplit -rewrite-statepoints-for-gc -irce -libcalls-shrinkwrap -sink -simplifycfg -constmerge -loop-unroll-and-jam -lowerinvoke -gvn -newgvn -loop-reroll -lower-constant-intrinsics -aggressive-instcombine -called-value-propagation -strip-dead-prototypes -globalsplit -rpo-functionattrs -gvn -div-rem-pairs -bdce -simplifycfg -forceattrs -callsite-splitting -insert-gcov-profiling -sroa -strip -simplifycfg -sccp -instnamer -globalopt -reassociate input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9911012235817576,12.252049684524536,opt -functionattrs -instsimplify -callsite-splitting -lowerswitch -aggressive-instcombine -licm -always-inline -nary-reassociate -cross-dso-cfi -add-discriminators -bdce -loop-interchange -redundant-dbg-inst-elim -slp-vectorizer -alignment-from-assumptions -ipsccp -coro-cleanup -lower-widenable-condition -div-rem-pairs -div-rem-pairs -correlated-propagation -loop-deletion -ee-instrument -mem2reg -mem2reg -gvn-hoist -memcpyopt -loop-fusion -inject-tli-mappings -consthoist -loop-instsimplify -strip-debug-declare -loop-instsimplify -slsr -adce -constmerge -loop-guard-widening -loop-fusion -loop-instsimplify -redundant-dbg-inst-elim -lowerinvoke -sccp -speculative-execution -strip-debug-declare -sancov -gvn-hoist -pgo-memop-opt -instcombine -aggressive-instcombine -speculative-execution -instsimplify -reassociate -irce -guard-widening -gvn -inferattrs -elim-avail-extern -alignment-from-assumptions -instnamer -guard-widening -loop-instsimplify -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9933259176863184,11.92369031906128,opt -loop-predication -insert-gcov-profiling -forceattrs -speculative-execution -globalsplit -mldst-motion -pgo-memop-opt -functionattrs -called-value-propagation -loop-guard-widening -aggressive-instcombine -infer-address-spaces -indvars -partially-inline-libcalls -simplifycfg -functionattrs -partially-inline-libcalls -break-crit-edges -loop-vectorize -loop-simplify -adce -loop-interchange -mergefunc -hotcoldsplit -globalopt -partial-inliner -adce -loop-idiom -partial-inliner -coro-early -loop-unswitch -name-anon-globals -add-discriminators -scalarizer -sroa -argpromotion -separate-const-offset-from-gep -mergereturn -loop-instsimplify -pgo-memop-opt -lower-widenable-condition -instsimplify -globaldce -loop-vectorize -coro-split -newgvn -coro-elide -attributor -strip-dead-prototypes -pgo-memop-opt -ipconstprop -dce -dse -loop-distribute -alignment-from-assumptions -lower-guard-intrinsic -correlated-propagation -gvn -loop-vectorize -ipsccp -mergefunc -simplifycfg -ipconstprop -cross-dso-cfi -flattencfg -loop-sink -flattencfg -elim-avail-extern -mldst-motion -loop-guard-widening -simplifycfg -loop-reduce -deadargelim -slp-vectorizer -simplifycfg -loop-sink -loop-fusion -rpo-functionattrs -callsite-splitting -loop-instsimplify -loop-simplifycfg -break-crit-edges -nary-reassociate -constmerge -die -simplifycfg -strip -functionattrs -loop-distribute -loop-reduce -ipconstprop -load-store-vectorizer -loop-interchange -licm -barrier -prune-eh -tailcallelim -scalarizer -loop-guard-widening -float2int -slsr -licm -mldst-motion -called-value-propagation -strip -coro-cleanup -div-rem-pairs -loop-distribute -sroa -loop-unroll -strip-nondebug -lower-constant-intrinsics -constmerge -callsite-splitting -break-crit-edges -rewrite-statepoints-for-gc -forceattrs -flattencfg -instcombine -consthoist -post-inline-ee-instrument -globaldce -float2int -partial-inliner -mergeicmps -aggressive-instcombine -memcpyopt -simplifycfg -gvn input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9966629588431589,14.353923320770264,opt -deadargelim -loweratomic -loop-reduce -div-rem-pairs -jump-threading -loop-interchange -slp-vectorizer -lower-constant-intrinsics -loop-distribute -lower-constant-intrinsics -inferattrs -strip -gvn -simplifycfg -loweratomic -loop-predication -bdce -lower-guard-intrinsic -loop-distribute -ee-instrument -globalsplit -loop-fusion -partial-inliner -loop-simplifycfg -loop-reroll -dse -loop-guard-widening -correlated-propagation -dse -insert-gcov-profiling -called-value-propagation -loop-deletion -loop-vectorize -strip-debug-declare -name-anon-globals -argpromotion -loop-data-prefetch -strip-dead-prototypes -lower-matrix-intrinsics -called-value-propagation -argpromotion -mem2reg -alignment-from-assumptions -dse -flattencfg -partially-inline-libcalls -ee-instrument -flattencfg -loop-load-elim -sroa -ipconstprop -indvars -deadargelim -flattencfg -loop-unroll -post-inline-ee-instrument -loweratomic -early-cse-memssa -globaldce -nary-reassociate -globaldce -break-crit-edges -globalopt -loop-instsimplify -coro-cleanup -indvars -mergereturn -loop-simplifycfg -sccp -reassociate -jump-threading -mergereturn -tailcallelim -break-crit-edges -loop-distribute -coro-early -prune-eh -partially-inline-libcalls -alignment-from-assumptions -loop-versioning-licm -prune-eh -reassociate -loop-versioning -callsite-splitting -nary-reassociate -gvn-hoist -loop-idiom -strip-nondebug -loop-predication -sroa -loop-unroll-and-jam -lower-expect -loop-data-prefetch -prune-eh -inferattrs -licm -mem2reg -memcpyopt -jump-threading -mergefunc -aggressive-instcombine -always-inline -dse -inject-tli-mappings -correlated-propagation -inject-tli-mappings -loop-simplifycfg -break-crit-edges -sroa -div-rem-pairs -globaldce -memcpyopt -rpo-functionattrs -sroa -speculative-execution -loop-predication -mergefunc -hotcoldsplit -strip-nondebug -instcombine -rpo-functionattrs -break-crit-edges -loop-predication -load-store-vectorizer -loop-guard-widening -loop-reduce -strip-debug-declare -loop-vectorize -ee-instrument -constmerge -indvars -mldst-motion -post-inline-ee-instrument -loop-simplifycfg -gvn-hoist -functionattrs -simple-loop-unswitch -mergeicmps -libcalls-shrinkwrap -loop-distribute -ipconstprop -loop-deletion -mldst-motion -deadargelim -simple-loop-unswitch -loweratomic -partial-inliner -strip -elim-avail-extern -coro-cleanup -coro-elide -loop-simplify -elim-avail-extern -scalarizer -loop-unroll -add-discriminators -speculative-execution -strip-debug-declare -instcombine -loop-simplifycfg -post-inline-ee-instrument -break-crit-edges -nary-reassociate -die -div-rem-pairs -simplifycfg -licm -mergeicmps -strip-nondebug -gvn input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9977753058954394,12.289266586303711,opt -correlated-propagation -die -mergefunc -functionattrs -loop-sink -coro-early -strip -loop-unroll -sccp -licm -scalarizer -loop-simplifycfg -coro-early -rpo-functionattrs -strip-dead-prototypes -simplifycfg -argpromotion -speculative-execution -aggressive-instcombine -load-store-vectorizer -name-anon-globals -canonicalize-aliases -callsite-splitting -lower-widenable-condition -loop-load-elim -functionattrs -canonicalize-aliases -deadargelim -tailcallelim -lower-widenable-condition -inject-tli-mappings -loop-versioning -lower-expect -reassociate -early-cse-memssa -elim-avail-extern -break-crit-edges -lower-guard-intrinsic -sink -partially-inline-libcalls -speculative-execution -mergefunc -loop-reroll -loop-distribute -globalopt -separate-const-offset-from-gep -lowerswitch -licm -lower-expect -partially-inline-libcalls -loop-deletion -loop-reduce -globalsplit -hotcoldsplit -redundant-dbg-inst-elim -loop-idiom -sroa -infer-address-spaces -hotcoldsplit -functionattrs -argpromotion -post-inline-ee-instrument -functionattrs -lower-widenable-condition -separate-const-offset-from-gep -always-inline -separate-const-offset-from-gep -constmerge -adce -slp-vectorizer -lower-constant-intrinsics -loop-simplifycfg -constprop -strip-dead-prototypes -loop-unroll -rewrite-statepoints-for-gc -ipsccp -bdce -loop-versioning-licm -jump-threading -reg2mem -licm -rpo-functionattrs -instnamer -newgvn -loop-simplifycfg -loop-vectorize -barrier -scalarizer -loop-guard-widening -post-inline-ee-instrument -loop-interchange -gvn -lower-widenable-condition -loop-versioning -always-inline -instcombine -ipsccp -deadargelim -flattencfg -sccp -loop-deletion -loop-idiom -inferattrs -globalsplit -licm -jump-threading -cross-dso-cfi -irce -always-inline -dce -ipconstprop -dce -jump-threading -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/patricia,1.0022246941045605,12.50986385345459,opt -redundant-dbg-inst-elim -strip-nondebug -flattencfg -loop-unroll-and-jam -correlated-propagation -loop-versioning -loop-vectorize -die -coro-early -hotcoldsplit -ipsccp -functionattrs -lower-constant-intrinsics -gvn -mergeicmps -globaldce -canonicalize-aliases -instsimplify -lowerinvoke -flattencfg -loop-fusion -lower-expect -constmerge -scalarizer -ee-instrument -strip-nondebug -dse -gvn -deadargelim -consthoist -nary-reassociate -slsr -instnamer -reassociate -indvars -memcpyopt -tailcallelim -callsite-splitting -partially-inline-libcalls -instsimplify -correlated-propagation -lower-guard-intrinsic -coro-early -coro-split -canonicalize-aliases -mergefunc -ee-instrument -speculative-execution -loop-fusion -callsite-splitting -partially-inline-libcalls -barrier -libcalls-shrinkwrap -lowerswitch -sccp -add-discriminators -sccp -inject-tli-mappings -div-rem-pairs -reassociate -canonicalize-aliases -loop-versioning-licm -coro-cleanup -instsimplify -coro-cleanup -mergefunc -forceattrs -insert-gcov-profiling -barrier -coro-elide -die -loop-distribute -strip-dead-prototypes -adce -irce -nary-reassociate -instsimplify -loop-load-elim -load-store-vectorizer -rewrite-statepoints-for-gc -speculative-execution -libcalls-shrinkwrap -inferattrs -post-inline-ee-instrument -loop-unroll -mergeicmps -loop-distribute -float2int -speculative-execution -coro-cleanup -nary-reassociate -forceattrs -loop-unroll -mergereturn -post-inline-ee-instrument -post-inline-ee-instrument -loop-unroll-and-jam -mergereturn -lcssa -slsr -simple-loop-unswitch -strip-dead-prototypes -mergeicmps -coro-cleanup -globalsplit -inject-tli-mappings -nary-reassociate -loop-fusion -guard-widening -gvn -sink -always-inline -bdce -separate-const-offset-from-gep -functionattrs -instcombine -loop-distribute -loop-guard-widening -pgo-memop-opt -mergeicmps -mergereturn -canonicalize-aliases -coro-elide -coro-split -coro-elide -gvn-hoist -float2int -flattencfg -loop-simplify -aggressive-instcombine -loop-versioning-licm -loop-predication -mergefunc -ipconstprop -simple-loop-unswitch -libcalls-shrinkwrap -coro-split -loop-data-prefetch -always-inline -bdce -speculative-execution -alignment-from-assumptions -lower-constant-intrinsics -attributor -globalopt -lowerswitch -coro-elide -name-anon-globals -instnamer -elim-avail-extern -dse -ee-instrument -loop-versioning -float2int -loop-simplify -coro-split -always-inline -barrier -tailcallelim -loop-versioning-licm -loop-simplifycfg -called-value-propagation -tailcallelim -always-inline -pgo-memop-opt -globaldce -scalarizer -lower-expect -called-value-propagation -newgvn -separate-const-offset-from-gep -called-value-propagation -sink -name-anon-globals -adce -instcombine -name-anon-globals -guard-widening -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/qsort,1.0959752321981424,12.017142057418823,opt -lowerinvoke -loop-unroll -globalsplit -loop-vectorize -loop-fusion -loop-predication -loop-deletion -lowerswitch -loop-reroll -lowerswitch -lowerswitch -always-inline -loop-interchange -strip -loop-fusion -deadargelim -newgvn -partially-inline-libcalls -lowerswitch -ee-instrument -loop-reroll -loop-unswitch -constmerge -loop-instsimplify -sancov -loop-reroll -mergeicmps -constprop -ipsccp -loop-instsimplify -memcpyopt -strip -nary-reassociate -strip -mem2reg -sink -redundant-dbg-inst-elim -lower-constant-intrinsics -lowerinvoke -coro-early -prune-eh -guard-widening -loop-versioning-licm -loop-simplify -loop-deletion -sroa -canonicalize-aliases -load-store-vectorizer -inferattrs -dce -barrier -loop-deletion -sroa -barrier -loop-unroll-and-jam -lower-expect -bdce -strip-dead-prototypes -dse -elim-avail-extern -bdce -inject-tli-mappings -inject-tli-mappings -gvn-hoist -tailcallelim -loop-predication -irce -dce -coro-elide -deadargelim -load-store-vectorizer -correlated-propagation -aggressive-instcombine -loop-unroll -redundant-dbg-inst-elim -sccp -simplifycfg -loop-versioning -loop-unroll-and-jam -loop-interchange -mem2reg -div-rem-pairs -inject-tli-mappings -flattencfg -barrier -lowerinvoke -memcpyopt -speculative-execution -lowerinvoke -loop-sink -called-value-propagation -slsr -separate-const-offset-from-gep -bdce -bdce -simplifycfg -lower-matrix-intrinsics -libcalls-shrinkwrap -loop-unroll-and-jam -irce -instcombine input.bc -o output.bc -benchmark://cBench-v1/qsort,1.0990712074303406,11.887055158615112,opt -lower-constant-intrinsics -coro-cleanup -loop-instsimplify -mergereturn -pgo-memop-opt -coro-elide -gvn -sink -consthoist -callsite-splitting -dce -partial-inliner -mem2reg -loop-simplify -instnamer -nary-reassociate -simple-loop-unswitch -memcpyopt -flattencfg -alignment-from-assumptions -loop-instsimplify -pgo-memop-opt -insert-gcov-profiling -constprop -loop-versioning -coro-elide -speculative-execution -globalsplit -infer-address-spaces -jump-threading -guard-widening -partially-inline-libcalls -consthoist -break-crit-edges -strip-nondebug -loop-data-prefetch -reassociate -newgvn -coro-split -newgvn -simplifycfg -strip-debug-declare -simplifycfg -lcssa -loop-idiom -coro-elide -loop-predication -loop-load-elim -ee-instrument -reassociate -always-inline -simplifycfg -nary-reassociate -functionattrs -elim-avail-extern -load-store-vectorizer -jump-threading -flattencfg -lower-widenable-condition -instcombine input.bc -o output.bc -benchmark://cBench-v1/qsort,1.1021671826625385,11.789689779281616,opt -early-cse-memssa -attributor -loop-simplify -libcalls-shrinkwrap -reassociate -instnamer -strip-dead-prototypes -functionattrs -mergeicmps -prune-eh -globalsplit -dce -loop-predication -globalsplit -mergereturn -scalarizer -mem2reg -loop-distribute -div-rem-pairs -mergeicmps -partially-inline-libcalls -elim-avail-extern -insert-gcov-profiling -loop-guard-widening -loop-data-prefetch -irce -separate-const-offset-from-gep -barrier -lower-expect -lower-guard-intrinsic -sancov -mergeicmps -partially-inline-libcalls -slsr -sancov -separate-const-offset-from-gep -gvn-hoist -loop-vectorize -load-store-vectorizer -constprop -loop-unroll -aggressive-instcombine -sink -loop-sink -loop-interchange -mergefunc -loop-data-prefetch -simplifycfg -instsimplify -lower-guard-intrinsic -forceattrs -loop-interchange -globaldce -pgo-memop-opt -ipsccp -alignment-from-assumptions -licm -mergefunc -sccp -constprop -infer-address-spaces -insert-gcov-profiling -loop-simplifycfg -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/qsort,1.105263157894737,11.881323337554932,opt -loop-predication -insert-gcov-profiling -strip-nondebug -loop-distribute -licm -instnamer -ipconstprop -coro-elide -loop-guard-widening -loop-versioning-licm -coro-elide -globalopt -mergereturn -mergeicmps -infer-address-spaces -sink -speculative-execution -cross-dso-cfi -slp-vectorizer -argpromotion -gvn-hoist -ipconstprop -constprop -sroa -loop-instsimplify -simplifycfg -instcombine -instcombine -lower-constant-intrinsics -lowerswitch -loop-sink -irce -early-cse-memssa -instnamer -loop-instsimplify -sancov -consthoist -pgo-memop-opt -coro-cleanup -loop-unswitch -loop-instsimplify -lower-expect -load-store-vectorizer -newgvn input.bc -o output.bc -benchmark://cBench-v1/qsort,1.108359133126935,11.847872734069824,opt -correlated-propagation -lower-expect -sink -lowerinvoke -newgvn -sink -break-crit-edges -break-crit-edges -loop-idiom -gvn -called-value-propagation -flattencfg -scalarizer -loop-load-elim -slp-vectorizer -correlated-propagation -sancov -argpromotion -alignment-from-assumptions -strip-nondebug -newgvn -lower-matrix-intrinsics -div-rem-pairs -ee-instrument -ee-instrument -infer-address-spaces -mergereturn -lowerinvoke -simplifycfg -instcombine -licm -rpo-functionattrs -constmerge -loop-deletion -newgvn -cross-dso-cfi -jump-threading input.bc -o output.bc -benchmark://cBench-v1/qsort,1.108359133126935,11.972721815109253,opt -separate-const-offset-from-gep -coro-elide -loop-interchange -indvars -loop-predication -guard-widening -irce -called-value-propagation -globalsplit -redundant-dbg-inst-elim -partially-inline-libcalls -rewrite-statepoints-for-gc -mergereturn -add-discriminators -dce -jump-threading -loop-data-prefetch -redundant-dbg-inst-elim -inject-tli-mappings -mem2reg -loop-versioning-licm -redundant-dbg-inst-elim -insert-gcov-profiling -lowerinvoke -gvn -mldst-motion -simple-loop-unswitch -loop-fusion -constmerge -alignment-from-assumptions -indvars -bdce -tailcallelim -elim-avail-extern -strip-dead-prototypes -die -simple-loop-unswitch -instcombine -partially-inline-libcalls -loweratomic -mergefunc -lowerinvoke -ee-instrument -rpo-functionattrs -lower-constant-intrinsics -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/qsort,1.108359133126935,12.017470836639404,opt -loop-deletion -indvars -loop-reroll -slp-vectorizer -loop-deletion -rewrite-statepoints-for-gc -coro-early -lcssa -loop-versioning -loop-reduce -strip-debug-declare -dce -guard-widening -mem2reg -infer-address-spaces -lower-constant-intrinsics -indvars -constmerge -attributor -lowerswitch -loop-simplifycfg -break-crit-edges -lcssa -dse -die -coro-elide -ipconstprop -alignment-from-assumptions -mergereturn -gvn -sancov -simplifycfg -loop-sink -hotcoldsplit -loop-deletion -lower-guard-intrinsic -float2int -loop-fusion -add-discriminators -instcombine -gvn-hoist -loop-idiom -gvn input.bc -o output.bc -benchmark://cBench-v1/qsort,1.108359133126935,12.212085723876953,opt -loop-vectorize -strip -globalsplit -loop-reroll -guard-widening -gvn -post-inline-ee-instrument -globalopt -bdce -mergeicmps -sancov -loop-guard-widening -sancov -break-crit-edges -tailcallelim -canonicalize-aliases -strip -add-discriminators -globalopt -globalsplit -flattencfg -loweratomic -globalsplit -attributor -mergeicmps -cross-dso-cfi -loop-simplify -sancov -partial-inliner -strip-debug-declare -prune-eh -argpromotion -gvn -reg2mem -attributor -mem2reg -forceattrs -newgvn -coro-early -strip-nondebug -loop-reroll -strip-debug-declare -loop-unswitch -loop-unroll -lower-widenable-condition -licm -loop-distribute -loop-distribute -loop-reroll -sancov -lower-constant-intrinsics -loop-deletion -coro-split -bdce -mem2reg -loop-simplify -canonicalize-aliases -mldst-motion -loop-sink -gvn-hoist -inject-tli-mappings -loop-instsimplify -mergereturn -coro-early -constmerge -constprop -instnamer -lower-matrix-intrinsics -partial-inliner -float2int -flattencfg -die -lower-constant-intrinsics -add-discriminators -lcssa -add-discriminators -mldst-motion -coro-elide -instsimplify -div-rem-pairs -instcombine -loop-predication -strip -insert-gcov-profiling -indvars -lowerswitch -nary-reassociate -dce -loweratomic -insert-gcov-profiling -libcalls-shrinkwrap -mldst-motion -instcombine -lower-widenable-condition -inject-tli-mappings -globalopt -lowerinvoke -gvn-hoist -strip-nondebug -loop-simplifycfg -elim-avail-extern -loop-distribute -rpo-functionattrs -memcpyopt -globalopt -barrier -consthoist -simple-loop-unswitch -load-store-vectorizer -sancov -partially-inline-libcalls -lower-constant-intrinsics -pgo-memop-opt -canonicalize-aliases -deadargelim -load-store-vectorizer -loop-interchange -mem2reg -memcpyopt -strip-nondebug -infer-address-spaces -simple-loop-unswitch -jump-threading -name-anon-globals -pgo-memop-opt -mergeicmps -instcombine -ipconstprop -sink -argpromotion -adce -cross-dso-cfi -partially-inline-libcalls -tailcallelim -sccp -infer-address-spaces -inject-tli-mappings -mergefunc -strip-debug-declare -loop-data-prefetch -flattencfg -dce -nary-reassociate -coro-cleanup -die -strip-dead-prototypes -newgvn -attributor -instnamer -early-cse-memssa -mergeicmps -ee-instrument -forceattrs -loop-simplify -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/qsort,1.1145510835913313,11.989583253860474,opt -coro-cleanup -reg2mem -rewrite-statepoints-for-gc -dse -partially-inline-libcalls -jump-threading -gvn-hoist -consthoist -pgo-memop-opt -loweratomic -guard-widening -globalopt -deadargelim -scalarizer -strip-debug-declare -tailcallelim -loop-reduce -coro-split -mem2reg -add-discriminators -loweratomic -loop-sink -globaldce -sancov -sink -load-store-vectorizer -loop-unroll -hotcoldsplit -add-discriminators -strip-dead-prototypes -gvn-hoist -div-rem-pairs -jump-threading -coro-cleanup -constmerge -slsr -gvn -lower-constant-intrinsics -lower-expect -rewrite-statepoints-for-gc -div-rem-pairs -cross-dso-cfi -infer-address-spaces -ee-instrument -nary-reassociate -loop-unswitch -sancov -loop-reroll -rpo-functionattrs -slp-vectorizer -insert-gcov-profiling -simple-loop-unswitch -lowerswitch -consthoist -argpromotion -instcombine -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/qsort,1.1207430340557278,11.769915342330933,opt -separate-const-offset-from-gep -loop-fusion -forceattrs -always-inline -slsr -loop-interchange -argpromotion -loop-load-elim -float2int -flattencfg -speculative-execution -sroa -div-rem-pairs -always-inline -float2int -mergefunc -dce -newgvn -lower-constant-intrinsics -strip-dead-prototypes -coro-split -constmerge -lower-matrix-intrinsics -lower-widenable-condition -lcssa -always-inline -instcombine -name-anon-globals -float2int -attributor -loop-interchange -post-inline-ee-instrument -coro-elide -loweratomic -newgvn -instcombine -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.093522422384055,12.692811965942383,opt -mergefunc -rpo-functionattrs -newgvn -strip-dead-prototypes -separate-const-offset-from-gep -loop-data-prefetch -loop-versioning -canonicalize-aliases -lower-matrix-intrinsics -mem2reg -instcombine -post-inline-ee-instrument -globaldce -reassociate -mergereturn -instcombine -gvn-hoist -instcombine -deadargelim -strip-nondebug -float2int -dce -memcpyopt -separate-const-offset-from-gep -hotcoldsplit -loop-data-prefetch -loop-simplify -attributor -partially-inline-libcalls -loop-interchange -die -bdce -break-crit-edges -bdce -mergeicmps -infer-address-spaces -strip-debug-declare -strip -speculative-execution -coro-cleanup -coro-early -canonicalize-aliases -loop-guard-widening -slp-vectorizer -mem2reg -loop-simplify -name-anon-globals -callsite-splitting -functionattrs -libcalls-shrinkwrap -globalopt -loop-rotate -slsr -speculative-execution -strip-nondebug -lowerinvoke -loop-guard-widening -mergeicmps -called-value-propagation -flattencfg -strip-nondebug -gvn -cross-dso-cfi -insert-gcov-profiling -loop-data-prefetch -simplifycfg -deadargelim -slsr -inferattrs -globaldce -rewrite-statepoints-for-gc -post-inline-ee-instrument -memcpyopt -constmerge -consthoist -speculative-execution -lower-matrix-intrinsics -coro-cleanup -gvn-hoist -adce -loop-instsimplify -loweratomic -early-cse-memssa -instcombine input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.0946722882330395,12.9319007396698,opt -loop-data-prefetch -sink -mldst-motion -consthoist -loop-versioning -consthoist -reassociate -guard-widening -div-rem-pairs -rewrite-statepoints-for-gc -ipconstprop -instnamer -add-discriminators -slp-vectorizer -flattencfg -functionattrs -loop-unroll -loop-data-prefetch -separate-const-offset-from-gep -ee-instrument -callsite-splitting -strip-nondebug -irce -name-anon-globals -loop-distribute -ipconstprop -loop-instsimplify -constmerge -attributor -gvn-hoist -loop-unswitch -loop-distribute -aggressive-instcombine -loop-interchange -dse -instsimplify -consthoist -mem2reg -lower-expect -loop-unroll-and-jam -gvn-hoist -newgvn -argpromotion -float2int -coro-early -called-value-propagation -loop-fusion -mldst-motion -elim-avail-extern -loop-simplifycfg -loop-load-elim -strip-nondebug -simplifycfg -coro-elide -loop-idiom -barrier -lowerinvoke -die -constprop -callsite-splitting -barrier -guard-widening -loweratomic -mem2reg -name-anon-globals -loop-predication -ipsccp -lower-matrix-intrinsics -prune-eh -gvn -always-inline -cross-dso-cfi -loop-interchange -dse -argpromotion -instcombine input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.0965887313146796,12.338773727416992,opt -loop-predication -loop-predication -infer-address-spaces -loop-unroll-and-jam -prune-eh -loop-reduce -constmerge -mergeicmps -loop-distribute -attributor -lowerinvoke -loop-deletion -loop-sink -coro-elide -reg2mem -licm -constmerge -instsimplify -mergefunc -reg2mem -sancov -bdce -strip -forceattrs -div-rem-pairs -loop-distribute -loop-data-prefetch -functionattrs -loop-idiom -loop-versioning -correlated-propagation -inject-tli-mappings -partial-inliner -licm -loweratomic -strip-nondebug -coro-cleanup -reg2mem -ipconstprop -loop-deletion -loop-deletion -lower-expect -constprop -coro-split -strip-nondebug -name-anon-globals -name-anon-globals -break-crit-edges -simple-loop-unswitch -sink -globaldce -sccp -reg2mem -loop-load-elim -speculative-execution -sroa -inferattrs -strip-dead-prototypes -early-cse-memssa -deadargelim -name-anon-globals -prune-eh -gvn-hoist -loop-data-prefetch -coro-elide -strip-debug-declare -constmerge -slp-vectorizer -partially-inline-libcalls -callsite-splitting -loop-deletion -simplifycfg -loop-guard-widening -early-cse-memssa -ipconstprop -break-crit-edges -rpo-functionattrs -loop-versioning-licm -coro-early -mem2reg -strip-debug-declare -instsimplify -callsite-splitting -forceattrs -simplifycfg -deadargelim -jump-threading -lower-guard-intrinsic -loop-distribute -dse -tailcallelim -constmerge -rewrite-statepoints-for-gc -elim-avail-extern -lower-matrix-intrinsics -dce -partially-inline-libcalls -insert-gcov-profiling -name-anon-globals -partially-inline-libcalls -infer-address-spaces -coro-split -loop-sink -gvn -lower-expect -simple-loop-unswitch -loop-versioning -loop-deletion -constprop -rpo-functionattrs -jump-threading -speculative-execution -lcssa -lcssa -hotcoldsplit -insert-gcov-profiling -elim-avail-extern -lower-matrix-intrinsics -loop-unroll-and-jam -elim-avail-extern -reassociate -instcombine input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.0969720199310082,13.111221075057983,opt -functionattrs -loop-simplify -early-cse-memssa -sccp -dce -loweratomic -tailcallelim -bdce -cross-dso-cfi -inject-tli-mappings -loop-unswitch -instsimplify -loop-versioning -aggressive-instcombine -bdce -gvn-hoist -lower-widenable-condition -argpromotion -elim-avail-extern -coro-cleanup -elim-avail-extern -instnamer -lower-widenable-condition -loop-versioning -loop-interchange -forceattrs -lowerinvoke -lcssa -bdce -nary-reassociate -add-discriminators -correlated-propagation -sancov -name-anon-globals -globalsplit -loop-instsimplify -tailcallelim -sroa -loop-unroll-and-jam -partially-inline-libcalls -mergefunc -deadargelim -ipsccp -early-cse-memssa -lower-matrix-intrinsics -scalarizer -redundant-dbg-inst-elim -lower-matrix-intrinsics -newgvn -globalsplit -loop-rotate -infer-address-spaces -correlated-propagation -infer-address-spaces -sccp -sroa -instcombine -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.097355308547336,12.750953435897827,opt -sroa -elim-avail-extern -coro-split -canonicalize-aliases -float2int -simple-loop-unswitch -correlated-propagation -pgo-memop-opt -rewrite-statepoints-for-gc -alignment-from-assumptions -die -cross-dso-cfi -newgvn -simplifycfg -loweratomic -insert-gcov-profiling -deadargelim -separate-const-offset-from-gep -float2int -loop-load-elim -barrier -separate-const-offset-from-gep -bdce -instcombine input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.0992717516289765,12.554092168807983,opt -tailcallelim -globalopt -post-inline-ee-instrument -dse -correlated-propagation -lowerinvoke -mergefunc -mldst-motion -irce -lower-widenable-condition -callsite-splitting -coro-early -rpo-functionattrs -strip-dead-prototypes -coro-cleanup -flattencfg -alignment-from-assumptions -lower-matrix-intrinsics -globaldce -coro-early -loop-instsimplify -lowerinvoke -mldst-motion -canonicalize-aliases -globalopt -lower-constant-intrinsics -simplifycfg -hotcoldsplit -gvn-hoist -flattencfg -memcpyopt -tailcallelim -sroa -partially-inline-libcalls -strip -hotcoldsplit -newgvn -loop-idiom -dse -dse -instcombine -slp-vectorizer -slp-vectorizer -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.099271751628977,12.885164499282837,opt -coro-early -loop-instsimplify -argpromotion -strip-dead-prototypes -loop-simplify -sccp -bdce -constprop -mergereturn -separate-const-offset-from-gep -libcalls-shrinkwrap -jump-threading -loop-reduce -indvars -functionattrs -lowerinvoke -alignment-from-assumptions -constprop -functionattrs -strip-dead-prototypes -loop-data-prefetch -inject-tli-mappings -bdce -coro-cleanup -dse -lowerinvoke -tailcallelim -sroa -instsimplify -consthoist -loop-simplifycfg -sancov -libcalls-shrinkwrap -gvn -loop-data-prefetch -partially-inline-libcalls -coro-early -dce -instcombine -mergeicmps -attributor -partial-inliner -mldst-motion -instnamer -loop-load-elim -lower-expect -correlated-propagation -speculative-execution -coro-split -cross-dso-cfi -indvars -early-cse-memssa -canonicalize-aliases -gvn-hoist -redundant-dbg-inst-elim -lcssa -simple-loop-unswitch -lower-widenable-condition -coro-early -loop-distribute -constprop -coro-split -pgo-memop-opt -lower-constant-intrinsics -infer-address-spaces -loop-fusion -constmerge -nary-reassociate -inject-tli-mappings -cross-dso-cfi -mergereturn -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.1004216174779609,15.460011005401611,opt -die -infer-address-spaces -loop-unroll -sroa -elim-avail-extern -cross-dso-cfi -mldst-motion -barrier -mergefunc -loop-sink -aggressive-instcombine -correlated-propagation -scalarizer -scalarizer -break-crit-edges -add-discriminators -lower-guard-intrinsic -instcombine -barrier -pgo-memop-opt -float2int -called-value-propagation -sccp -lower-guard-intrinsic -speculative-execution -elim-avail-extern -mergefunc -loop-simplify -coro-split -globalopt -infer-address-spaces -adce -loop-idiom -ipconstprop -loop-guard-widening -indvars -lower-expect -aggressive-instcombine -loop-idiom -deadargelim -cross-dso-cfi -insert-gcov-profiling -lower-widenable-condition -loop-reroll -ipsccp -break-crit-edges -early-cse-memssa -loop-reroll -div-rem-pairs -canonicalize-aliases -functionattrs -die -forceattrs -coro-early -tailcallelim -adce -prune-eh -inject-tli-mappings -guard-widening -slsr -gvn -sroa -loop-load-elim -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.1004216174779613,12.831381559371948,opt -instcombine -float2int -globalopt -redundant-dbg-inst-elim -lower-matrix-intrinsics -loop-versioning -argpromotion -rpo-functionattrs -loop-interchange -loop-data-prefetch -barrier -aggressive-instcombine -loop-simplifycfg -aggressive-instcombine -rewrite-statepoints-for-gc -canonicalize-aliases -mergeicmps -barrier -partially-inline-libcalls -always-inline -aggressive-instcombine -gvn-hoist -insert-gcov-profiling -ipsccp -sink -loop-instsimplify -loop-guard-widening -argpromotion -lower-guard-intrinsic -hotcoldsplit -mergefunc -ipconstprop -redundant-dbg-inst-elim -sroa -lowerinvoke -slsr -newgvn -dce -break-crit-edges -simplifycfg -infer-address-spaces -instnamer -functionattrs -die -die -scalarizer -infer-address-spaces -strip -lowerinvoke -jump-threading -correlated-propagation -libcalls-shrinkwrap -constmerge -loweratomic -lower-expect -loop-reroll -scalarizer -ipsccp -ee-instrument -lower-widenable-condition -instcombine input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.1023380605596014,14.866809129714966,opt -mergeicmps -mergereturn -strip-debug-declare -globaldce -mergereturn -loop-instsimplify -alignment-from-assumptions -float2int -slp-vectorizer -sccp -flattencfg -callsite-splitting -infer-address-spaces -always-inline -loop-simplifycfg -flattencfg -newgvn -mem2reg -cross-dso-cfi -lower-matrix-intrinsics -instcombine -early-cse-memssa -reassociate -infer-address-spaces -rewrite-statepoints-for-gc -loop-simplifycfg -instnamer -coro-cleanup -loop-data-prefetch -loop-versioning-licm -correlated-propagation -loop-reroll -strip-nondebug -irce -loop-versioning-licm -ipconstprop -functionattrs -simplifycfg -argpromotion -sroa -memcpyopt -name-anon-globals -lcssa -sink -die -loop-simplify -forceattrs -strip -reg2mem -irce -loop-deletion -slsr -elim-avail-extern -mem2reg -lower-expect -lowerinvoke -coro-split -coro-split -dce -strip-dead-prototypes -float2int -loop-instsimplify -ipsccp -loweratomic -loop-predication -newgvn -ipconstprop -mergeicmps -float2int -simple-loop-unswitch -licm -ipsccp -loop-distribute -mergefunc -slsr -inject-tli-mappings -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/sha,1.4682274247491636,11.895204067230225,opt -lowerswitch -loop-reduce -mergefunc -reg2mem -infer-address-spaces -licm -pgo-memop-opt -lowerinvoke -insert-gcov-profiling -early-cse-memssa -aggressive-instcombine -inferattrs -canonicalize-aliases -div-rem-pairs -slsr -instnamer -load-store-vectorizer -loop-instsimplify -aggressive-instcombine -mem2reg -loop-distribute -attributor -argpromotion -loweratomic -instsimplify -loop-guard-widening -ee-instrument -lowerswitch -indvars -cross-dso-cfi -irce -break-crit-edges -loop-simplify -always-inline -constprop -dse -ipsccp -correlated-propagation -mergeicmps -loop-vectorize -mem2reg -ee-instrument -guard-widening -sink -instsimplify -loop-guard-widening -loop-predication -strip-nondebug -irce -simplifycfg -scalarizer -slp-vectorizer -forceattrs -float2int -newgvn input.bc -o output.bc -benchmark://cBench-v1/sha,1.4715719063545152,11.981029510498047,opt -mem2reg -div-rem-pairs -inject-tli-mappings -forceattrs -mergeicmps -dce -loop-unroll-and-jam -loop-fusion -loop-versioning -aggressive-instcombine -break-crit-edges -simplifycfg -irce -loop-sink -guard-widening -loop-sink -break-crit-edges -div-rem-pairs -separate-const-offset-from-gep -scalarizer -inferattrs -flattencfg -loweratomic -bdce -instcombine -post-inline-ee-instrument -lcssa -add-discriminators -flattencfg -instcombine -loop-reroll -inject-tli-mappings -elim-avail-extern -loop-versioning-licm -coro-elide -partial-inliner -loop-reroll -loop-data-prefetch -lower-matrix-intrinsics -correlated-propagation -consthoist -instnamer -partially-inline-libcalls -lower-matrix-intrinsics -lowerswitch -loop-versioning-licm -canonicalize-aliases -prune-eh -globalsplit -rewrite-statepoints-for-gc -ipsccp -jump-threading -coro-split -newgvn -memcpyopt -loop-versioning-licm -slp-vectorizer -reassociate -simplifycfg -newgvn -lcssa -simplifycfg -lower-matrix-intrinsics -dce -aggressive-instcombine -loop-distribute -loop-data-prefetch -infer-address-spaces -irce -instsimplify -lower-expect -correlated-propagation -sancov -alignment-from-assumptions -adce -tailcallelim -functionattrs -partial-inliner -bdce -strip-nondebug -ipconstprop -globalsplit -cross-dso-cfi -coro-early -instcombine -coro-early -bdce -loop-unroll-and-jam -sroa -aggressive-instcombine -loweratomic -indvars -loop-data-prefetch -cross-dso-cfi -coro-early -globalopt -canonicalize-aliases -break-crit-edges -insert-gcov-profiling -redundant-dbg-inst-elim -loop-deletion -reassociate -loop-distribute -simplifycfg -div-rem-pairs -loop-fusion -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/sha,1.474916387959866,11.905332565307617,opt -coro-cleanup -gvn -inferattrs -loop-versioning -name-anon-globals -simplifycfg -loop-interchange -div-rem-pairs -loop-deletion -mergefunc -ee-instrument -dce -flattencfg -mldst-motion -callsite-splitting -sccp -consthoist -functionattrs -attributor -aggressive-instcombine -loop-instsimplify -loop-deletion -mem2reg -mergefunc -flattencfg -rewrite-statepoints-for-gc -name-anon-globals -strip -bdce -prune-eh -lower-widenable-condition -loop-vectorize -sccp -instsimplify -mldst-motion -instnamer -div-rem-pairs -mldst-motion -canonicalize-aliases -newgvn -lower-constant-intrinsics -sink -indvars -alignment-from-assumptions -argpromotion -rewrite-statepoints-for-gc -early-cse-memssa -attributor -post-inline-ee-instrument -early-cse-memssa -loop-guard-widening -constmerge -lower-constant-intrinsics -prune-eh -strip -rpo-functionattrs -instcombine input.bc -o output.bc -benchmark://cBench-v1/sha,1.4749163879598663,11.936026334762573,opt -strip -always-inline -lower-expect -partially-inline-libcalls -gvn-hoist -loop-guard-widening -instnamer -reg2mem -slsr -loop-unroll -instnamer -slp-vectorizer -cross-dso-cfi -loop-distribute -called-value-propagation -ee-instrument -jump-threading -rewrite-statepoints-for-gc -loop-data-prefetch -globalsplit -partial-inliner -rpo-functionattrs -strip -strip-debug-declare -lower-guard-intrinsic -loop-distribute -ipconstprop -partially-inline-libcalls -irce -speculative-execution -flattencfg -redundant-dbg-inst-elim -loop-instsimplify -functionattrs -loop-reroll -hotcoldsplit -insert-gcov-profiling -loop-reroll -lower-expect -consthoist -lower-matrix-intrinsics -early-cse-memssa -prune-eh -loop-distribute -globalsplit -inject-tli-mappings -irce -mergefunc -hotcoldsplit -argpromotion -name-anon-globals -loop-simplifycfg -partially-inline-libcalls -slsr -barrier -flattencfg -post-inline-ee-instrument -sink -loop-vectorize -loop-vectorize -coro-cleanup -lowerinvoke -inject-tli-mappings -canonicalize-aliases -float2int -lowerswitch -indvars -lower-matrix-intrinsics -lowerinvoke -redundant-dbg-inst-elim -prune-eh -aggressive-instcombine -hotcoldsplit -strip-debug-declare -early-cse-memssa -licm -load-store-vectorizer -insert-gcov-profiling -sancov -pgo-memop-opt -sink -barrier -mem2reg -strip-debug-declare -cross-dso-cfi -callsite-splitting -gvn -simplifycfg -licm -memcpyopt -ipconstprop -lowerswitch -loop-guard-widening -functionattrs -loop-interchange -coro-elide -simple-loop-unswitch -separate-const-offset-from-gep -instcombine -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/sha,1.4782608695652173,11.766895771026611,opt -alignment-from-assumptions -sroa -indvars -adce -jump-threading -add-discriminators -ipconstprop -div-rem-pairs -bdce -instnamer -indvars -simplifycfg -mem2reg -lower-widenable-condition -loop-interchange -sancov -argpromotion -inject-tli-mappings -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/sha,1.4782608695652173,12.040958642959595,opt -instcombine -loop-sink -functionattrs -strip -jump-threading -insert-gcov-profiling -lower-guard-intrinsic -simple-loop-unswitch -mldst-motion -loop-reduce -strip-dead-prototypes -slsr -partial-inliner -loop-data-prefetch -argpromotion -mldst-motion -always-inline -pgo-memop-opt -mergeicmps -mergeicmps -attributor -lower-expect -called-value-propagation -coro-cleanup -barrier -loop-unswitch -lowerinvoke -ipconstprop -inject-tli-mappings -lower-widenable-condition -loop-unroll -loop-predication -loop-simplify -mergefunc -loop-unroll -elim-avail-extern -rpo-functionattrs -licm -loop-distribute -simplifycfg -loop-load-elim -scalarizer -bdce -coro-cleanup -gvn -licm -strip-debug-declare -early-cse-memssa -loop-unroll-and-jam -add-discriminators -reg2mem -gvn -instsimplify -rewrite-statepoints-for-gc -strip -canonicalize-aliases -sccp -simplifycfg -simplifycfg -lower-widenable-condition -bdce -sroa -loop-distribute -loop-versioning -redundant-dbg-inst-elim -guard-widening -adce -constprop -insert-gcov-profiling -load-store-vectorizer -pgo-memop-opt -attributor -ee-instrument -loop-fusion -prune-eh -slsr -inferattrs -loop-deletion -loop-load-elim -loweratomic -strip-debug-declare -functionattrs -insert-gcov-profiling -libcalls-shrinkwrap -loop-unroll-and-jam -barrier -functionattrs -scalarizer -loop-instsimplify -loop-guard-widening -die -aggressive-instcombine -nary-reassociate -indvars -simple-loop-unswitch -scalarizer -strip -loop-guard-widening -scalarizer -load-store-vectorizer -lowerinvoke -lowerinvoke -coro-cleanup -instcombine input.bc -o output.bc -benchmark://cBench-v1/sha,1.4849498327759196,12.055265426635742,opt -simplifycfg -ipsccp -aggressive-instcombine -loweratomic -licm -loop-interchange -deadargelim -canonicalize-aliases -break-crit-edges -alignment-from-assumptions -loop-simplifycfg -barrier -strip-nondebug -gvn -flattencfg -coro-split -load-store-vectorizer -strip -ipsccp -instcombine -redundant-dbg-inst-elim -libcalls-shrinkwrap -correlated-propagation -forceattrs -partially-inline-libcalls -ipconstprop -constprop -mergereturn -newgvn -lower-guard-intrinsic -load-store-vectorizer -sroa -lowerswitch -strip-debug-declare -adce -separate-const-offset-from-gep -inject-tli-mappings -load-store-vectorizer -always-inline -libcalls-shrinkwrap -correlated-propagation -ipconstprop -loop-fusion -globalopt -slp-vectorizer -partially-inline-libcalls -forceattrs -newgvn -elim-avail-extern -early-cse-memssa -globaldce -inject-tli-mappings -aggressive-instcombine -separate-const-offset-from-gep -alignment-from-assumptions -name-anon-globals -attributor -globalopt -loop-reroll -lower-matrix-intrinsics -called-value-propagation -indvars -elim-avail-extern -loop-interchange -mem2reg -loop-load-elim -instcombine input.bc -o output.bc -benchmark://cBench-v1/sha,1.4949832775919731,11.823912382125854,opt -pgo-memop-opt -aggressive-instcombine -lower-widenable-condition -dce -strip-debug-declare -globaldce -partial-inliner -simplifycfg -div-rem-pairs -slsr -infer-address-spaces -separate-const-offset-from-gep -newgvn -loop-unroll-and-jam -inferattrs -barrier -coro-cleanup -loop-predication -instcombine -early-cse-memssa -reg2mem -lower-widenable-condition -infer-address-spaces -sancov -alignment-from-assumptions -early-cse-memssa -name-anon-globals -lower-widenable-condition -dce -tailcallelim -loop-data-prefetch -loop-instsimplify -loop-simplifycfg -instnamer -cross-dso-cfi -mem2reg -coro-elide -loop-distribute -called-value-propagation -always-inline -alignment-from-assumptions -strip-dead-prototypes -irce -lower-guard-intrinsic -load-store-vectorizer -insert-gcov-profiling -loop-instsimplify -die -loop-rotate -nary-reassociate -post-inline-ee-instrument -separate-const-offset-from-gep -div-rem-pairs -coro-split -loop-sink -redundant-dbg-inst-elim -partially-inline-libcalls -die -loop-unroll-and-jam -loweratomic -hotcoldsplit -coro-cleanup -libcalls-shrinkwrap -mergefunc -simple-loop-unswitch -ee-instrument -simplifycfg -coro-cleanup -lcssa -simple-loop-unswitch -deadargelim -instcombine -loweratomic -nary-reassociate -guard-widening -separate-const-offset-from-gep -constmerge -redundant-dbg-inst-elim -instsimplify -dse -functionattrs -newgvn -licm -flattencfg -callsite-splitting -loop-fusion -strip-dead-prototypes -instsimplify -callsite-splitting -simplifycfg -dse -lower-constant-intrinsics -gvn-hoist -mergereturn -memcpyopt -dce -loop-idiom -loop-instsimplify -rewrite-statepoints-for-gc -hotcoldsplit -speculative-execution -licm -speculative-execution -argpromotion -newgvn -adce -sancov -rpo-functionattrs -instnamer -redundant-dbg-inst-elim -coro-cleanup -name-anon-globals -sroa -always-inline -partially-inline-libcalls -guard-widening -loop-idiom -strip-dead-prototypes -constprop -mergereturn -loop-interchange -separate-const-offset-from-gep -barrier -alignment-from-assumptions -bdce -loop-unroll-and-jam -gvn-hoist -attributor -reassociate -loop-data-prefetch -simplifycfg -div-rem-pairs -mergeicmps -mem2reg -elim-avail-extern -simplifycfg -adce -loop-idiom -nary-reassociate -loop-data-prefetch -indvars -sccp -gvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/sha,1.5050167224080264,11.817471742630005,opt -simplifycfg -partially-inline-libcalls -partial-inliner -loweratomic -lower-widenable-condition -separate-const-offset-from-gep -float2int -partial-inliner -lower-expect -sccp -hotcoldsplit -infer-address-spaces -loop-unswitch -gvn -barrier -separate-const-offset-from-gep -mergefunc -lower-constant-intrinsics -lower-matrix-intrinsics -indvars -functionattrs -called-value-propagation -mergeicmps -gvn-hoist -globalsplit -memcpyopt -loweratomic -partially-inline-libcalls -lowerinvoke -hotcoldsplit -die -loop-distribute -strip-dead-prototypes -coro-split -loop-distribute -loop-vectorize -loop-vectorize -die -coro-split -argpromotion -loop-deletion -early-cse-memssa -lower-guard-intrinsic -loop-simplify -lower-expect -loop-data-prefetch -attributor -ee-instrument -reassociate -coro-elide -correlated-propagation -div-rem-pairs -break-crit-edges -coro-cleanup -lower-widenable-condition -name-anon-globals -instcombine -reg2mem -jump-threading -callsite-splitting -loop-fusion -instnamer -early-cse-memssa -post-inline-ee-instrument -alignment-from-assumptions -speculative-execution -dce -bdce -libcalls-shrinkwrap -sroa -partial-inliner -reg2mem -mergefunc -sccp -break-crit-edges -loop-unroll-and-jam -lower-constant-intrinsics -flattencfg -pgo-memop-opt -tailcallelim -coro-split -indvars -sroa -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/sha,1.5050167224080266,11.961605548858643,opt -coro-elide -barrier -ipconstprop -loop-data-prefetch -rpo-functionattrs -loop-reduce -rpo-functionattrs -speculative-execution -constmerge -strip-debug-declare -break-crit-edges -reg2mem -mldst-motion -lower-guard-intrinsic -argpromotion -always-inline -loop-distribute -sancov -always-inline -mergeicmps -globalsplit -strip-debug-declare -div-rem-pairs -add-discriminators -irce -loop-distribute -cross-dso-cfi -functionattrs -load-store-vectorizer -aggressive-instcombine -simplifycfg -elim-avail-extern -separate-const-offset-from-gep -loop-guard-widening -tailcallelim -newgvn -always-inline -mergefunc -coro-early -loweratomic -loop-predication -strip-debug-declare -lowerswitch -consthoist -gvn -jump-threading -break-crit-edges -sccp -loop-fusion -deadargelim -tailcallelim -rewrite-statepoints-for-gc -lcssa -sancov -inject-tli-mappings -early-cse-memssa -instcombine -ee-instrument -mergefunc -loop-distribute -sancov -loop-guard-widening -barrier -div-rem-pairs -consthoist -aggressive-instcombine -deadargelim -loop-simplify -called-value-propagation -always-inline -inject-tli-mappings -simplifycfg -strip -insert-gcov-profiling -redundant-dbg-inst-elim -constprop -canonicalize-aliases -memcpyopt -tailcallelim -jump-threading -coro-elide -name-anon-globals -dse -loop-versioning -insert-gcov-profiling -loop-unroll-and-jam -slp-vectorizer -indvars -inferattrs -argpromotion -sccp -lower-expect -loop-idiom -dce -flattencfg -coro-split -scalarizer -functionattrs -callsite-splitting -canonicalize-aliases -barrier -elim-avail-extern -tailcallelim -loop-guard-widening -loop-fusion -lcssa -lowerswitch -instcombine -simplifycfg -slsr -ipconstprop -correlated-propagation -indvars -flattencfg -name-anon-globals -lowerinvoke -canonicalize-aliases -consthoist -attributor -coro-elide -scalarizer -ipsccp -partially-inline-libcalls -instsimplify -coro-elide -rewrite-statepoints-for-gc -strip-dead-prototypes -scalarizer -canonicalize-aliases -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/stringsearch,0.9767759562841531,12.063631057739258,opt -globalopt -loop-deletion -float2int -reassociate -lower-matrix-intrinsics -loop-guard-widening -strip -ee-instrument -deadargelim -lower-widenable-condition -post-inline-ee-instrument -coro-cleanup -elim-avail-extern -die -mem2reg -early-cse-memssa -guard-widening -loop-vectorize -constmerge -rewrite-statepoints-for-gc -rewrite-statepoints-for-gc -dse -loop-unroll -instcombine -loop-distribute -prune-eh -functionattrs -globalopt -flattencfg -ee-instrument -partially-inline-libcalls -adce -argpromotion -consthoist -consthoist -instcombine -called-value-propagation -simplifycfg -gvn input.bc -o output.bc -benchmark://cBench-v1/stringsearch,0.9795081967213116,11.88592791557312,opt -loop-rotate -loop-reroll -loop-unroll-and-jam -consthoist -loop-rotate -adce -loop-sink -ipsccp -loop-instsimplify -mem2reg -mergeicmps -reassociate -loop-load-elim -mergereturn -sroa -loop-simplifycfg -loop-data-prefetch -mergefunc -flattencfg -newgvn -loop-idiom -loop-vectorize -coro-split -deadargelim -globalsplit -die -loop-fusion -loop-instsimplify -dce -loop-predication -mergeicmps -sink -simple-loop-unswitch -globalsplit -guard-widening -mem2reg -jump-threading -loop-simplifycfg -lower-expect -post-inline-ee-instrument -lower-constant-intrinsics -always-inline -constprop -inject-tli-mappings -gvn-hoist -mergefunc -strip -lower-widenable-condition -simplifycfg -barrier -adce -instcombine input.bc -o output.bc -benchmark://cBench-v1/stringsearch,0.9808743169398909,12.13899278640747,opt -newgvn -slsr -lowerinvoke -lowerinvoke -loop-distribute -lower-guard-intrinsic -globaldce -memcpyopt -sancov -callsite-splitting -callsite-splitting -inject-tli-mappings -licm -early-cse-memssa -loop-simplify -loop-deletion -lowerinvoke -ipsccp -speculative-execution -scalarizer -loop-guard-widening -jump-threading -attributor -flattencfg -licm -insert-gcov-profiling -slsr -jump-threading -mergereturn -alignment-from-assumptions -reassociate -indvars -loop-simplifycfg -constprop -sancov -loop-unroll -loop-reroll -jump-threading -guard-widening -simplifycfg -partially-inline-libcalls -constprop -hotcoldsplit -loop-instsimplify -partially-inline-libcalls -pgo-memop-opt -name-anon-globals -coro-early -mergeicmps -indvars -sccp -simplifycfg -reassociate -bdce -loop-vectorize -jump-threading -lowerswitch -correlated-propagation -ipsccp -loop-unroll-and-jam -loop-unroll -strip -inline -inject-tli-mappings -gvn-hoist -loop-data-prefetch -alignment-from-assumptions -sccp -bdce -loop-interchange -functionattrs -infer-address-spaces -forceattrs -strip-debug-declare -lcssa -break-crit-edges -lower-guard-intrinsic -slsr -strip-dead-prototypes -loop-distribute -lower-guard-intrinsic -break-crit-edges -partially-inline-libcalls -nary-reassociate -reassociate -dce -loop-unroll-and-jam -argpromotion -lower-expect -loop-data-prefetch -lower-expect -always-inline -loop-simplify -add-discriminators -irce -slp-vectorizer -name-anon-globals -ee-instrument -newgvn -gvn-hoist -inject-tli-mappings -lower-guard-intrinsic -licm -simplifycfg -loop-instsimplify -partial-inliner -lower-widenable-condition -flattencfg -rewrite-statepoints-for-gc -loop-instsimplify -lowerswitch -gvn -lowerinvoke -loop-instsimplify -lowerswitch -guard-widening -lower-widenable-condition -mergeicmps -lower-guard-intrinsic -lower-matrix-intrinsics -correlated-propagation -globalsplit -loop-interchange -infer-address-spaces -loop-versioning -deadargelim -lower-guard-intrinsic -mem2reg -post-inline-ee-instrument -instcombine -globalsplit -simple-loop-unswitch -loop-vectorize -attributor -lowerinvoke -loop-deletion -rpo-functionattrs -loop-load-elim -adce -attributor -coro-cleanup -argpromotion -newgvn -barrier -loop-reroll -mergeicmps -bdce -strip-debug-declare -adce -separate-const-offset-from-gep -lower-matrix-intrinsics -bdce -loop-deletion -loop-unswitch -sink -coro-elide -instcombine -loop-data-prefetch -loop-versioning -die -slsr -jump-threading -adce -die -lower-expect -rewrite-statepoints-for-gc -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/stringsearch,0.9836065573770493,12.070388317108154,opt -consthoist -lower-constant-intrinsics -always-inline -globaldce -memcpyopt -loop-instsimplify -guard-widening -globalsplit -consthoist -loop-data-prefetch -canonicalize-aliases -simple-loop-unswitch -slp-vectorizer -lowerinvoke -flattencfg -simplifycfg -infer-address-spaces -gvn -float2int -mergeicmps -partially-inline-libcalls -add-discriminators -coro-split -correlated-propagation -lower-matrix-intrinsics -loop-vectorize -strip-nondebug -rewrite-statepoints-for-gc -partial-inliner -loop-guard-widening -coro-elide -coro-split -strip -rewrite-statepoints-for-gc -loop-fusion -float2int -attributor -elim-avail-extern -functionattrs -correlated-propagation -mergeicmps -loop-data-prefetch -flattencfg -hotcoldsplit -loop-idiom -consthoist -loweratomic -loop-idiom -reg2mem -mem2reg -mergeicmps -add-discriminators -loop-guard-widening -ee-instrument -scalarizer -memcpyopt -speculative-execution -aggressive-instcombine -post-inline-ee-instrument -tailcallelim -sancov -redundant-dbg-inst-elim -loop-predication -loop-predication -called-value-propagation -name-anon-globals -consthoist -separate-const-offset-from-gep -lowerswitch -redundant-dbg-inst-elim -rewrite-statepoints-for-gc -loop-guard-widening -argpromotion -hotcoldsplit -libcalls-shrinkwrap -mergefunc -dse -dse -sccp -loop-guard-widening -pgo-memop-opt -lowerswitch -simple-loop-unswitch -nary-reassociate -indvars -slsr -slsr -memcpyopt -functionattrs -loop-unswitch -prune-eh -mergereturn -mergereturn -globalsplit -loop-idiom -mergefunc -redundant-dbg-inst-elim -mergeicmps -forceattrs -globalopt -dse -licm -mergereturn -dse -constprop -cross-dso-cfi -rewrite-statepoints-for-gc -adce -simplifycfg -rpo-functionattrs -sroa -ipconstprop -strip -load-store-vectorizer -insert-gcov-profiling -instcombine -jump-threading -canonicalize-aliases -mem2reg -tailcallelim -globalopt -loop-simplify -loop-instsimplify -correlated-propagation -loop-unroll-and-jam -gvn -loop-sink -sancov -memcpyopt -loop-vectorize -strip-nondebug -adce -ipconstprop -loop-versioning-licm -loop-simplifycfg -loop-versioning-licm -simplifycfg -irce -strip -loop-data-prefetch -strip-dead-prototypes -loop-versioning-licm -mergeicmps -lcssa -lowerswitch -div-rem-pairs -gvn -loop-sink -globalsplit -aggressive-instcombine -loop-distribute -insert-gcov-profiling -newgvn input.bc -o output.bc -benchmark://cBench-v1/stringsearch,0.9904371584699454,14.024319648742676,opt -dse -instsimplify -strip-nondebug -lcssa -instsimplify -instnamer -strip-dead-prototypes -loop-deletion -loop-instsimplify -deadargelim -dce -instsimplify -strip -instnamer -sink -lower-constant-intrinsics -loop-data-prefetch -simplifycfg -correlated-propagation -ipsccp -speculative-execution -alignment-from-assumptions -float2int -loop-unroll -partially-inline-libcalls -functionattrs -redundant-dbg-inst-elim -loop-unroll-and-jam -reassociate -loop-simplifycfg -mldst-motion -loop-predication -mldst-motion -called-value-propagation -div-rem-pairs -elim-avail-extern -lower-matrix-intrinsics -flattencfg -barrier -float2int -functionattrs -elim-avail-extern -loop-instsimplify -inject-tli-mappings -loop-instsimplify -loop-reroll -consthoist -lcssa -globalopt -strip -nary-reassociate -loop-vectorize -newgvn -rpo-functionattrs -loop-load-elim -loop-deletion -infer-address-spaces -guard-widening -strip-dead-prototypes -separate-const-offset-from-gep -sancov -forceattrs -partial-inliner -gvn -sroa -load-store-vectorizer -loop-data-prefetch -globaldce -speculative-execution -lcssa -strip -lower-matrix-intrinsics -speculative-execution -loop-instsimplify -nary-reassociate -loop-instsimplify -div-rem-pairs -speculative-execution -slp-vectorizer -slp-vectorizer -coro-cleanup -mergefunc -cross-dso-cfi -guard-widening -slp-vectorizer -rewrite-statepoints-for-gc -ee-instrument -correlated-propagation -loop-data-prefetch -loop-instsimplify -strip-dead-prototypes -mergefunc -slp-vectorizer -loop-vectorize -forceattrs -consthoist -insert-gcov-profiling -barrier -name-anon-globals -licm -strip-dead-prototypes -irce -infer-address-spaces -die -mem2reg -post-inline-ee-instrument -rewrite-statepoints-for-gc -div-rem-pairs -globalsplit -aggressive-instcombine -loop-unroll-and-jam -loop-versioning -loop-instsimplify -mem2reg -bdce -loop-interchange -bdce -lower-widenable-condition -ipsccp -add-discriminators -sccp -attributor -reassociate -constmerge -scalarizer -strip-debug-declare -strip-dead-prototypes -infer-address-spaces -rpo-functionattrs -deadargelim -mergereturn -inferattrs -inferattrs -separate-const-offset-from-gep -loop-fusion -scalarizer -loop-deletion -inferattrs -lower-expect -partial-inliner -simplifycfg -mergereturn -lcssa -sccp -separate-const-offset-from-gep -irce -insert-gcov-profiling -globaldce -barrier -ee-instrument -always-inline -flattencfg -tailcallelim -alignment-from-assumptions -name-anon-globals -loop-simplifycfg -coro-early -ipsccp -early-cse-memssa -simplifycfg -deadargelim -loop-sink -globaldce -flattencfg -coro-elide -licm -instcombine -name-anon-globals -mldst-motion -infer-address-spaces -loweratomic -pgo-memop-opt -globaldce -always-inline -sccp -indvars -strip-nondebug -loop-unroll-and-jam -correlated-propagation -post-inline-ee-instrument -sancov -loop-reduce -memcpyopt -loop-simplify -instnamer -separate-const-offset-from-gep -separate-const-offset-from-gep -strip -coro-early -mem2reg -lower-guard-intrinsic -jump-threading -strip-debug-declare -simplifycfg -nary-reassociate -newgvn input.bc -o output.bc -benchmark://cBench-v1/stringsearch,0.9918032786885245,11.971539974212646,opt -loop-reduce -simplifycfg -die -inferattrs -constmerge -tailcallelim -loop-guard-widening -memcpyopt -partially-inline-libcalls -adce -float2int -sancov -newgvn -prune-eh -sink -alignment-from-assumptions -constmerge -sroa -die -instcombine -attributor -globaldce -coro-early -loop-versioning -mldst-motion -strip-debug-declare -attributor -loop-unroll-and-jam -dce -lower-constant-intrinsics -break-crit-edges -mldst-motion -rewrite-statepoints-for-gc -load-store-vectorizer -argpromotion -separate-const-offset-from-gep -break-crit-edges -slsr -functionattrs -lowerswitch -canonicalize-aliases -loop-data-prefetch -loop-unroll -loop-unswitch -mem2reg -loop-unswitch -deadargelim -dse -loweratomic -newgvn -globalsplit -loop-reroll -adce -functionattrs -flattencfg -sink -dse -loop-fusion -inject-tli-mappings -simplifycfg -early-cse-memssa -functionattrs -elim-avail-extern input.bc -o output.bc -benchmark://cBench-v1/stringsearch,0.9918032786885245,12.370582818984985,opt -coro-cleanup -flattencfg -indvars -strip-nondebug -rewrite-statepoints-for-gc -globalsplit -libcalls-shrinkwrap -lowerswitch -coro-elide -deadargelim -simplifycfg -partial-inliner -loop-reduce -elim-avail-extern -reg2mem -lcssa -globalsplit -loop-data-prefetch -libcalls-shrinkwrap -scalarizer -lcssa -ipconstprop -attributor -die -dse -insert-gcov-profiling -partial-inliner -mem2reg -lowerinvoke -loop-simplify -loop-sink -die -mergeicmps -memcpyopt -aggressive-instcombine -callsite-splitting -globalopt -lower-guard-intrinsic -hotcoldsplit -globalopt -lcssa -float2int -lowerinvoke -speculative-execution -loop-reroll -jump-threading -loop-simplify -coro-elide -strip -lower-guard-intrinsic -tailcallelim -speculative-execution -alignment-from-assumptions -elim-avail-extern -loop-idiom -loop-simplify -loop-simplify -partial-inliner -attributor -globalsplit -early-cse-memssa -loop-vectorize -lower-constant-intrinsics -constmerge -loop-interchange -flattencfg -globalopt -libcalls-shrinkwrap -lower-constant-intrinsics -infer-address-spaces -lowerswitch -mergeicmps -reassociate -break-crit-edges -loop-vectorize -lower-constant-intrinsics -strip-nondebug -pgo-memop-opt -loop-simplify -loop-reroll -insert-gcov-profiling -guard-widening -memcpyopt -loop-unroll -deadargelim -loop-simplifycfg -inject-tli-mappings -instnamer -loop-reroll -loop-deletion -early-cse-memssa -reg2mem -slp-vectorizer -div-rem-pairs -constprop -called-value-propagation -gvn -aggressive-instcombine -flattencfg -pgo-memop-opt -gvn-hoist -globalsplit -elim-avail-extern -reassociate -licm -coro-elide -irce -prune-eh -loop-unroll-and-jam -partially-inline-libcalls -globaldce -loop-distribute -break-crit-edges -loop-reroll -sancov -float2int -loweratomic -insert-gcov-profiling -redundant-dbg-inst-elim -deadargelim -speculative-execution -loop-unroll-and-jam -infer-address-spaces -mem2reg -name-anon-globals -pgo-memop-opt -correlated-propagation -rpo-functionattrs -infer-address-spaces -speculative-execution -aggressive-instcombine -post-inline-ee-instrument -lcssa -elim-avail-extern -loop-unroll -dse -break-crit-edges -mem2reg -dse -partial-inliner -licm -slsr -memcpyopt -indvars -loop-load-elim -div-rem-pairs -lower-guard-intrinsic -flattencfg -loop-vectorize -insert-gcov-profiling -reg2mem -loop-deletion -die -rewrite-statepoints-for-gc -div-rem-pairs -prune-eh -coro-early -loop-distribute -scalarizer -mldst-motion -loop-simplifycfg -loop-instsimplify -lower-widenable-condition -slp-vectorizer -ee-instrument -cross-dso-cfi -sink -constprop -tailcallelim -simple-loop-unswitch -lower-widenable-condition -float2int -mergereturn -mem2reg -lower-matrix-intrinsics -loop-reroll -constmerge -loop-versioning-licm -scalarizer -loop-reroll -memcpyopt -gvn -forceattrs -cross-dso-cfi -alignment-from-assumptions -break-crit-edges -bdce -sink -loop-predication -infer-address-spaces -loop-simplify -adce -loop-reroll -adce -mldst-motion -jump-threading -sancov -argpromotion -correlated-propagation -argpromotion -ee-instrument -barrier -dse -consthoist -loop-guard-widening -die -loop-load-elim -loop-unswitch -loop-guard-widening -coro-split -strip -barrier -loop-deletion -loop-predication -instcombine -called-value-propagation -tailcallelim -always-inline -consthoist -loop-fusion -slp-vectorizer -loop-sink -loop-versioning-licm -post-inline-ee-instrument -lowerinvoke -loop-versioning -load-store-vectorizer -loop-simplifycfg -barrier -functionattrs -loop-unroll-and-jam -slp-vectorizer -gvn -globalopt input.bc -o output.bc -benchmark://cBench-v1/stringsearch,0.9931693989071037,12.058562278747559,opt -correlated-propagation -coro-early -ee-instrument -loweratomic -strip-debug-declare -post-inline-ee-instrument -cross-dso-cfi -partially-inline-libcalls -gvn-hoist -globaldce -sccp -coro-cleanup -consthoist -constprop -barrier -loop-distribute -rpo-functionattrs -partially-inline-libcalls -simple-loop-unswitch -partial-inliner -globalsplit -loop-reduce -coro-split -ipsccp -loop-sink -irce -indvars -mldst-motion -coro-elide -hotcoldsplit -ipsccp -lower-matrix-intrinsics -ipsccp -sroa -reg2mem -newgvn -constprop -sancov -reassociate -globalopt -slp-vectorizer -loop-reduce -tailcallelim -loop-instsimplify -sink -globaldce -functionattrs -cross-dso-cfi -loop-vectorize -loop-vectorize -loop-vectorize -loop-interchange -loop-instsimplify -strip-nondebug -partially-inline-libcalls -alignment-from-assumptions -lower-guard-intrinsic -globaldce -lower-constant-intrinsics -coro-early -sroa -lowerswitch -loop-distribute -lowerswitch -strip-nondebug -globalopt -pgo-memop-opt -globaldce -load-store-vectorizer -div-rem-pairs -called-value-propagation -lower-matrix-intrinsics -loop-predication -strip-debug-declare -dse -partially-inline-libcalls -simplifycfg -instnamer -canonicalize-aliases -partially-inline-libcalls -loop-deletion -always-inline -loop-simplify -gvn -div-rem-pairs -adce -dce -strip-nondebug -slp-vectorizer -strip-nondebug -loop-sink -loweratomic -hotcoldsplit -functionattrs -loop-versioning-licm -ee-instrument -loop-data-prefetch -strip-debug-declare -tailcallelim -redundant-dbg-inst-elim -gvn-hoist -newgvn -dse -loop-versioning -memcpyopt -mldst-motion -hotcoldsplit -always-inline -newgvn -loop-data-prefetch -loop-data-prefetch -tailcallelim -loop-fusion -gvn -inferattrs -load-store-vectorizer -dce -lowerinvoke -elim-avail-extern -guard-widening -loop-reduce -simple-loop-unswitch -cross-dso-cfi -coro-split -always-inline -globaldce -loop-unroll-and-jam -called-value-propagation -lcssa -instcombine -sccp -mergefunc -rewrite-statepoints-for-gc -instcombine -globalsplit -jump-threading -guard-widening -insert-gcov-profiling -callsite-splitting -barrier -rpo-functionattrs -argpromotion -inferattrs -guard-widening -coro-cleanup -strip -slsr -loop-versioning-licm -loop-instsimplify -simplifycfg -dse -sccp -coro-elide -early-cse-memssa -lower-guard-intrinsic -loop-vectorize -instcombine -slp-vectorizer -instsimplify -mldst-motion -libcalls-shrinkwrap -barrier -insert-gcov-profiling -early-cse-memssa -loop-versioning-licm -redundant-dbg-inst-elim -lower-constant-intrinsics -loop-instsimplify -rpo-functionattrs -lower-widenable-condition -lower-expect -libcalls-shrinkwrap -sroa -rpo-functionattrs -lower-widenable-condition -cross-dso-cfi -correlated-propagation -strip-nondebug -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/stringsearch,1.0013661202185793,12.024682760238647,opt -newgvn -loop-versioning-licm -loop-instsimplify -coro-early -instcombine -strip-nondebug -name-anon-globals -loop-vectorize -loop-deletion -lowerswitch -instcombine -forceattrs -load-store-vectorizer -lowerswitch -separate-const-offset-from-gep -aggressive-instcombine -globalsplit -globalopt -loop-simplifycfg -sccp -loop-versioning -mergereturn -break-crit-edges -ipsccp -sink -loop-versioning -separate-const-offset-from-gep -loop-unroll -inferattrs -elim-avail-extern -break-crit-edges -loop-instsimplify -strip-dead-prototypes -slsr -mem2reg -loop-data-prefetch -jump-threading -instcombine -coro-early -loop-simplify -simplifycfg -dce -lower-constant-intrinsics input.bc -o output.bc -benchmark://cBench-v1/stringsearch,1.0040983606557372,11.870396137237549,opt -instnamer -barrier -simple-loop-unswitch -lower-matrix-intrinsics -licm -loop-idiom -scalarizer -post-inline-ee-instrument -loop-unswitch -name-anon-globals -ipconstprop -cross-dso-cfi -ipconstprop -lower-widenable-condition -cross-dso-cfi -slp-vectorizer -constprop -cross-dso-cfi -early-cse-memssa -deadargelim -insert-gcov-profiling -lcssa -dse -lowerswitch -rpo-functionattrs -separate-const-offset-from-gep -simplifycfg -sink -loop-fusion -mem2reg -callsite-splitting -libcalls-shrinkwrap -reassociate -gvn -deadargelim -flattencfg -strip-dead-prototypes -rpo-functionattrs -consthoist -pgo-memop-opt -libcalls-shrinkwrap -lower-expect -lower-constant-intrinsics -loop-idiom -memcpyopt -lower-constant-intrinsics -flattencfg -mldst-motion -cross-dso-cfi -load-store-vectorizer -functionattrs -gvn -mergeicmps -strip-dead-prototypes -instcombine -cross-dso-cfi -die -loop-load-elim -lowerswitch -dse -loop-simplify -lowerinvoke -loop-simplifycfg -loop-reroll -loop-fusion -always-inline -lcssa -rpo-functionattrs -rewrite-statepoints-for-gc -partial-inliner -aggressive-instcombine -licm -bdce -scalarizer -load-store-vectorizer -memcpyopt -reg2mem -load-store-vectorizer -lower-matrix-intrinsics -mem2reg -libcalls-shrinkwrap -scalarizer -rewrite-statepoints-for-gc -speculative-execution -sccp -jump-threading -speculative-execution -speculative-execution -inject-tli-mappings -mergefunc -irce -ee-instrument -constprop -rpo-functionattrs -elim-avail-extern -coro-cleanup -strip -deadargelim -loop-vectorize -lower-expect -jump-threading -instcombine -lower-constant-intrinsics -loop-versioning-licm -alignment-from-assumptions -loop-fusion -globaldce -loop-vectorize -dce -name-anon-globals -deadargelim -die -loop-guard-widening -argpromotion -bdce -loop-deletion -loop-versioning -slp-vectorizer -loop-simplifycfg -strip-debug-declare -loop-simplify -loop-unroll-and-jam -inferattrs -speculative-execution -gvn -load-store-vectorizer -alignment-from-assumptions -gvn-hoist -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9664179104477612,11.904651880264282,opt -guard-widening -ee-instrument -correlated-propagation -lcssa -ee-instrument -loop-idiom -jump-threading -guard-widening -elim-avail-extern -reassociate -slp-vectorizer -newgvn -mem2reg -loop-idiom -loop-fusion -alignment-from-assumptions -libcalls-shrinkwrap -strip -redundant-dbg-inst-elim -loop-distribute -simplifycfg -ipsccp -pgo-memop-opt -infer-address-spaces -post-inline-ee-instrument -redundant-dbg-inst-elim -bdce -lower-widenable-condition -functionattrs -float2int -newgvn input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9738805970149257,12.163768291473389,opt -bdce -coro-split -lower-widenable-condition -canonicalize-aliases -partially-inline-libcalls -loop-simplify -newgvn -lowerswitch -mergefunc -sink -dse -insert-gcov-profiling -dse -strip-dead-prototypes -loop-versioning -instsimplify -constprop -partial-inliner -prune-eh -strip -rpo-functionattrs -loop-simplifycfg -mem2reg -alignment-from-assumptions -slp-vectorizer -lower-guard-intrinsic -strip-debug-declare -lower-guard-intrinsic -loop-vectorize -mergefunc -gvn-hoist -strip-dead-prototypes -loop-guard-widening -lcssa -loop-idiom -loop-fusion -rpo-functionattrs -instsimplify -coro-split -forceattrs -callsite-splitting -coro-elide -callsite-splitting -cross-dso-cfi -early-cse-memssa -called-value-propagation -partial-inliner -canonicalize-aliases -jump-threading -mergefunc -div-rem-pairs -infer-address-spaces -lowerinvoke -forceattrs -newgvn -loop-reduce -inferattrs -loop-simplify -consthoist -float2int -redundant-dbg-inst-elim -licm -elim-avail-extern -newgvn -sancov -add-discriminators -name-anon-globals -loop-reroll -scalarizer -barrier -instcombine -strip-dead-prototypes -reassociate -dse -loop-reduce -instsimplify -forceattrs -coro-split -lower-constant-intrinsics -speculative-execution -ipconstprop -constprop -loop-reduce -aggressive-instcombine -functionattrs -loop-vectorize -jump-threading -sccp -tailcallelim -irce -add-discriminators -strip -slp-vectorizer -jump-threading -ee-instrument -indvars -reg2mem -strip -argpromotion -irce -rpo-functionattrs -callsite-splitting -loop-sink -post-inline-ee-instrument -globalsplit -memcpyopt -separate-const-offset-from-gep -loop-simplifycfg -nary-reassociate -loop-reduce -gvn-hoist -inferattrs -coro-cleanup -reg2mem -bdce -sink -float2int -sroa -constmerge -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9776119402985074,14.341261625289917,opt -loop-interchange -loop-deletion -loop-distribute -loop-versioning -insert-gcov-profiling -float2int -newgvn -loop-simplify -functionattrs -loop-idiom -slsr -functionattrs -sink -elim-avail-extern -mergefunc -loop-distribute -lcssa -lcssa -float2int -loop-sink -sink -die -canonicalize-aliases -infer-address-spaces -name-anon-globals -lower-matrix-intrinsics -mergereturn -simple-loop-unswitch -licm -loop-simplifycfg -globaldce -constmerge -lower-guard-intrinsic -simple-loop-unswitch -loop-fusion -lcssa -loop-unroll-and-jam -tailcallelim -break-crit-edges -strip-debug-declare -forceattrs -inferattrs -constmerge -sink -loop-unswitch -early-cse-memssa -rewrite-statepoints-for-gc -coro-split -irce -sroa -globalopt -mergefunc -strip-debug-declare -called-value-propagation -called-value-propagation -redundant-dbg-inst-elim -ipsccp -break-crit-edges -ee-instrument -always-inline -redundant-dbg-inst-elim -gvn-hoist -die -attributor -lower-guard-intrinsic -loop-guard-widening -simplifycfg -pgo-memop-opt -indvars -float2int -ipsccp -simplifycfg -hotcoldsplit -sink -loop-simplify -partially-inline-libcalls -pgo-memop-opt -gvn -ee-instrument -sink -slp-vectorizer -constprop -coro-elide -loop-interchange -mergeicmps -loweratomic -inject-tli-mappings -loop-idiom -aggressive-instcombine -mldst-motion -functionattrs -sccp -always-inline -newgvn -loop-distribute -instcombine input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9813432835820894,13.230485677719116,opt -called-value-propagation -licm -strip-nondebug -alignment-from-assumptions -jump-threading -libcalls-shrinkwrap -loop-vectorize -alignment-from-assumptions -lower-widenable-condition -correlated-propagation -scalarizer -coro-early -sancov -lowerinvoke -ee-instrument -coro-split -dse -pgo-memop-opt -constmerge -lower-constant-intrinsics -libcalls-shrinkwrap -coro-elide -lower-guard-intrinsic -float2int -loop-reroll -elim-avail-extern -partial-inliner -instnamer -coro-cleanup -loop-versioning -alignment-from-assumptions -globaldce -ipsccp -ipconstprop -loop-reroll -sink -mem2reg -lowerswitch -mergereturn -instnamer -mem2reg -die -lowerinvoke -tailcallelim -strip-debug-declare -sink -gvn-hoist -coro-split -die -float2int -dse -loop-versioning -float2int -strip-nondebug -functionattrs -coro-split -die -lcssa -loop-interchange -float2int -loop-vectorize -mergeicmps -instcombine -gvn-hoist -early-cse-memssa -separate-const-offset-from-gep -partially-inline-libcalls -load-store-vectorizer -loop-instsimplify -loop-deletion -gvn -tailcallelim -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9813432835820896,12.88115906715393,opt -break-crit-edges -mldst-motion -ipsccp -loop-predication -loop-load-elim -sroa -redundant-dbg-inst-elim -loop-load-elim -globaldce -nary-reassociate -instsimplify -sroa -irce -instnamer -barrier -consthoist -adce -forceattrs -newgvn -instcombine -loop-unswitch -lower-expect -called-value-propagation -constmerge -strip-debug-declare -simplifycfg -elim-avail-extern -gvn input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9813432835820897,15.134238719940186,opt -loop-fusion -ipconstprop -prune-eh -early-cse-memssa -inferattrs -newgvn -sink -load-store-vectorizer -coro-early -instnamer -reassociate -coro-cleanup -coro-cleanup -barrier -coro-split -argpromotion -guard-widening -insert-gcov-profiling -loop-idiom -sccp -loop-guard-widening -lower-matrix-intrinsics -globalopt -tailcallelim -name-anon-globals -consthoist -name-anon-globals -dse -loop-data-prefetch -libcalls-shrinkwrap -loop-unroll-and-jam -jump-threading -barrier -instnamer -tailcallelim -mergeicmps -inject-tli-mappings -elim-avail-extern -always-inline -loop-unswitch -partial-inliner -always-inline -licm -lowerswitch -rewrite-statepoints-for-gc -loop-versioning -barrier -mem2reg -loop-reroll -lowerswitch -loop-data-prefetch -coro-elide -lowerswitch -simplifycfg -load-store-vectorizer -constprop -strip -strip -die -slsr -elim-avail-extern -lowerinvoke -instcombine input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9850746268656717,12.014153242111206,opt -pgo-memop-opt -early-cse-memssa -loop-unroll-and-jam -irce -loop-instsimplify -loop-guard-widening -rewrite-statepoints-for-gc -lower-guard-intrinsic -float2int -nary-reassociate -consthoist -hotcoldsplit -loop-distribute -bdce -nary-reassociate -libcalls-shrinkwrap -load-store-vectorizer -elim-avail-extern -slsr -simple-loop-unswitch -sroa -lcssa -early-cse-memssa -lower-constant-intrinsics -nary-reassociate -lcssa -loop-distribute -instnamer -cross-dso-cfi -coro-split -canonicalize-aliases -loop-unswitch -partially-inline-libcalls -name-anon-globals -constprop -coro-split -strip -separate-const-offset-from-gep -loop-load-elim -sancov -mldst-motion -ipconstprop -always-inline -load-store-vectorizer -loop-unroll-and-jam -slp-vectorizer -elim-avail-extern -adce -newgvn -mem2reg -loop-predication -indvars -rewrite-statepoints-for-gc -lowerinvoke -reg2mem -instsimplify -partially-inline-libcalls -loop-deletion -add-discriminators -loop-simplify -forceattrs -sroa -globalsplit -loweratomic -gvn -bdce -rewrite-statepoints-for-gc -reg2mem -mldst-motion -coro-split -mergefunc -sroa -post-inline-ee-instrument -float2int -loop-deletion -loop-unroll-and-jam -name-anon-globals -canonicalize-aliases -aggressive-instcombine -alignment-from-assumptions -early-cse-memssa -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9850746268656717,12.287578821182251,opt -inject-tli-mappings -strip-nondebug -die -constprop -loop-fusion -sancov -sroa -lcssa -instcombine -globaldce -inferattrs -load-store-vectorizer -aggressive-instcombine -partial-inliner -barrier -strip-nondebug -loop-idiom -mergeicmps -cross-dso-cfi -sancov -elim-avail-extern -sroa -simplifycfg -loop-sink -loop-instsimplify -mldst-motion -dse -newgvn -ipconstprop -instsimplify -dce -break-crit-edges -add-discriminators -dse -globalsplit -mem2reg -tailcallelim -loop-interchange -speculative-execution -simplifycfg -lower-expect -reassociate -speculative-execution -loop-unroll-and-jam -jump-threading -inject-tli-mappings -sink -loop-simplify -insert-gcov-profiling -loop-load-elim -cross-dso-cfi -loop-distribute -simplifycfg -die -mem2reg -callsite-splitting -lower-constant-intrinsics -constprop -instcombine input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9888059701492538,12.100034475326538,opt -inferattrs -mergeicmps -loop-sink -mem2reg -attributor -insert-gcov-profiling -add-discriminators -sink -loop-data-prefetch -loop-instsimplify -loop-fusion -div-rem-pairs -deadargelim -coro-early -speculative-execution -argpromotion -coro-cleanup -load-store-vectorizer -inferattrs -loop-simplifycfg -early-cse-memssa -indvars -mem2reg -constprop -adce -ipconstprop -strip-nondebug -die -insert-gcov-profiling -constprop -gvn -loop-sink -instsimplify -guard-widening -loop-unroll -prune-eh -constmerge -lower-widenable-condition -redundant-dbg-inst-elim -lowerinvoke -flattencfg -loop-simplify -mergereturn -tailcallelim -loop-unroll -prune-eh -sccp -separate-const-offset-from-gep -loop-versioning -lower-guard-intrinsic -early-cse-memssa -mergefunc -elim-avail-extern -correlated-propagation -ipconstprop -partially-inline-libcalls -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9888059701492539,12.108437776565552,opt -sancov -strip-nondebug -globaldce -add-discriminators -loop-reduce -strip-nondebug -rpo-functionattrs -partially-inline-libcalls -newgvn -sancov -cross-dso-cfi -simplifycfg -jump-threading -loop-instsimplify -aggressive-instcombine -reassociate -lowerswitch -instcombine -lcssa -loop-simplify -simple-loop-unswitch -memcpyopt -nary-reassociate -die -coro-split -loop-vectorize -indvars -lower-widenable-condition -globalsplit -partially-inline-libcalls -die -always-inline -sccp -dce -loop-unroll-and-jam -lower-expect -dse -lower-widenable-condition -early-cse-memssa -loop-instsimplify -always-inline -canonicalize-aliases -die -gvn-hoist -slp-vectorizer -memcpyopt -jump-threading -loop-instsimplify -globaldce -loop-fusion -loop-unroll -flattencfg -coro-elide -constprop -speculative-execution -loop-fusion -lower-widenable-condition -coro-split -lower-guard-intrinsic -rewrite-statepoints-for-gc -barrier -reassociate -loop-interchange -globaldce -coro-elide -float2int -sancov -lower-constant-intrinsics -mem2reg -lower-widenable-condition -instcombine -newgvn -simple-loop-unswitch -instcombine -partial-inliner -consthoist -sccp -tailcallelim -coro-cleanup -lower-expect -loop-interchange -functionattrs -inferattrs -coro-elide -mldst-motion -newgvn -post-inline-ee-instrument -post-inline-ee-instrument -adce -constprop -loop-predication -globalsplit -reassociate -post-inline-ee-instrument -lowerswitch -sroa -loop-deletion -simplifycfg -tailcallelim -constprop -gvn input.bc -o output.bc -benchmark://cBench-v1/susan,0.977476324545687,14.979936361312866,opt -canonicalize-aliases -loop-guard-widening -float2int -loop-versioning-licm -redundant-dbg-inst-elim -callsite-splitting -loop-load-elim -lowerswitch -loop-unroll-and-jam -lower-guard-intrinsic -forceattrs -instnamer -licm -memcpyopt -prune-eh -loop-unswitch -correlated-propagation -adce -called-value-propagation -loop-predication -loop-load-elim -lower-matrix-intrinsics -sccp -instcombine -globalopt -loop-simplifycfg -lcssa -guard-widening -die -alignment-from-assumptions -partially-inline-libcalls -loop-unroll-and-jam -inject-tli-mappings -sancov -redundant-dbg-inst-elim -cross-dso-cfi -float2int -lower-constant-intrinsics -argpromotion -elim-avail-extern -loop-unroll -argpromotion -loop-predication -lowerswitch -sccp -memcpyopt -dce -add-discriminators -flattencfg -guard-widening -instcombine -speculative-execution -coro-cleanup -ipsccp -early-cse-memssa -instcombine -mem2reg -lower-guard-intrinsic -insert-gcov-profiling -separate-const-offset-from-gep -alignment-from-assumptions -strip -lowerinvoke -elim-avail-extern -scalarizer -insert-gcov-profiling -lower-expect -strip-debug-declare -licm -bdce -hotcoldsplit -sccp -loop-guard-widening -simple-loop-unswitch -loop-versioning -prune-eh -strip-nondebug -gvn -simplifycfg -loop-load-elim -redundant-dbg-inst-elim -coro-elide -prune-eh -partial-inliner -instsimplify -loop-guard-widening -loop-vectorize -barrier -strip-dead-prototypes -inferattrs -adce -load-store-vectorizer -div-rem-pairs -mergeicmps -lower-constant-intrinsics -globalopt -coro-split -reassociate -nary-reassociate -indvars -memcpyopt -scalarizer -lower-guard-intrinsic -ipsccp -bdce -div-rem-pairs -separate-const-offset-from-gep -mldst-motion -alignment-from-assumptions -separate-const-offset-from-gep -ee-instrument -consthoist -post-inline-ee-instrument -correlated-propagation -globaldce -loop-guard-widening -loop-predication -gvn-hoist -guard-widening -always-inline -rewrite-statepoints-for-gc -callsite-splitting -rewrite-statepoints-for-gc -mem2reg -instsimplify -strip -lower-expect -lower-matrix-intrinsics -deadargelim -lcssa -loop-simplify -slp-vectorizer -strip-debug-declare -loop-simplify -forceattrs -early-cse-memssa -inject-tli-mappings -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/susan,0.9824673662656768,14.057718515396118,opt -bdce -partially-inline-libcalls -mem2reg -sccp -attributor -pgo-memop-opt -constmerge -ipconstprop -coro-elide -loop-interchange -insert-gcov-profiling -constmerge -strip-nondebug -loweratomic -insert-gcov-profiling -guard-widening -guard-widening -gvn -loop-load-elim -loop-idiom -instcombine -coro-elide -strip-dead-prototypes -sink -callsite-splitting -mem2reg -loop-interchange -always-inline -dce -elim-avail-extern -newgvn -called-value-propagation -lower-guard-intrinsic -lower-matrix-intrinsics -div-rem-pairs -globaldce -instnamer -sroa -nary-reassociate -prune-eh -separate-const-offset-from-gep -lower-guard-intrinsic -newgvn -sancov -sccp -infer-address-spaces -bdce -partial-inliner -mergeicmps -sccp -rewrite-statepoints-for-gc -early-cse-memssa -early-cse-memssa -dse -called-value-propagation -div-rem-pairs -globalopt -strip-dead-prototypes -slsr -functionattrs -flattencfg -callsite-splitting -loop-predication -forceattrs -indvars -die -loop-reroll -rpo-functionattrs -ipconstprop -gvn-hoist -post-inline-ee-instrument -redundant-dbg-inst-elim -post-inline-ee-instrument -loweratomic -loop-interchange -lower-guard-intrinsic -nary-reassociate -loop-instsimplify -sink -instsimplify -globaldce -loop-versioning-licm -inferattrs -attributor -jump-threading input.bc -o output.bc -benchmark://cBench-v1/susan,0.991041719989762,14.902771949768066,opt -argpromotion -loweratomic -loop-unroll -slsr -loop-versioning -consthoist -functionattrs -alignment-from-assumptions -alignment-from-assumptions -dse -strip-dead-prototypes -loop-data-prefetch -lower-guard-intrinsic -loop-fusion -irce -dse -float2int -loop-distribute -correlated-propagation -elim-avail-extern -rewrite-statepoints-for-gc -prune-eh -loop-fusion -prune-eh -loop-distribute -redundant-dbg-inst-elim -load-store-vectorizer -alignment-from-assumptions -prune-eh -loop-unroll -simplifycfg -argpromotion -lower-guard-intrinsic -mem2reg -strip-nondebug -gvn -elim-avail-extern -loop-deletion -loop-sink -functionattrs -simple-loop-unswitch -loop-unroll-and-jam -separate-const-offset-from-gep -sccp -strip -simple-loop-unswitch -mergeicmps -mergeicmps -licm -name-anon-globals -irce -correlated-propagation -coro-early -loop-load-elim -early-cse-memssa -strip -rewrite-statepoints-for-gc -barrier -loop-data-prefetch -ee-instrument -libcalls-shrinkwrap -tailcallelim -strip-nondebug -canonicalize-aliases -elim-avail-extern -loop-fusion -early-cse-memssa -strip-nondebug -loop-sink -lowerinvoke -ipconstprop -inferattrs -slsr -ee-instrument -loop-deletion -coro-early -dse -lowerswitch -loop-reroll -inject-tli-mappings -instnamer -sink -loop-simplifycfg -lowerinvoke -load-store-vectorizer -speculative-execution -canonicalize-aliases -loop-versioning -simple-loop-unswitch -loop-fusion -adce -dce -loop-interchange -loop-load-elim -always-inline -elim-avail-extern -loop-distribute -always-inline -scalarizer -instsimplify -mldst-motion -mergefunc -newgvn -constmerge -ipsccp -separate-const-offset-from-gep -flattencfg -lower-matrix-intrinsics -simplifycfg -indvars -loop-unswitch -speculative-execution -adce -simple-loop-unswitch -separate-const-offset-from-gep -loop-simplify -loop-interchange -prune-eh -licm -mem2reg -speculative-execution -globalopt -instcombine -loop-versioning-licm -sccp -deadargelim -correlated-propagation -ipsccp -slp-vectorizer -load-store-vectorizer -loop-unroll-and-jam -licm -slp-vectorizer -forceattrs -loop-vectorize -partially-inline-libcalls -indvars -scalarizer -redundant-dbg-inst-elim -newgvn -mergereturn -slsr -strip-debug-declare -consthoist -loop-interchange -constmerge -instsimplify -constprop -inferattrs -add-discriminators -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/susan,0.9928333759918095,15.974971294403076,opt -dse -add-discriminators -mem2reg -loop-predication -loop-reroll -prune-eh -guard-widening -irce -strip-nondebug -loop-distribute -separate-const-offset-from-gep -loop-versioning-licm -ipconstprop -memcpyopt -newgvn -newgvn -consthoist -name-anon-globals -correlated-propagation -mldst-motion -redundant-dbg-inst-elim -licm -callsite-splitting -constmerge -scalarizer -canonicalize-aliases -argpromotion -instcombine -loop-unroll -instsimplify -nary-reassociate -loop-simplify -early-cse-memssa -loop-unswitch -mergeicmps -canonicalize-aliases -ipsccp -globaldce -loop-fusion -lower-matrix-intrinsics -post-inline-ee-instrument -post-inline-ee-instrument -loop-versioning-licm -sink -strip -dse -libcalls-shrinkwrap -float2int -loop-instsimplify -break-crit-edges -sccp -constmerge -alignment-from-assumptions -add-discriminators -argpromotion -instcombine -loweratomic -constmerge -loop-instsimplify -prune-eh -loop-vectorize -float2int -lower-expect -lcssa -forceattrs -coro-cleanup -div-rem-pairs -loop-fusion -nary-reassociate -argpromotion -irce -separate-const-offset-from-gep -separate-const-offset-from-gep -globalopt -redundant-dbg-inst-elim -lower-matrix-intrinsics -loop-vectorize -loop-versioning -gvn-hoist -loop-data-prefetch -correlated-propagation -loop-unswitch -ipsccp -add-discriminators -loop-guard-widening -globaldce -ee-instrument -speculative-execution -loop-data-prefetch -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/susan,0.9929613514205275,15.52566409111023,opt -constprop -lowerswitch -float2int -barrier -loop-deletion -loop-predication -lower-constant-intrinsics -speculative-execution -early-cse-memssa -lower-guard-intrinsic -reassociate -globaldce -load-store-vectorizer -insert-gcov-profiling -loop-fusion -globaldce -prune-eh -prune-eh -div-rem-pairs -sroa -correlated-propagation -loop-guard-widening -coro-early -mergereturn -gvn -add-discriminators -sccp -speculative-execution -break-crit-edges -strip-dead-prototypes -rpo-functionattrs -lower-expect -loop-sink -rewrite-statepoints-for-gc -callsite-splitting -mergefunc -infer-address-spaces -rpo-functionattrs -coro-early -speculative-execution -aggressive-instcombine -globaldce -loop-guard-widening -strip-nondebug -indvars -loop-deletion -coro-early -reassociate -loop-idiom -loop-vectorize -strip -bdce -scalarizer -callsite-splitting -die -gvn -globalopt -mem2reg -loop-load-elim -loop-load-elim -mergefunc -instsimplify -loop-instsimplify -lower-matrix-intrinsics -attributor -callsite-splitting -lower-guard-intrinsic -scalarizer -hotcoldsplit -loop-unroll-and-jam -loop-versioning-licm -lower-widenable-condition -simple-loop-unswitch -mergereturn -globalsplit -canonicalize-aliases -lower-constant-intrinsics -consthoist -pgo-memop-opt -hotcoldsplit -insert-gcov-profiling -callsite-splitting -slp-vectorizer -alignment-from-assumptions -inject-tli-mappings -guard-widening -add-discriminators -early-cse-memssa -elim-avail-extern -licm -pgo-memop-opt -functionattrs -loop-sink -jump-threading -tailcallelim -name-anon-globals -loop-reroll -cross-dso-cfi -sccp -dce -loop-instsimplify -globalopt -always-inline -elim-avail-extern -globalopt -nary-reassociate -early-cse-memssa -partial-inliner -loop-distribute -indvars -simplifycfg -partially-inline-libcalls -div-rem-pairs -loop-load-elim -loop-fusion -inject-tli-mappings -sancov -loop-instsimplify -constprop -die -flattencfg -loop-predication -gvn-hoist -adce -loop-load-elim -scalarizer -reassociate -callsite-splitting -cross-dso-cfi -lower-matrix-intrinsics -name-anon-globals -lower-matrix-intrinsics -loop-guard-widening -canonicalize-aliases -loop-distribute -sancov -ipsccp -coro-cleanup -reg2mem -load-store-vectorizer -deadargelim -loop-data-prefetch -ipconstprop -load-store-vectorizer -canonicalize-aliases -loop-guard-widening -attributor -ipsccp -loop-unroll -mergereturn -loop-versioning -add-discriminators -load-store-vectorizer -barrier -loop-interchange -guard-widening -loop-reroll -simple-loop-unswitch -gvn-hoist -functionattrs -elim-avail-extern -partially-inline-libcalls -cross-dso-cfi -coro-early -ipconstprop -reassociate -strip-dead-prototypes -mergefunc -sroa -rpo-functionattrs -add-discriminators -scalarizer -float2int -lower-expect -hotcoldsplit -dce -coro-split -name-anon-globals -simplifycfg -rewrite-statepoints-for-gc -callsite-splitting -speculative-execution -adce -loop-unroll -constmerge -early-cse-memssa -sccp -constmerge -loop-instsimplify -adce -attributor -sccp -instsimplify -libcalls-shrinkwrap -loop-guard-widening -hotcoldsplit -prune-eh -canonicalize-aliases -constmerge -lowerinvoke -loop-unswitch -name-anon-globals -cross-dso-cfi -redundant-dbg-inst-elim -loop-simplifycfg -rewrite-statepoints-for-gc -strip-debug-declare -loop-data-prefetch -coro-early -mergereturn -scalarizer -simple-loop-unswitch -loweratomic -lower-constant-intrinsics -gvn-hoist -inferattrs -lower-matrix-intrinsics -slsr -libcalls-shrinkwrap -gvn -sink -mergefunc -lower-guard-intrinsic -flattencfg -instnamer -licm -guard-widening -always-inline -flattencfg -functionattrs -barrier -instcombine input.bc -o output.bc -benchmark://cBench-v1/susan,0.9946250319938573,311.2034537792206,opt -irce -dce -speculative-execution -rewrite-statepoints-for-gc -aggressive-instcombine -ipsccp -loop-distribute -slp-vectorizer -loop-simplify -loop-rotate -memcpyopt -reg2mem -inferattrs -inferattrs -hotcoldsplit -lower-constant-intrinsics -loop-guard-widening -consthoist -pgo-memop-opt -always-inline -loop-unroll-and-jam -cross-dso-cfi -loop-fusion -speculative-execution -name-anon-globals -lcssa -sink -strip-dead-prototypes -loop-versioning -barrier -loop-data-prefetch -loop-reduce -dce -sink -ipsccp -mem2reg -scalarizer -globalopt -bdce -newgvn -coro-elide -libcalls-shrinkwrap -loop-data-prefetch -coro-split -mem2reg -speculative-execution -speculative-execution -sancov -globalopt -infer-address-spaces -loop-simplify -globaldce -post-inline-ee-instrument -loop-data-prefetch -break-crit-edges -coro-elide -partial-inliner -forceattrs -constprop -break-crit-edges -ee-instrument -indvars -loop-unroll -mergefunc -coro-split -float2int -argpromotion -correlated-propagation -lowerswitch -simplifycfg -aggressive-instcombine -strip -infer-address-spaces -mem2reg -reassociate -hotcoldsplit -coro-early -lower-expect -alignment-from-assumptions -jump-threading -loop-guard-widening -instnamer -constprop -inferattrs -gvn -early-cse-memssa -instcombine -loop-versioning -gvn -loop-sink -gvn-hoist -slp-vectorizer -sancov -guard-widening -lower-widenable-condition -mergeicmps -constmerge -indvars -irce -pgo-memop-opt -lower-expect -lowerswitch -loop-load-elim -div-rem-pairs -ipconstprop -functionattrs -dse -lower-widenable-condition -loop-fusion -aggressive-instcombine -elim-avail-extern -sroa -sccp -flattencfg -loop-simplify -loop-versioning -simplifycfg -flattencfg -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/susan,0.9974404914256462,14.56405782699585,opt -mem2reg -scalarizer -instsimplify -sink -loop-instsimplify -inferattrs -loop-versioning-licm -sancov -early-cse-memssa -dse -mergeicmps -called-value-propagation -simple-loop-unswitch -die -simplifycfg -add-discriminators -loop-sink -flattencfg -sink -libcalls-shrinkwrap -always-inline -coro-cleanup -mldst-motion -loop-versioning -partial-inliner -aggressive-instcombine -reg2mem -loop-reroll -name-anon-globals -lcssa -sroa -slsr -loop-unswitch -hotcoldsplit -sccp -reassociate -strip-dead-prototypes -partially-inline-libcalls -partial-inliner -add-discriminators -lowerinvoke -globalopt -rewrite-statepoints-for-gc -strip -sccp -instsimplify -loop-instsimplify -sccp -loop-simplifycfg -div-rem-pairs -infer-address-spaces -mldst-motion -partial-inliner -early-cse-memssa -sccp -strip-debug-declare -indvars -correlated-propagation -deadargelim -strip -memcpyopt -sancov -simple-loop-unswitch -inferattrs -loop-data-prefetch -bdce -inject-tli-mappings -ipsccp -loop-predication -licm -inject-tli-mappings -flattencfg -elim-avail-extern -simplifycfg -sancov -argpromotion -ee-instrument -pgo-memop-opt -lower-widenable-condition -loop-predication -rewrite-statepoints-for-gc -loop-unswitch -loop-fusion -loop-load-elim -lcssa -loop-reroll -lower-expect -instsimplify -scalarizer -guard-widening -partially-inline-libcalls -instcombine -callsite-splitting -coro-cleanup -jump-threading -deadargelim -loop-vectorize -loop-reroll -bdce -lower-matrix-intrinsics -scalarizer -early-cse-memssa -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/susan,1.000767852572306,13.883830785751343,opt -speculative-execution -elim-avail-extern -newgvn -strip-dead-prototypes -hotcoldsplit -loop-vectorize -die -simplifycfg -mldst-motion -lower-guard-intrinsic -consthoist -loop-unroll-and-jam -loop-load-elim -loweratomic -strip-nondebug -post-inline-ee-instrument -guard-widening -always-inline -ee-instrument -loop-sink -loop-unroll -insert-gcov-profiling -loop-data-prefetch -dse -consthoist -loop-reroll -mergefunc -partially-inline-libcalls -strip-dead-prototypes -die -lower-constant-intrinsics -alignment-from-assumptions -attributor -attributor -correlated-propagation -simple-loop-unswitch -consthoist -loop-instsimplify -add-discriminators -coro-cleanup -nary-reassociate -loop-distribute -newgvn -break-crit-edges -lcssa -loop-versioning -post-inline-ee-instrument -pgo-memop-opt -loop-simplify -coro-split -loop-unroll -partially-inline-libcalls -rpo-functionattrs -guard-widening -lower-matrix-intrinsics -newgvn -sroa -newgvn -loweratomic -mergereturn -strip -reg2mem -coro-split -early-cse-memssa -globalsplit -coro-early -rewrite-statepoints-for-gc -loop-load-elim -loop-predication -strip-dead-prototypes -loop-unswitch -consthoist -slsr -inferattrs -newgvn -loop-unroll-and-jam -deadargelim -irce -lower-expect -loop-interchange -loop-unroll -constprop -loop-guard-widening -globalopt -rewrite-statepoints-for-gc -sroa -callsite-splitting -globalsplit -elim-avail-extern -globalsplit -indvars -reassociate -strip-nondebug -dce -mergeicmps -dce -guard-widening -name-anon-globals -constprop -irce -sancov -gvn -instcombine -loop-vectorize -constprop -speculative-execution -canonicalize-aliases -break-crit-edges -add-discriminators -irce -loop-load-elim -bdce -called-value-propagation -loop-unroll-and-jam -loop-distribute -loop-idiom -slsr -argpromotion -pgo-memop-opt -infer-address-spaces -dse -inferattrs -loop-reroll -correlated-propagation -lower-widenable-condition -loop-simplify -indvars -callsite-splitting -scalarizer -lowerinvoke -jump-threading -loop-predication -hotcoldsplit -lower-matrix-intrinsics -post-inline-ee-instrument -mergeicmps -infer-address-spaces -loop-interchange -loop-vectorize -instsimplify input.bc -o output.bc -benchmark://cBench-v1/susan,1.0015357051446123,13.91321086883545,opt -sroa -jump-threading -sccp -lower-constant-intrinsics -ee-instrument -rpo-functionattrs -jump-threading -simplifycfg -mem2reg -name-anon-globals -coro-split -alignment-from-assumptions -loop-interchange -loop-data-prefetch -reg2mem -loop-unroll-and-jam -infer-address-spaces -loop-fusion -sroa -globaldce -callsite-splitting -loweratomic -loop-deletion -post-inline-ee-instrument -loop-instsimplify -indvars -slsr -ipconstprop -consthoist -simplifycfg -mergefunc -aggressive-instcombine -instsimplify -canonicalize-aliases -strip-dead-prototypes -partially-inline-libcalls -loop-interchange -gvn-hoist -add-discriminators -correlated-propagation -constprop -loop-versioning-licm -loop-versioning -instcombine -globalopt -float2int -float2int -inject-tli-mappings -dse -constmerge -loop-unroll -forceattrs -strip-dead-prototypes -aggressive-instcombine -loop-fusion -coro-split -ee-instrument -loop-unroll -simplifycfg -mldst-motion -indvars -inferattrs -loop-instsimplify -sccp -rewrite-statepoints-for-gc -pgo-memop-opt -add-discriminators -insert-gcov-profiling -loweratomic -loop-simplifycfg -scalarizer -loop-guard-widening -strip-debug-declare -constprop -loop-instsimplify -globaldce -partial-inliner -simple-loop-unswitch -called-value-propagation -loop-guard-widening -prune-eh -alignment-from-assumptions -canonicalize-aliases -lower-widenable-condition -loop-guard-widening -licm -rewrite-statepoints-for-gc -float2int -infer-address-spaces -elim-avail-extern -slp-vectorizer -consthoist -newgvn input.bc -o output.bc -benchmark://cBench-v1/susan,1.0239314051702073,13.509535074234009,opt -canonicalize-aliases -lower-matrix-intrinsics -memcpyopt -scalarizer -mem2reg -insert-gcov-profiling -newgvn -reg2mem -argpromotion -strip -simplifycfg -constprop -jump-threading -reg2mem -consthoist -barrier -partial-inliner -flattencfg -slp-vectorizer -add-discriminators -loop-instsimplify -instnamer -functionattrs -barrier -loop-unroll -loop-unroll -loop-sink -simplifycfg -die -loop-interchange -simple-loop-unswitch -reg2mem -loweratomic -globalsplit -mldst-motion -instnamer -loop-data-prefetch -rpo-functionattrs -lower-guard-intrinsic -lowerswitch -reassociate -mergereturn -indvars -deadargelim -speculative-execution -newgvn -attributor -load-store-vectorizer -coro-elide -loop-unswitch -dse -sccp -infer-address-spaces -loop-unroll-and-jam -loop-unroll-and-jam -add-discriminators -loop-data-prefetch -loop-simplifycfg -ipconstprop -div-rem-pairs -elim-avail-extern -loop-versioning -gvn -dce -rewrite-statepoints-for-gc -argpromotion -loop-instsimplify -strip-dead-prototypes -coro-cleanup -loop-unroll-and-jam -instcombine -loop-data-prefetch -newgvn -lower-widenable-condition -strip-dead-prototypes -inferattrs -tailcallelim -dce -div-rem-pairs -loop-guard-widening -dse -partial-inliner -coro-elide -instcombine -simple-loop-unswitch -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,0.9724202156237686,42.7266845703125,opt -break-crit-edges -guard-widening -partially-inline-libcalls -correlated-propagation -argpromotion -loop-versioning -redundant-dbg-inst-elim -dce -indvars -loop-instsimplify -loop-simplifycfg -loop-deletion -hotcoldsplit -globalopt -loop-data-prefetch -inject-tli-mappings -rpo-functionattrs -loop-unroll -functionattrs -lowerinvoke -globalsplit -lowerswitch -mergereturn -loop-predication -functionattrs -lcssa -post-inline-ee-instrument -argpromotion -licm -loop-data-prefetch -scalarizer -deadargelim -slsr -slsr -loop-deletion -guard-widening -strip-nondebug -die -libcalls-shrinkwrap -called-value-propagation -always-inline -hotcoldsplit -separate-const-offset-from-gep -loop-deletion -ipconstprop -mem2reg -flattencfg -loop-simplifycfg -insert-gcov-profiling -simplifycfg -forceattrs -gvn-hoist -alignment-from-assumptions -inferattrs -jump-threading -infer-address-spaces -slsr -loop-deletion -jump-threading -lower-expect -loop-data-prefetch -speculative-execution -newgvn -break-crit-edges -globaldce -instcombine -loweratomic -callsite-splitting -dce -die -inject-tli-mappings -slp-vectorizer -lowerinvoke -barrier -ipsccp -sccp -post-inline-ee-instrument -loop-versioning -slsr -dce -coro-split -gvn -memcpyopt -memcpyopt -loop-vectorize -loop-deletion -loop-sink -constprop -loop-vectorize -loop-simplify -mergefunc -ipsccp -loop-distribute -gvn -insert-gcov-profiling -coro-cleanup -loop-unroll -jump-threading -gvn -cross-dso-cfi -prune-eh -constprop -loop-guard-widening -lower-widenable-condition -mergefunc -adce -loop-idiom -loop-versioning-licm -coro-split -sroa -reassociate -coro-split -loop-vectorize -early-cse-memssa -loop-interchange -flattencfg -loop-reroll -slsr -strip-dead-prototypes -nary-reassociate -strip-dead-prototypes -loweratomic -gvn-hoist -attributor -slsr -name-anon-globals -prune-eh -called-value-propagation -cross-dso-cfi -cross-dso-cfi -gvn -div-rem-pairs -loop-versioning -elim-avail-extern -lower-matrix-intrinsics -instnamer -nary-reassociate -load-store-vectorizer -constmerge -instcombine -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,0.9850997528564778,43.625590324401855,opt -reassociate -lower-widenable-condition -nary-reassociate -loop-idiom -always-inline -cross-dso-cfi -infer-address-spaces -sink -bdce -loop-unroll -load-store-vectorizer -separate-const-offset-from-gep -deadargelim -bdce -callsite-splitting -loop-distribute -barrier -deadargelim -loop-unswitch -loop-versioning-licm -rpo-functionattrs -loop-guard-widening -loop-deletion -loop-idiom -canonicalize-aliases -speculative-execution -dse -break-crit-edges -loweratomic -cross-dso-cfi -div-rem-pairs -correlated-propagation -libcalls-shrinkwrap -inferattrs -early-cse-memssa -mem2reg -partial-inliner -loop-simplifycfg -loop-simplify -argpromotion -barrier -loop-reduce -canonicalize-aliases -slsr -speculative-execution -sancov -mldst-motion -constmerge -flattencfg -div-rem-pairs -redundant-dbg-inst-elim -lower-expect -instcombine -dce -libcalls-shrinkwrap -argpromotion -break-crit-edges -ipsccp -simple-loop-unswitch -simplifycfg -nary-reassociate -canonicalize-aliases -hotcoldsplit -mergeicmps -lower-constant-intrinsics -instsimplify input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,0.9884308177226978,42.622666358947754,opt -strip -globaldce -insert-gcov-profiling -irce -sancov -redundant-dbg-inst-elim -consthoist -sroa -globaldce -loop-fusion -slsr -jump-threading -tailcallelim -indvars -globalsplit -die -newgvn -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,0.9915111572764067,39.32834792137146,opt -lower-expect -simplifycfg -loop-instsimplify -insert-gcov-profiling -barrier -consthoist -post-inline-ee-instrument -tailcallelim -strip-nondebug -loop-simplify -loop-simplify -coro-cleanup -loop-distribute -name-anon-globals -sroa -bdce -ipsccp -insert-gcov-profiling -dce -globaldce -mem2reg -rpo-functionattrs -prune-eh -mergereturn -loop-versioning-licm -loop-distribute -bdce -ipconstprop -strip-debug-declare -bdce -gvn-hoist -alignment-from-assumptions -loop-data-prefetch -lower-expect -early-cse-memssa -instnamer -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,0.9944124073211789,42.087604999542236,opt -load-store-vectorizer -ipconstprop -canonicalize-aliases -libcalls-shrinkwrap -loop-unswitch -loop-guard-widening -loop-sink -argpromotion -dce -loop-instsimplify -loop-unroll -sccp -barrier -mem2reg -dce -separate-const-offset-from-gep -loweratomic -pgo-memop-opt -globalopt -irce -irce -called-value-propagation -lower-matrix-intrinsics -irce -indvars -sancov -called-value-propagation -coro-elide -break-crit-edges -rewrite-statepoints-for-gc -loop-deletion -prune-eh -loop-data-prefetch -strip-debug-declare -lower-guard-intrinsic -canonicalize-aliases -elim-avail-extern -lower-widenable-condition -newgvn -strip -called-value-propagation -coro-early -strip -ipsccp -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,0.9955585801783728,44.708903789520264,opt -inject-tli-mappings -sroa -loop-predication -globalopt -rewrite-statepoints-for-gc -sink -loop-instsimplify -functionattrs -loop-idiom -canonicalize-aliases -separate-const-offset-from-gep -aggressive-instcombine -ipconstprop -loop-simplify -lower-expect -gvn -scalarizer -reassociate -die -loop-interchange -sroa -lower-widenable-condition -consthoist -redundant-dbg-inst-elim -hotcoldsplit -constprop -loop-reroll -consthoist -sroa -canonicalize-aliases -strip -mergeicmps -add-discriminators -rpo-functionattrs -slsr -irce -constprop -constprop -sancov -lower-guard-intrinsic -break-crit-edges -loop-simplify -indvars -loop-instsimplify -mergefunc -loweratomic -irce -gvn-hoist -add-discriminators -instsimplify -aggressive-instcombine -coro-cleanup -inferattrs -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,0.9997492746874888,38.4443724155426,opt -consthoist -bdce -sroa -simplifycfg -early-cse-memssa -jump-threading -dce -lower-expect -gvn -gvn-hoist -redundant-dbg-inst-elim -constmerge -mergefunc -lowerinvoke -speculative-execution -slp-vectorizer -irce -mergereturn -float2int -early-cse-memssa -lowerinvoke -prune-eh -prune-eh -loop-reroll -lower-guard-intrinsic -loop-guard-widening -lowerinvoke -newgvn -post-inline-ee-instrument -aggressive-instcombine input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.0063039507145672,50.186365604400635,opt -globaldce -lower-constant-intrinsics -coro-early -loop-unroll-and-jam -mergeicmps -lower-guard-intrinsic -loop-reduce -lower-guard-intrinsic -irce -bdce -callsite-splitting -elim-avail-extern -newgvn -float2int -simplifycfg -break-crit-edges -inject-tli-mappings -mergeicmps -add-discriminators -hotcoldsplit -deadargelim -attributor -lower-constant-intrinsics -float2int -name-anon-globals -always-inline -correlated-propagation -sroa -consthoist -strip-dead-prototypes -ipsccp -memcpyopt -globaldce -loop-instsimplify -loop-interchange -strip -reassociate -gvn -loop-versioning -irce -instnamer -barrier -lower-expect -barrier -loop-simplifycfg -strip-debug-declare -lower-guard-intrinsic -cross-dso-cfi -loop-instsimplify -gvn-hoist -gvn-hoist -sancov -mergereturn -aggressive-instcombine -mergefunc -bdce -loop-idiom -licm -coro-cleanup -sccp -ee-instrument -gvn -canonicalize-aliases -lower-widenable-condition -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.0131809878577311,40.80617117881775,opt -functionattrs -mem2reg -tailcallelim -loop-distribute -break-crit-edges -gvn-hoist -rewrite-statepoints-for-gc -coro-elide -float2int -globalsplit -ipconstprop -guard-widening -infer-address-spaces -scalarizer -lower-expect -add-discriminators -bdce -insert-gcov-profiling -loop-simplify -irce -lowerinvoke -loop-reroll -slp-vectorizer -slsr -rewrite-statepoints-for-gc -forceattrs -licm -sccp -simple-loop-unswitch -loop-versioning -coro-early -slsr -coro-early -instsimplify -loop-versioning-licm -coro-cleanup -irce -sancov -indvars -elim-avail-extern -div-rem-pairs -bdce -called-value-propagation -loop-load-elim -loop-idiom -mem2reg -speculative-execution -consthoist -strip -licm -loop-predication -rewrite-statepoints-for-gc -insert-gcov-profiling -gvn -post-inline-ee-instrument -dse -nary-reassociate -strip-debug-declare -lower-expect -loop-unroll-and-jam -lower-guard-intrinsic -scalarizer -early-cse-memssa -rpo-functionattrs -sancov -loop-load-elim -loop-reduce -speculative-execution -functionattrs -mergefunc -memcpyopt -irce -loop-predication -deadargelim -strip-nondebug -functionattrs -speculative-execution -gvn -instcombine -memcpyopt -sccp -prune-eh -loop-vectorize -dse -reassociate -lower-matrix-intrinsics -simplifycfg -coro-cleanup -lower-constant-intrinsics -alignment-from-assumptions -cross-dso-cfi -irce -loop-unroll -instcombine -hotcoldsplit -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.0268276084386976,46.057499408721924,opt -coro-split -loop-instsimplify -post-inline-ee-instrument -insert-gcov-profiling -guard-widening -loop-unroll -strip -dce -guard-widening -indvars -sancov -simplifycfg -lcssa -flattencfg -called-value-propagation -loop-distribute -jump-threading -lower-matrix-intrinsics -simple-loop-unswitch -mergefunc -loop-unroll -insert-gcov-profiling -mem2reg -adce -consthoist -strip-debug-declare -lower-expect -loop-guard-widening -loop-load-elim -mergefunc -deadargelim -irce -strip-dead-prototypes -gvn-hoist -slsr -loop-versioning -loop-fusion -memcpyopt -functionattrs -loop-distribute -loop-interchange -reassociate -barrier -float2int -pgo-memop-opt -indvars -slp-vectorizer -prune-eh -lower-widenable-condition -argpromotion -alignment-from-assumptions -elim-avail-extern -forceattrs -coro-elide -instcombine -aggressive-instcombine -reassociate -mem2reg -loop-versioning-licm -gvn -speculative-execution -loop-versioning-licm -bdce -tailcallelim -reg2mem -lower-constant-intrinsics -loop-fusion -sancov -mem2reg -instsimplify -loop-vectorize -globalsplit -partial-inliner -strip-debug-declare -flattencfg -loop-guard-widening -newgvn -irce -loop-versioning-licm -prune-eh -functionattrs -load-store-vectorizer -newgvn -lcssa -inject-tli-mappings -globalsplit -loop-deletion -loop-sink -inferattrs -loop-load-elim -hotcoldsplit -simple-loop-unswitch -loop-interchange -rewrite-statepoints-for-gc -hotcoldsplit -loop-data-prefetch -hotcoldsplit -functionattrs -flattencfg -deadargelim -aggressive-instcombine -post-inline-ee-instrument -break-crit-edges -bdce -lower-widenable-condition -flattencfg -inferattrs -gvn -globaldce -indvars -strip-debug-declare -licm -mergefunc -constmerge -irce -coro-split -post-inline-ee-instrument -loop-load-elim -redundant-dbg-inst-elim -rpo-functionattrs -gvn-hoist -loop-distribute -guard-widening -tailcallelim -adce -sroa -coro-early -jump-threading -speculative-execution -rewrite-statepoints-for-gc -early-cse-memssa -instcombine input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,0.9719230216860548,43.69095706939697,opt -adce -barrier -guard-widening -sancov -name-anon-globals -speculative-execution -mem2reg -ipconstprop -simple-loop-unswitch -strip -separate-const-offset-from-gep -always-inline -loop-versioning -loop-predication -loop-distribute -guard-widening -coro-split -constprop -lower-constant-intrinsics -constmerge -instcombine -tailcallelim -slp-vectorizer -mldst-motion -ee-instrument -loop-unroll -constprop -sroa -loop-sink -sink -libcalls-shrinkwrap -lowerswitch -ipsccp -instcombine -constmerge -separate-const-offset-from-gep -lower-matrix-intrinsics -simplifycfg -canonicalize-aliases -tailcallelim -ipsccp -always-inline -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,0.9994614390348989,43.0509147644043,opt -loop-unroll-and-jam -coro-split -loop-vectorize -strip-debug-declare -lowerinvoke -adce -guard-widening -reassociate -correlated-propagation -infer-address-spaces -coro-early -instnamer -loop-simplify -separate-const-offset-from-gep -newgvn -loop-vectorize -argpromotion -sancov -loop-reroll -coro-cleanup -ee-instrument -coro-early -post-inline-ee-instrument -instsimplify -canonicalize-aliases -strip-dead-prototypes -name-anon-globals -mem2reg -loop-fusion -gvn-hoist -lowerinvoke -called-value-propagation -loop-rotate -jump-threading -loop-instsimplify -lcssa -lower-expect -float2int -infer-address-spaces -mergefunc -mergereturn -mldst-motion -separate-const-offset-from-gep -lower-matrix-intrinsics -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.0002872325147207,40.322293758392334,opt -loop-fusion -strip-nondebug -strip-debug-declare -jump-threading -gvn-hoist -mergeicmps -sroa -adce -ee-instrument -globaldce -loop-guard-widening -loop-data-prefetch -constprop -tailcallelim -guard-widening -sccp -indvars -loop-unroll -loop-unswitch -jump-threading -gvn -add-discriminators -always-inline -instcombine input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.0014002585092634,43.58587026596069,opt -break-crit-edges -coro-early -strip -loop-versioning -mergefunc -mem2reg -reassociate -nary-reassociate -flattencfg -insert-gcov-profiling -sroa -strip-dead-prototypes -loop-versioning -die -correlated-propagation -slsr -loop-vectorize -div-rem-pairs -barrier -barrier -loop-predication -elim-avail-extern -gvn -loop-unroll-and-jam -loop-interchange -coro-split -attributor -inject-tli-mappings -pgo-memop-opt -jump-threading -lower-constant-intrinsics -loop-instsimplify -instsimplify -memcpyopt -mem2reg -always-inline -nary-reassociate -loop-deletion -dce -mergereturn -lcssa -instcombine input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.0040212552060892,110.09268641471863,opt -ipsccp -callsite-splitting -mldst-motion -libcalls-shrinkwrap -loop-unroll -mldst-motion -loop-unroll -loop-unswitch -sroa -constmerge -lcssa -sccp -div-rem-pairs -constmerge -argpromotion -early-cse-memssa -prune-eh -insert-gcov-profiling -rpo-functionattrs -rewrite-statepoints-for-gc -constprop -attributor -dse -strip-nondebug -gvn-hoist -deadargelim -lower-constant-intrinsics -sroa -early-cse-memssa -coro-cleanup -strip-debug-declare -strip-dead-prototypes -div-rem-pairs -alignment-from-assumptions -scalarizer -licm -ee-instrument -rewrite-statepoints-for-gc -functionattrs -correlated-propagation -always-inline -loop-instsimplify -insert-gcov-profiling -reassociate -die -dse -strip -canonicalize-aliases -ipconstprop -early-cse-memssa -rpo-functionattrs -coro-cleanup -simple-loop-unswitch -libcalls-shrinkwrap -lower-guard-intrinsic -globaldce -loop-deletion -loweratomic -mergeicmps -inject-tli-mappings -coro-split -loop-unroll -callsite-splitting -loop-unroll -scalarizer -sroa -loop-data-prefetch -strip-dead-prototypes -div-rem-pairs -dse -slsr -libcalls-shrinkwrap -loop-data-prefetch -add-discriminators -adce -gvn -bdce -loop-instsimplify -loop-fusion -die -instsimplify -correlated-propagation -constmerge -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.0187060175211833,35.92176580429077,opt -coro-early -attributor -mem2reg -argpromotion -ipconstprop -coro-cleanup -strip-debug-declare -scalarizer -break-crit-edges -inject-tli-mappings -loop-distribute -inferattrs -coro-cleanup -loop-simplifycfg -gvn -bdce -libcalls-shrinkwrap -consthoist -consthoist -bdce -loop-distribute -simplifycfg -coro-split -inject-tli-mappings -alignment-from-assumptions -always-inline -name-anon-globals -dse -barrier -rewrite-statepoints-for-gc -lower-matrix-intrinsics -coro-elide -instcombine input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.0204653166738475,47.219963788986206,opt -loop-load-elim -gvn-hoist -irce -argpromotion -consthoist -ipconstprop -loop-distribute -alignment-from-assumptions -redundant-dbg-inst-elim -sroa -jump-threading -inferattrs -loop-reroll -instnamer -callsite-splitting -jump-threading -instnamer -lower-matrix-intrinsics -indvars -sancov -always-inline -loop-sink -lower-expect -mergefunc -coro-elide -tailcallelim -gvn-hoist -float2int -globaldce -early-cse-memssa -indvars -bdce -mem2reg -simplifycfg -memcpyopt -jump-threading -ee-instrument -infer-address-spaces -indvars -add-discriminators -instcombine input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.0306979750107712,42.30078458786011,opt -rpo-functionattrs -globalopt -inject-tli-mappings -rewrite-statepoints-for-gc -name-anon-globals -loop-versioning -add-discriminators -bdce -globaldce -dce -load-store-vectorizer -mem2reg -ee-instrument -loop-simplifycfg -loop-interchange -break-crit-edges -infer-address-spaces -loop-versioning-licm -pgo-memop-opt -dce -loop-predication -speculative-execution -slp-vectorizer -callsite-splitting -bdce -dce -cross-dso-cfi -adce -partially-inline-libcalls -canonicalize-aliases -lower-widenable-condition -instcombine -correlated-propagation -inferattrs -coro-early -loop-unroll-and-jam -loop-interchange -globaldce -newgvn -simplifycfg -strip-nondebug -scalarizer -instcombine input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.0324213700990954,46.63143301010132,opt -scalarizer -sccp -loop-unroll -infer-address-spaces -irce -lower-constant-intrinsics -forceattrs -instsimplify -inferattrs -elim-avail-extern -loop-distribute -loop-unswitch -mergefunc -lower-matrix-intrinsics -globalopt -consthoist -loop-versioning-licm -correlated-propagation -inferattrs -loop-versioning-licm -reassociate -libcalls-shrinkwrap -coro-early -load-store-vectorizer -loop-data-prefetch -redundant-dbg-inst-elim -tailcallelim -sroa -simplifycfg -add-discriminators -instnamer -simplifycfg -licm -simple-loop-unswitch -prune-eh -newgvn -loop-simplify -loop-fusion -rpo-functionattrs -loop-simplifycfg -jump-threading -always-inline -post-inline-ee-instrument -functionattrs -argpromotion -inferattrs -constprop -insert-gcov-profiling -sccp -alignment-from-assumptions -tailcallelim -dce -jump-threading -instcombine -loop-distribute -globaldce -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.0421872755995978,62.661231994628906,opt -lower-constant-intrinsics -libcalls-shrinkwrap -lcssa -loop-simplifycfg -loop-data-prefetch -deadargelim -load-store-vectorizer -lower-guard-intrinsic -libcalls-shrinkwrap -loop-instsimplify -reg2mem -strip-debug-declare -sccp -inferattrs -globalopt -jump-threading -memcpyopt -loop-instsimplify -loop-sink -loop-unroll-and-jam -coro-early -attributor -loop-simplify -lower-widenable-condition -coro-early -ee-instrument -called-value-propagation -hotcoldsplit -loop-unroll -speculative-execution -coro-split -rpo-functionattrs -newgvn -div-rem-pairs -hotcoldsplit -tailcallelim -strip-dead-prototypes -lowerinvoke -canonicalize-aliases -name-anon-globals -sancov -gvn-hoist -separate-const-offset-from-gep -name-anon-globals -loop-simplifycfg -memcpyopt -strip-dead-prototypes -tailcallelim -sroa -cross-dso-cfi -loop-deletion -instsimplify -sancov -consthoist -loop-unroll -memcpyopt -loop-distribute -loop-predication -loweratomic -loop-data-prefetch -speculative-execution -name-anon-globals -aggressive-instcombine -coro-cleanup -lcssa -aggressive-instcombine -called-value-propagation -sancov -loop-predication -loop-fusion -libcalls-shrinkwrap -partially-inline-libcalls -coro-cleanup -constprop -loop-guard-widening -break-crit-edges -separate-const-offset-from-gep -lower-matrix-intrinsics -always-inline -mergereturn -sink -lower-guard-intrinsic -break-crit-edges -slsr -sancov -loop-load-elim -strip -lcssa -instcombine -callsite-splitting -coro-split -bdce -rpo-functionattrs -early-cse-memssa -loop-reroll -sancov -die -simplifycfg -coro-elide -lower-constant-intrinsics -loop-data-prefetch -mergefunc -lcssa -nary-reassociate -simple-loop-unswitch -attributor -loop-reroll -name-anon-globals -adce -inferattrs -licm -cross-dso-cfi -newgvn -newgvn -indvars -inferattrs -inject-tli-mappings -loop-unroll -guard-widening -loop-interchange -loop-simplify -instcombine -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffdither,0.9824466551326413,41.701881647109985,opt -dse -constprop -coro-split -sroa -mergereturn -cross-dso-cfi -rpo-functionattrs -memcpyopt -lower-widenable-condition -lowerinvoke -attributor -lowerinvoke -mergefunc -mergefunc -lower-constant-intrinsics -coro-early -prune-eh -loop-unroll-and-jam -slp-vectorizer -loop-unswitch -memcpyopt -loop-idiom -lcssa -post-inline-ee-instrument -jump-threading -constprop -gvn-hoist -simplifycfg -libcalls-shrinkwrap -gvn input.bc -o output.bc -benchmark://cBench-v1/tiffdither,0.9888985005767011,41.054413080215454,opt -infer-address-spaces -sink -elim-avail-extern -deadargelim -loop-distribute -gvn -loop-idiom -loop-deletion -rpo-functionattrs -ee-instrument -loop-versioning -simple-loop-unswitch -constprop -lower-expect -sancov -globalopt -elim-avail-extern -elim-avail-extern -dce -mergefunc -gvn -early-cse-memssa -die -irce -guard-widening -barrier -rewrite-statepoints-for-gc -mergereturn -gvn-hoist -loop-data-prefetch -functionattrs -mem2reg -partial-inliner -die -partial-inliner -strip-debug-declare -loop-distribute -coro-early -tailcallelim -mergereturn -lcssa -mldst-motion -libcalls-shrinkwrap -slsr -consthoist -infer-address-spaces -die -instsimplify -loop-load-elim -mergereturn -gvn -aggressive-instcombine -coro-cleanup -rewrite-statepoints-for-gc -consthoist -tailcallelim -aggressive-instcombine -hotcoldsplit -loop-reroll -strip-debug-declare -globalopt -memcpyopt -lower-matrix-intrinsics -correlated-propagation -newgvn -instcombine -strip -loop-guard-widening -loop-deletion -forceattrs -name-anon-globals -dse -libcalls-shrinkwrap -mergefunc -redundant-dbg-inst-elim -strip-nondebug -scalarizer -mldst-motion -sroa -globaldce -inferattrs -guard-widening -loop-unroll-and-jam -loop-instsimplify -instsimplify -partially-inline-libcalls -lower-widenable-condition -jump-threading -called-value-propagation -newgvn input.bc -o output.bc -benchmark://cBench-v1/tiffdither,0.9970444059976932,49.48758888244629,opt -guard-widening -pgo-memop-opt -gvn-hoist -early-cse-memssa -aggressive-instcombine -strip-nondebug -name-anon-globals -guard-widening -instsimplify -cross-dso-cfi -mem2reg -float2int -loop-data-prefetch -lower-expect -loop-predication -correlated-propagation -insert-gcov-profiling -sink -redundant-dbg-inst-elim -scalarizer -coro-early -elim-avail-extern -adce -scalarizer -separate-const-offset-from-gep -aggressive-instcombine -strip-dead-prototypes -partially-inline-libcalls -licm -loop-simplify -loop-unroll -called-value-propagation -scalarizer -add-discriminators -gvn -callsite-splitting -gvn -inject-tli-mappings -deadargelim -redundant-dbg-inst-elim -loop-rotate -gvn-hoist -functionattrs -simple-loop-unswitch -strip -instnamer -instcombine -loop-data-prefetch -lcssa -early-cse-memssa -indvars -reassociate -strip-nondebug -instcombine -early-cse-memssa -lower-widenable-condition -loop-reroll -post-inline-ee-instrument -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffdither,0.999315167243368,62.450594902038574,opt -lower-widenable-condition -gvn -cross-dso-cfi -strip-nondebug -always-inline -loweratomic -tailcallelim -lower-constant-intrinsics -indvars -mem2reg -float2int -ipconstprop -argpromotion -die -pgo-memop-opt -speculative-execution -dse -globalsplit -loop-fusion -pgo-memop-opt -called-value-propagation -flattencfg -callsite-splitting -loop-data-prefetch -loop-predication -prune-eh -jump-threading -callsite-splitting -div-rem-pairs -loop-simplifycfg -indvars -die -loop-unroll -licm -ipsccp -newgvn -simplifycfg -gvn-hoist -globalopt -coro-early -loop-simplify -loop-deletion -ipsccp -canonicalize-aliases -always-inline -coro-cleanup -globaldce -constprop -gvn -loop-load-elim -lower-guard-intrinsic -nary-reassociate -barrier -infer-address-spaces -lowerinvoke -always-inline -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.0058751441753175,39.923675298690796,opt -post-inline-ee-instrument -coro-early -coro-early -add-discriminators -sroa -hotcoldsplit -loop-unroll -always-inline -insert-gcov-profiling -insert-gcov-profiling -indvars -memcpyopt -ipconstprop -always-inline -instcombine -insert-gcov-profiling -ee-instrument -rpo-functionattrs -adce -reg2mem -gvn-hoist -pgo-memop-opt -instnamer -called-value-propagation -rewrite-statepoints-for-gc -tailcallelim -sccp -barrier -flattencfg -simplifycfg -loweratomic -mergefunc -coro-elide -mem2reg -dse -forceattrs -deadargelim -strip-nondebug -loop-simplify -rpo-functionattrs -slsr -early-cse-memssa -loop-idiom -break-crit-edges -memcpyopt -called-value-propagation -loop-simplifycfg -lower-widenable-condition -mem2reg -dce -consthoist -jump-threading -licm -loop-simplify -adce -strip-dead-prototypes -loop-guard-widening -loop-idiom -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.0083621683967705,67.24185132980347,opt -prune-eh -coro-early -loop-deletion -simplifycfg -instnamer -inject-tli-mappings -bdce -lower-expect -div-rem-pairs -lowerinvoke -loop-load-elim -mergefunc -nary-reassociate -partially-inline-libcalls -prune-eh -sroa -aggressive-instcombine -tailcallelim -gvn-hoist -loop-simplifycfg -sccp -simplifycfg -instsimplify -early-cse-memssa -forceattrs -add-discriminators -dse -insert-gcov-profiling -correlated-propagation -lower-matrix-intrinsics -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.0100562283737027,38.78786373138428,opt -reg2mem -post-inline-ee-instrument -lower-matrix-intrinsics -dce -loop-distribute -ipsccp -newgvn -consthoist -sancov -load-store-vectorizer -mem2reg -indvars -sink -bdce -early-cse-memssa -loop-guard-widening -slp-vectorizer -tailcallelim -scalarizer -strip -licm -constmerge -cross-dso-cfi -mergereturn -gvn -simplifycfg -redundant-dbg-inst-elim -globalopt -inject-tli-mappings -inferattrs -libcalls-shrinkwrap -canonicalize-aliases -bdce -globaldce -instnamer -always-inline -rewrite-statepoints-for-gc -rpo-functionattrs -loop-vectorize -dse -div-rem-pairs -div-rem-pairs -simple-loop-unswitch -prune-eh -flattencfg -gvn -loop-deletion -elim-avail-extern -adce -functionattrs -instcombine input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.0121828143021916,41.328232288360596,opt -deadargelim -scalarizer -sancov -sancov -name-anon-globals -lowerinvoke -reg2mem -slsr -loop-guard-widening -die -jump-threading -argpromotion -loop-vectorize -loop-distribute -lower-constant-intrinsics -simple-loop-unswitch -loop-reroll -lower-expect -adce -separate-const-offset-from-gep -lower-guard-intrinsic -simple-loop-unswitch -reassociate -mem2reg -cross-dso-cfi -attributor -sroa -div-rem-pairs -guard-widening -mergefunc -barrier -forceattrs -redundant-dbg-inst-elim -lower-widenable-condition -loop-idiom -consthoist -mergeicmps -callsite-splitting -tailcallelim -globalsplit -add-discriminators -inject-tli-mappings -argpromotion -globalopt -loop-instsimplify -scalarizer -loop-guard-widening -loop-load-elim -mergefunc -instsimplify -nary-reassociate -loop-simplifycfg -deadargelim -loop-instsimplify -scalarizer -hotcoldsplit -simple-loop-unswitch -lower-expect -die -lcssa -early-cse-memssa -rewrite-statepoints-for-gc -strip-dead-prototypes -licm -loop-unswitch -instcombine -separate-const-offset-from-gep -loop-deletion -loop-versioning-licm -loop-versioning -simplifycfg -loop-interchange -attributor -redundant-dbg-inst-elim -globalopt -mldst-motion -gvn -loop-unroll-and-jam -argpromotion -cross-dso-cfi -loop-deletion -sancov -lower-expect -instcombine -loop-predication -gvn input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.0269247404844288,40.07159352302551,opt -div-rem-pairs -mem2reg -mergereturn -mergeicmps -loop-distribute -instcombine -mergefunc -loop-load-elim -infer-address-spaces -loop-distribute -lcssa -forceattrs -loop-predication -dce -libcalls-shrinkwrap -mergeicmps -loop-versioning-licm -memcpyopt -irce -float2int -loop-fusion -float2int -break-crit-edges -div-rem-pairs -coro-elide -attributor -loop-deletion -coro-elide -name-anon-globals -rpo-functionattrs -irce -inferattrs -canonicalize-aliases -newgvn -lower-constant-intrinsics -lower-constant-intrinsics -argpromotion -simplifycfg -forceattrs -add-discriminators -loop-instsimplify -instcombine -inferattrs -prune-eh -slp-vectorizer -correlated-propagation -aggressive-instcombine -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.0273212226066895,331.82224774360657,opt -strip-dead-prototypes -cross-dso-cfi -loop-distribute -mergefunc -loop-idiom -loop-distribute -lower-widenable-condition -loop-deletion -coro-cleanup -lcssa -post-inline-ee-instrument -elim-avail-extern -add-discriminators -consthoist -inferattrs -partially-inline-libcalls -sink -reg2mem -loop-deletion -coro-early -simplifycfg -strip-nondebug -lcssa -coro-cleanup -indvars -load-store-vectorizer -licm -always-inline -simple-loop-unswitch -instsimplify -sroa -mergeicmps -globaldce -separate-const-offset-from-gep -loweratomic -instcombine -tailcallelim -canonicalize-aliases -loop-predication -tailcallelim -newgvn -partially-inline-libcalls -callsite-splitting -alignment-from-assumptions -strip-nondebug -coro-elide -loop-interchange -coro-split -load-store-vectorizer -lower-constant-intrinsics -guard-widening -nary-reassociate -lowerinvoke -loop-deletion -float2int -constprop -loop-simplify -simplifycfg -separate-const-offset-from-gep -consthoist -early-cse-memssa -jump-threading -newgvn -cross-dso-cfi -pgo-memop-opt -elim-avail-extern -attributor -scalarizer -barrier -coro-cleanup -early-cse-memssa -nary-reassociate -inferattrs -loop-simplify -ipconstprop -speculative-execution -strip -strip-dead-prototypes -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,0.9665311977049962,47.10209608078003,opt -name-anon-globals -globalopt -loop-rotate -lower-widenable-condition -flattencfg -instnamer -div-rem-pairs -lcssa -loop-deletion -loop-rotate -die -ipconstprop -libcalls-shrinkwrap -sink -simplifycfg -loop-simplifycfg -infer-address-spaces -coro-early -attributor -scalarizer -bdce -mem2reg -lowerinvoke -attributor -loop-unroll-and-jam -pgo-memop-opt -ipconstprop -globalsplit -instsimplify -strip -hotcoldsplit -newgvn -instsimplify -licm -loop-distribute -loop-distribute -lcssa -nary-reassociate -lower-guard-intrinsic -reassociate -loop-unroll -guard-widening -lcssa -irce -indvars -strip -coro-early -strip -constprop -mergeicmps -canonicalize-aliases -instcombine -instsimplify -loop-reroll -mergeicmps -loop-fusion -float2int -dse -gvn -rpo-functionattrs -gvn-hoist -flattencfg -loop-distribute -reassociate input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,0.9784843413817833,45.35628080368042,opt -sink -deadargelim -mldst-motion -gvn-hoist -globalopt -elim-avail-extern -infer-address-spaces -instnamer -lcssa -ipconstprop -insert-gcov-profiling -insert-gcov-profiling -inferattrs -mergeicmps -adce -loop-simplifycfg -callsite-splitting -mem2reg -loop-fusion -instsimplify -redundant-dbg-inst-elim -callsite-splitting -mem2reg -tailcallelim -aggressive-instcombine -loop-rotate -constprop -attributor -gvn -consthoist -mldst-motion -sancov -argpromotion -redundant-dbg-inst-elim -simplifycfg -nary-reassociate input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,0.9825142583928143,44.82570767402649,opt -callsite-splitting -rpo-functionattrs -loop-load-elim -partially-inline-libcalls -lower-matrix-intrinsics -separate-const-offset-from-gep -nary-reassociate -lowerinvoke -dse -sink -loop-data-prefetch -separate-const-offset-from-gep -strip-nondebug -gvn -elim-avail-extern -loop-vectorize -strip-nondebug -strip -lower-expect -coro-cleanup -irce -bdce -loop-load-elim -constprop -lowerinvoke -mem2reg -gvn -simplifycfg -inferattrs -ipsccp -lower-guard-intrinsic -memcpyopt -early-cse-memssa -mergeicmps -attributor -strip -argpromotion -loop-distribute -loop-fusion -ipsccp -coro-cleanup -newgvn -slp-vectorizer -loop-data-prefetch -mem2reg -die -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,0.990608244253953,337.1097273826599,opt -partially-inline-libcalls -mem2reg -attributor -consthoist -loweratomic -libcalls-shrinkwrap -loop-guard-widening -loweratomic -lower-expect -instcombine -loop-fusion -inferattrs -argpromotion -aggressive-instcombine -loop-rotate -elim-avail-extern -cross-dso-cfi -strip -div-rem-pairs -correlated-propagation -ee-instrument -sccp -post-inline-ee-instrument -simple-loop-unswitch -loop-interchange -forceattrs -add-discriminators -lcssa -loop-load-elim -rewrite-statepoints-for-gc -inject-tli-mappings -sink -mergeicmps -strip -coro-early -rewrite-statepoints-for-gc -lower-guard-intrinsic -lower-constant-intrinsics -argpromotion -newgvn -cross-dso-cfi -cross-dso-cfi -lower-constant-intrinsics -instnamer -loop-idiom -hotcoldsplit -mergereturn -licm -loop-load-elim -tailcallelim -coro-cleanup -sink -sccp -sroa -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,0.9914278883917897,41.52029347419739,opt -rpo-functionattrs -loop-unswitch -elim-avail-extern -ipsccp -dse -float2int -consthoist -lower-widenable-condition -flattencfg -strip-dead-prototypes -functionattrs -instcombine -partially-inline-libcalls -coro-cleanup -hotcoldsplit -rpo-functionattrs -libcalls-shrinkwrap -rpo-functionattrs -partially-inline-libcalls -slp-vectorizer -mergeicmps -coro-early -gvn-hoist -simple-loop-unswitch -loop-instsimplify -loop-guard-widening -pgo-memop-opt -loop-guard-widening -loop-reduce -div-rem-pairs -instsimplify -alignment-from-assumptions -rewrite-statepoints-for-gc -gvn-hoist -name-anon-globals -sroa -loop-instsimplify -coro-early -reassociate -libcalls-shrinkwrap -float2int -sancov -break-crit-edges -partial-inliner -lcssa -scalarizer -strip -early-cse-memssa -newgvn -memcpyopt -globalopt -deadargelim -globalsplit -simplifycfg -mergeicmps -functionattrs -mldst-motion -lower-matrix-intrinsics -ipsccp -coro-cleanup -dse -loop-unswitch -instcombine -ipconstprop -reg2mem -flattencfg -flattencfg -loop-reduce -coro-split -loop-deletion -loop-simplify -canonicalize-aliases -loop-load-elim -prune-eh -called-value-propagation -sccp -loop-versioning -coro-split -break-crit-edges -inject-tli-mappings -sroa -ipconstprop -lower-matrix-intrinsics -functionattrs -always-inline -elim-avail-extern -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,0.9923499880468563,40.777365922927856,opt -cross-dso-cfi -gvn -die -mem2reg -lcssa -rpo-functionattrs -reassociate -simplifycfg -name-anon-globals -lower-guard-intrinsic -inject-tli-mappings -irce -irce -jump-threading -loop-versioning-licm -inject-tli-mappings -aggressive-instcombine -newgvn -strip-debug-declare -sink -reassociate -aggressive-instcombine input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,0.9933062395409992,46.45159435272217,opt -separate-const-offset-from-gep -mergefunc -strip -ee-instrument -reg2mem -always-inline -scalarizer -coro-cleanup -flattencfg -lcssa -globaldce -sroa -memcpyopt -slp-vectorizer -loop-deletion -coro-early -loop-reduce -break-crit-edges -die -callsite-splitting -instsimplify -coro-split -sroa -instcombine -flattencfg -lower-widenable-condition -loop-unroll-and-jam -bdce -coro-cleanup -mergeicmps -redundant-dbg-inst-elim -loop-simplifycfg -prune-eh -rewrite-statepoints-for-gc -instsimplify -elim-avail-extern -ipsccp -strip-nondebug -dse -gvn -strip -consthoist -elim-avail-extern -partially-inline-libcalls -slsr -loop-idiom -div-rem-pairs -alignment-from-assumptions -coro-elide -simplifycfg -die input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,0.9949796796557496,49.326151609420776,opt -forceattrs -loop-distribute -slp-vectorizer -constmerge -libcalls-shrinkwrap -loop-idiom -sroa -gvn-hoist -simplifycfg -loop-sink -instnamer -instnamer -gvn -constmerge -loop-guard-widening -lower-constant-intrinsics -pgo-memop-opt -forceattrs -rpo-functionattrs -scalarizer -instnamer -loop-rotate -loweratomic -canonicalize-aliases -sink -instcombine -separate-const-offset-from-gep -aggressive-instcombine -loop-predication -instsimplify -ee-instrument -deadargelim -coro-cleanup -coro-split -callsite-splitting -lower-matrix-intrinsics -slsr -loop-predication -hotcoldsplit -mergeicmps -reassociate -always-inline -bdce -strip-nondebug -globaldce -loop-fusion -hotcoldsplit -loop-instsimplify -ipsccp -coro-split -ipconstprop -globaldce -barrier -strip-nondebug -coro-cleanup -sroa -inferattrs -mldst-motion -mergeicmps -post-inline-ee-instrument -globalsplit -globalsplit -adce -lower-guard-intrinsic -sccp -strip-nondebug -loop-reduce -break-crit-edges -deadargelim -memcpyopt -globalopt -sccp -loop-fusion -alignment-from-assumptions -loop-unroll -adce -speculative-execution -dse -die -gvn -coro-cleanup -strip -simple-loop-unswitch -correlated-propagation -lower-guard-intrinsic -constmerge -simplifycfg -gvn -gvn-hoist -lowerinvoke -called-value-propagation -instsimplify input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.0114408660906389,45.817564964294434,opt -deadargelim -separate-const-offset-from-gep -alignment-from-assumptions -lower-widenable-condition -loop-versioning -sroa -loop-fusion -loop-distribute -mergereturn -alignment-from-assumptions -guard-widening -partially-inline-libcalls -hotcoldsplit -elim-avail-extern -break-crit-edges -rpo-functionattrs -alignment-from-assumptions -deadargelim -gvn-hoist -deadargelim -consthoist -break-crit-edges -loop-vectorize -reassociate -loop-load-elim -strip-nondebug -instcombine -div-rem-pairs -callsite-splitting -lowerinvoke -strip-dead-prototypes -loop-guard-widening -constprop -loop-versioning-licm -loop-interchange -loop-guard-widening -sroa -load-store-vectorizer -instcombine -loop-interchange -loop-vectorize -strip -newgvn -loop-sink -sroa -rewrite-statepoints-for-gc -simple-loop-unswitch -loop-unroll-and-jam -simplifycfg -loop-sink -float2int -simplifycfg -loop-fusion -separate-const-offset-from-gep -loop-predication -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.0162221235613536,45.437578201293945,opt -lowerinvoke -strip -inject-tli-mappings -mem2reg -called-value-propagation -callsite-splitting -globalopt -irce -simplifycfg -irce -sccp -infer-address-spaces -instcombine -loop-predication -slp-vectorizer -constmerge -instsimplify -canonicalize-aliases -memcpyopt -always-inline -dse -functionattrs -sancov -rewrite-statepoints-for-gc -lower-expect -dse -irce -jump-threading -aggressive-instcombine -loop-deletion -adce -separate-const-offset-from-gep -deadargelim -globalsplit -add-discriminators -loop-sink -strip-nondebug -mem2reg -scalarizer -constmerge -newgvn input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.994413407821229,12.527162551879883,opt -indvars -loop-unroll -infer-address-spaces -guard-widening -loop-reroll -loop-simplifycfg -loop-interchange -partial-inliner -nary-reassociate -loop-unroll-and-jam -coro-cleanup -rewrite-statepoints-for-gc -mergeicmps -slsr -loop-distribute -reassociate -lcssa -inferattrs -alignment-from-assumptions -coro-cleanup -loop-load-elim -mem2reg -slp-vectorizer -instsimplify -canonicalize-aliases -globalsplit -loop-reroll -instcombine -loop-load-elim -loop-simplifycfg -sroa -lower-widenable-condition -loop-instsimplify -rewrite-statepoints-for-gc -simplifycfg -rpo-functionattrs -sccp -nary-reassociate -lowerinvoke -loop-data-prefetch -lower-guard-intrinsic -loop-predication -sink -rpo-functionattrs -constprop -loop-unswitch -reassociate -lower-matrix-intrinsics -attributor -pgo-memop-opt -elim-avail-extern -inline -reassociate -speculative-execution -mem2reg -libcalls-shrinkwrap -jump-threading -loop-vectorize -loop-reduce -coro-split -functionattrs -simplifycfg -load-store-vectorizer -constprop -infer-address-spaces -loop-distribute -loop-versioning-licm -mergefunc -globalsplit -licm -lower-matrix-intrinsics -barrier -forceattrs -name-anon-globals -ee-instrument -cross-dso-cfi -lowerinvoke -instsimplify -pgo-memop-opt -die -reassociate -gvn input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9972067039106146,11.98168158531189,opt -post-inline-ee-instrument -called-value-propagation -alignment-from-assumptions -licm -prune-eh -loop-simplifycfg -loop-deletion -redundant-dbg-inst-elim -loop-sink -sroa -coro-early -mergereturn -lowerswitch -constprop -instsimplify -name-anon-globals -mergereturn -ipconstprop -alignment-from-assumptions -cross-dso-cfi -nary-reassociate -strip-debug-declare -instsimplify -argpromotion -post-inline-ee-instrument -loop-unswitch -barrier -indvars -strip-debug-declare -lowerinvoke -ee-instrument -instcombine -simplifycfg -loop-load-elim -break-crit-edges -argpromotion -load-store-vectorizer -loop-load-elim -callsite-splitting -newgvn -loop-reduce -gvn-hoist -inferattrs -loop-reduce -slp-vectorizer -irce -callsite-splitting -coro-early -add-discriminators -loop-sink -loop-reduce -die -called-value-propagation -constprop -rpo-functionattrs -irce -loop-versioning -deadargelim -loop-idiom -strip-debug-declare -post-inline-ee-instrument -loop-unroll -indvars -strip-debug-declare -separate-const-offset-from-gep -inline -loweratomic -loop-guard-widening -indvars -libcalls-shrinkwrap -loop-idiom -loweratomic -memcpyopt -callsite-splitting -coro-cleanup -pgo-memop-opt -instsimplify -reg2mem -float2int -add-discriminators -lower-constant-intrinsics -lower-expect -loop-simplify -globaldce -inject-tli-mappings -flattencfg -inject-tli-mappings -globalsplit -sroa -lower-expect -adce -forceattrs -loop-deletion -loop-simplify -inject-tli-mappings -sancov -inferattrs -loop-versioning -newgvn -loop-reroll -loop-load-elim -simplifycfg -instsimplify input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9972067039106146,12.768595933914185,opt -barrier -loop-predication -infer-address-spaces -loop-reroll -add-discriminators -prune-eh -aggressive-instcombine -strip -reg2mem -mldst-motion -alignment-from-assumptions -callsite-splitting -loop-unroll-and-jam -sancov -loop-predication -memcpyopt -loop-distribute -lower-expect -licm -break-crit-edges -deadargelim -sccp -loop-predication -sancov -correlated-propagation -slp-vectorizer -globalopt -gvn -slsr -lower-constant-intrinsics -loop-distribute -post-inline-ee-instrument -aggressive-instcombine -simplifycfg -instnamer -simple-loop-unswitch -reg2mem -inject-tli-mappings -constmerge -called-value-propagation -dce -mergeicmps -reassociate -strip-nondebug -forceattrs -consthoist -ipconstprop -strip-dead-prototypes -strip -redundant-dbg-inst-elim -attributor -deadargelim -mergereturn -loop-distribute -strip-dead-prototypes -forceattrs -constprop -partial-inliner -constmerge -argpromotion -elim-avail-extern -inferattrs -loop-simplify -globalsplit -loop-simplifycfg -lowerinvoke -sroa -mem2reg -loop-sink -deadargelim -adce -lower-matrix-intrinsics -loop-unroll -slp-vectorizer -globalopt -loop-instsimplify -nary-reassociate -loop-reduce -lowerinvoke -libcalls-shrinkwrap -rewrite-statepoints-for-gc -deadargelim -inject-tli-mappings -pgo-memop-opt -loop-unswitch -gvn-hoist -sroa -tailcallelim -lowerinvoke -simple-loop-unswitch -inline -loop-load-elim -consthoist -strip -strip-nondebug -slp-vectorizer -prune-eh -add-discriminators -lower-guard-intrinsic -add-discriminators -canonicalize-aliases -flattencfg -mldst-motion -simple-loop-unswitch -globalsplit -simple-loop-unswitch -mergeicmps -slsr -mergeicmps -strip-dead-prototypes -instnamer -load-store-vectorizer -float2int -mldst-motion -coro-early -partially-inline-libcalls -sccp -consthoist -float2int -attributor -constmerge -strip-dead-prototypes -ee-instrument -sccp -early-cse-memssa -strip -instsimplify -early-cse-memssa -die -loop-load-elim -loop-sink -mergereturn -gvn-hoist -consthoist -dce -constprop -sccp -float2int -inject-tli-mappings -guard-widening -slp-vectorizer -loop-unroll-and-jam -lowerswitch -inferattrs -lower-widenable-condition -globaldce -lowerswitch -sccp -lower-constant-intrinsics -float2int -inline -slp-vectorizer -sroa -dse -loop-unroll-and-jam -loop-versioning -tailcallelim -mem2reg -partial-inliner -loop-fusion -infer-address-spaces -mldst-motion -break-crit-edges -loop-predication -loop-unroll -newgvn -callsite-splitting -die -div-rem-pairs -instcombine -loop-data-prefetch -constmerge -float2int -redundant-dbg-inst-elim -simple-loop-unswitch -sroa -simple-loop-unswitch -loop-deletion -callsite-splitting -simplifycfg -loweratomic -loop-sink -inline -memcpyopt -add-discriminators -instnamer -loop-unroll -loop-deletion -globaldce -constprop -inject-tli-mappings -rewrite-statepoints-for-gc -always-inline -loop-simplify -lower-expect -loop-reroll -simple-loop-unswitch -correlated-propagation -coro-split -flattencfg -loweratomic -aggressive-instcombine -scalarizer -loop-idiom -separate-const-offset-from-gep -attributor -die -rewrite-statepoints-for-gc -coro-split -newgvn input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9972067039106147,12.197010517120361,opt -guard-widening -name-anon-globals -name-anon-globals -barrier -strip-nondebug -mem2reg -add-discriminators -pgo-memop-opt -insert-gcov-profiling -sink -die -sancov -strip-dead-prototypes -indvars -mergereturn -rewrite-statepoints-for-gc -loop-versioning-licm -loop-reduce -bdce -mergefunc -adce -flattencfg -guard-widening -break-crit-edges -mldst-motion -instsimplify -instnamer -instsimplify -bdce -instcombine -mergefunc -forceattrs -coro-early -loweratomic -loop-unswitch -infer-address-spaces -loop-fusion -load-store-vectorizer -rewrite-statepoints-for-gc -licm -ipsccp -separate-const-offset-from-gep -post-inline-ee-instrument -mergeicmps -mldst-motion -partial-inliner -attributor -load-store-vectorizer -partially-inline-libcalls -ee-instrument -nary-reassociate -dce -attributor -loop-distribute -functionattrs -name-anon-globals -nary-reassociate -ipsccp -globalsplit -strip-debug-declare -rpo-functionattrs -ee-instrument -strip-debug-declare -licm -inject-tli-mappings -sancov -forceattrs -early-cse-memssa -instnamer -bdce -licm -lower-widenable-condition -deadargelim -always-inline -loop-deletion -partially-inline-libcalls -newgvn -sink -ipsccp -add-discriminators -slp-vectorizer -div-rem-pairs -infer-address-spaces -loop-deletion -correlated-propagation -correlated-propagation -instnamer -loop-idiom -name-anon-globals -deadargelim -mergeicmps -coro-split -irce -tailcallelim -called-value-propagation -lower-expect -licm -loop-versioning -mergereturn -tailcallelim -loop-versioning-licm -aggressive-instcombine -functionattrs -mem2reg -constprop -sroa -lower-expect -mem2reg -libcalls-shrinkwrap -loweratomic -sccp -sccp -ipconstprop -barrier -loop-distribute -loop-versioning -lower-constant-intrinsics -redundant-dbg-inst-elim -scalarizer -aggressive-instcombine -gvn-hoist -speculative-execution -loop-unroll -partial-inliner -simple-loop-unswitch -alignment-from-assumptions -memcpyopt -strip -float2int -loop-vectorize -loop-versioning-licm -loop-vectorize -loop-reduce -rpo-functionattrs -die -loop-versioning-licm -loop-unswitch -licm -loop-reroll -called-value-propagation -always-inline -strip -lower-expect -newgvn -constmerge -loop-versioning-licm -adce -loop-predication -simple-loop-unswitch -consthoist -cross-dso-cfi -licm -adce -lower-widenable-condition -loop-idiom -simplifycfg -barrier -slp-vectorizer -loop-simplify -loop-unroll-and-jam -gvn-hoist -strip-dead-prototypes -inferattrs -loop-data-prefetch -elim-avail-extern -sccp -loweratomic -correlated-propagation -div-rem-pairs -lcssa -add-discriminators -functionattrs -instcombine -constprop -loop-instsimplify -strip-nondebug -separate-const-offset-from-gep -loop-load-elim -sccp -name-anon-globals -float2int -lower-expect -loop-simplify -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9972067039106147,12.215384006500244,opt -scalarizer -loop-distribute -mldst-motion -hotcoldsplit -loop-guard-widening -mergefunc -infer-address-spaces -add-discriminators -ipconstprop -cross-dso-cfi -tailcallelim -deadargelim -dce -instsimplify -loop-deletion -strip-nondebug -ipsccp -constprop -loop-instsimplify -inferattrs -loop-instsimplify -adce -forceattrs -tailcallelim -inferattrs -div-rem-pairs -loop-guard-widening -canonicalize-aliases -infer-address-spaces -always-inline -inject-tli-mappings -name-anon-globals -elim-avail-extern -scalarizer -strip-nondebug -elim-avail-extern -partial-inliner -coro-cleanup -irce -deadargelim -loop-reroll -ipconstprop -loop-simplify -redundant-dbg-inst-elim -loop-reroll -mergeicmps -scalarizer -lower-guard-intrinsic -loop-instsimplify -loop-deletion -irce -barrier -loop-unswitch -lower-expect -name-anon-globals -lower-widenable-condition -infer-address-spaces -mem2reg -loop-simplifycfg -elim-avail-extern -rewrite-statepoints-for-gc -adce -libcalls-shrinkwrap -post-inline-ee-instrument -reg2mem -bdce -strip -loop-instsimplify -newgvn -lower-expect -pgo-memop-opt -loop-simplify -globalopt -coro-split -sancov -instsimplify -constprop -loop-vectorize -mem2reg -redundant-dbg-inst-elim -slp-vectorizer -partially-inline-libcalls -callsite-splitting -constmerge -loop-simplify -loop-interchange -loop-unroll -loop-load-elim -inline -loop-load-elim -rewrite-statepoints-for-gc -memcpyopt -rpo-functionattrs -scalarizer -sancov -strip-dead-prototypes -constmerge -loop-sink -name-anon-globals -constmerge -globalsplit -lower-expect -nary-reassociate -loop-versioning-licm -lower-guard-intrinsic -adce -partial-inliner -loop-vectorize -called-value-propagation -partial-inliner -lower-guard-intrinsic -strip -loop-simplifycfg -lower-expect -mem2reg -simplifycfg -coro-cleanup -nary-reassociate -loop-simplify -barrier -loop-guard-widening -lower-matrix-intrinsics -bdce -deadargelim -loop-fusion -cross-dso-cfi -strip-nondebug -separate-const-offset-from-gep -sink -loop-vectorize -cross-dso-cfi -loop-unroll -correlated-propagation -loop-simplifycfg -lcssa -ipsccp -load-store-vectorizer -loop-reroll -simplifycfg -coro-elide -consthoist -gvn-hoist -elim-avail-extern -instsimplify -jump-threading -instsimplify -sancov -deadargelim -die -instnamer -add-discriminators -alignment-from-assumptions -sink -forceattrs -coro-early -dse -ipconstprop -loop-reroll -aggressive-instcombine -loop-reroll -globalsplit -mergeicmps -gvn -strip-debug-declare -sroa -instnamer -irce -sink -newgvn -add-discriminators -loop-deletion -strip-nondebug -instsimplify -loop-unroll -barrier -guard-widening -name-anon-globals -mergereturn -loop-vectorize -early-cse-memssa -die -bdce -reassociate -bdce -pgo-memop-opt -cross-dso-cfi -loop-interchange -mldst-motion -lower-widenable-condition -adce -add-discriminators -strip-dead-prototypes -lower-constant-intrinsics -attributor -simple-loop-unswitch -deadargelim -lowerswitch -loweratomic -callsite-splitting -gvn-hoist -flattencfg -speculative-execution -loop-unswitch -lowerswitch -mem2reg -loop-simplify -slsr -lcssa -canonicalize-aliases -canonicalize-aliases -slsr -always-inline -cross-dso-cfi -lowerinvoke -indvars -early-cse-memssa -callsite-splitting -globalsplit -lower-guard-intrinsic -coro-elide -insert-gcov-profiling -lower-widenable-condition -gvn-hoist -elim-avail-extern -dce -loweratomic -lower-constant-intrinsics -nary-reassociate -add-discriminators -adce -prune-eh -gvn -insert-gcov-profiling -cross-dso-cfi -memcpyopt -ipsccp -called-value-propagation -reassociate -irce -pgo-memop-opt -licm -loop-unroll-and-jam -deadargelim -dse -lower-widenable-condition -loop-simplify -lowerinvoke -memcpyopt -bdce -sancov -instsimplify -forceattrs -strip-dead-prototypes -consthoist -mem2reg -redundant-dbg-inst-elim -memcpyopt -inline -hotcoldsplit -jump-threading -gvn-hoist -mergeicmps -gvn -mem2reg -name-anon-globals -lower-expect -loop-sink -strip-nondebug -ee-instrument -attributor -ipsccp -licm -pgo-memop-opt -post-inline-ee-instrument -sink -loop-reduce -early-cse-memssa -loop-guard-widening -licm -break-crit-edges -lower-constant-intrinsics -canonicalize-aliases -loop-data-prefetch -coro-early -instnamer -simplifycfg -infer-address-spaces -instcombine -lowerswitch -coro-early -instsimplify -loop-versioning -add-discriminators -slsr -partial-inliner -barrier -coro-cleanup -lowerswitch -reassociate -licm -loop-unroll -loop-sink -strip-dead-prototypes -nary-reassociate -deadargelim -globaldce -simplifycfg -argpromotion -libcalls-shrinkwrap -prune-eh -loop-deletion -infer-address-spaces -early-cse-memssa -loop-unroll -infer-address-spaces -attributor -add-discriminators -flattencfg -load-store-vectorizer -lower-constant-intrinsics -loop-predication -early-cse-memssa -ipsccp -lowerswitch -speculative-execution -newgvn -sancov -flattencfg -reg2mem -ipsccp -libcalls-shrinkwrap -loop-idiom -lower-widenable-condition -loop-idiom -argpromotion -functionattrs -memcpyopt -mergefunc -loop-sink -globalsplit -always-inline -inject-tli-mappings -ee-instrument -loop-distribute -constprop -memcpyopt -simplifycfg -guard-widening -globaldce -ee-instrument -lowerinvoke -loop-sink -inject-tli-mappings -consthoist -rpo-functionattrs -infer-address-spaces -float2int -lower-guard-intrinsic -tailcallelim -correlated-propagation -loop-unroll-and-jam -pgo-memop-opt -scalarizer -load-store-vectorizer -instnamer -insert-gcov-profiling -alignment-from-assumptions -globalsplit -inject-tli-mappings -cross-dso-cfi -slsr -tailcallelim -dce -loop-data-prefetch -callsite-splitting -mergeicmps -callsite-splitting -globalopt -dse -pgo-memop-opt -aggressive-instcombine -irce -div-rem-pairs -lowerswitch -dce -post-inline-ee-instrument -libcalls-shrinkwrap -ipconstprop -lcssa -callsite-splitting -attributor -loop-idiom -mem2reg input.bc -o output.bc +benchmark://cbench-v1/adpcm,0.9999999999999999,12.475622177124023,opt -loweratomic -prune-eh -guard-widening -prune-eh -constmerge -gvn-hoist -gvn -coro-cleanup -load-store-vectorizer -scalarizer -jump-threading -slp-vectorizer -lower-guard-intrinsic -loop-reduce -nary-reassociate -mem2reg -lower-matrix-intrinsics -tailcallelim -constmerge -aggressive-instcombine -forceattrs -name-anon-globals -licm -constprop -consthoist -loop-deletion -pgo-memop-opt -div-rem-pairs -loop-simplifycfg -argpromotion -inject-tli-mappings -globalopt -slsr -loop-deletion -gvn -coro-elide -hotcoldsplit -instcombine -infer-address-spaces -loop-guard-widening -loop-vectorize -loop-sink -name-anon-globals -elim-avail-extern -redundant-dbg-inst-elim -loop-versioning -break-crit-edges -scalarizer -elim-avail-extern -irce -functionattrs -constprop -coro-cleanup -lower-constant-intrinsics -coro-early -mem2reg -correlated-propagation -sink -early-cse-memssa -early-cse-memssa -add-discriminators -dse -loop-distribute -libcalls-shrinkwrap -constprop -loop-instsimplify -loop-distribute -strip-dead-prototypes -strip-nondebug -libcalls-shrinkwrap -lower-matrix-intrinsics -coro-elide -tailcallelim -callsite-splitting -lowerswitch -libcalls-shrinkwrap -loop-simplify -lcssa -gvn-hoist -flattencfg -instnamer -load-store-vectorizer -dse -infer-address-spaces -loop-unswitch -prune-eh -forceattrs -alignment-from-assumptions -consthoist -guard-widening -lower-matrix-intrinsics -redundant-dbg-inst-elim -coro-cleanup -scalarizer -simple-loop-unswitch -rewrite-statepoints-for-gc -coro-early -sink -lcssa -gvn-hoist -loop-distribute -loop-deletion -insert-gcov-profiling -loop-distribute -loop-interchange -globalsplit -add-discriminators -loop-simplify -simplifycfg -prune-eh -always-inline -lower-guard-intrinsic -irce -simplifycfg -strip-debug-declare -argpromotion -strip -instcombine -sancov -gvn-hoist -consthoist -lowerinvoke -globalopt -loop-reduce -consthoist -argpromotion -rpo-functionattrs -deadargelim -jump-threading -barrier -functionattrs -speculative-execution -argpromotion -loop-distribute -bdce -mergereturn -ipconstprop -loop-fusion -loop-idiom -loop-guard-widening -mldst-motion -name-anon-globals -post-inline-ee-instrument -newgvn -functionattrs -lower-matrix-intrinsics -float2int -loop-sink -post-inline-ee-instrument -loop-idiom -scalarizer -always-inline -name-anon-globals -coro-early -strip -gvn -load-store-vectorizer -loop-reduce -flattencfg -inferattrs -reg2mem -aggressive-instcombine -bdce -argpromotion -memcpyopt -lcssa -loop-distribute -infer-address-spaces -add-discriminators -coro-split -lower-widenable-condition -strip-dead-prototypes -lower-guard-intrinsic -always-inline -add-discriminators -called-value-propagation -bdce -mergefunc -instnamer -loop-reroll -tailcallelim -div-rem-pairs -loweratomic -reg2mem -sancov -coro-elide -ee-instrument -sroa -argpromotion -simplifycfg -simplifycfg -partially-inline-libcalls -inferattrs -gvn -sancov -strip-nondebug -lcssa -licm -tailcallelim -ee-instrument -canonicalize-aliases -loop-fusion -functionattrs -lowerswitch -always-inline -alignment-from-assumptions -loop-simplify -lowerinvoke -separate-const-offset-from-gep -lowerswitch -lcssa -gvn -alignment-from-assumptions -sink -aggressive-instcombine -break-crit-edges -scalarizer -float2int -indvars -gvn -ipconstprop -loop-guard-widening -nary-reassociate -instcombine -die -loop-unswitch -loop-idiom -pgo-memop-opt -consthoist -loop-unroll-and-jam -slsr -attributor -adce -gvn-hoist -slp-vectorizer -strip -mem2reg -lower-widenable-condition -strip-nondebug -licm -coro-elide -ee-instrument -consthoist -constprop -simplifycfg -functionattrs -coro-cleanup -alignment-from-assumptions -called-value-propagation -slsr -functionattrs -loop-reroll -loop-simplifycfg -forceattrs -cross-dso-cfi -loop-data-prefetch -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/adpcm,1.0000000000000002,12.368368148803711,opt -libcalls-shrinkwrap -globaldce -globalopt -loop-sink -callsite-splitting -post-inline-ee-instrument -mergeicmps -jump-threading -loop-instsimplify -mldst-motion -lowerswitch -sccp -sccp -elim-avail-extern -gvn -add-discriminators -ipsccp -loop-versioning-licm -insert-gcov-profiling -mergeicmps -coro-cleanup -bdce -constprop -strip -loop-fusion -callsite-splitting -early-cse-memssa -mergefunc -loop-instsimplify -strip-nondebug -forceattrs -forceattrs -mergereturn -strip-dead-prototypes -coro-split -aggressive-instcombine -reassociate -coro-cleanup -loop-simplifycfg -sink -load-store-vectorizer -constprop -loop-unswitch -loop-distribute -lower-matrix-intrinsics -float2int -pgo-memop-opt -loop-unroll -loop-unroll-and-jam -guard-widening -reg2mem -ee-instrument -always-inline -strip -slp-vectorizer -flattencfg -deadargelim -called-value-propagation -globalopt -mldst-motion -consthoist -infer-address-spaces -loop-fusion -infer-address-spaces -post-inline-ee-instrument -partial-inliner -loop-sink -deadargelim -sroa -lcssa -loop-versioning-licm -simplifycfg -simplifycfg -load-store-vectorizer -deadargelim -partial-inliner -loop-fusion -redundant-dbg-inst-elim -partial-inliner -partially-inline-libcalls -elim-avail-extern -constprop -loop-deletion -memcpyopt -lowerswitch -loop-predication -strip-debug-declare -lower-guard-intrinsic -dce -indvars -licm -deadargelim -coro-early -partially-inline-libcalls -functionattrs -loop-instsimplify -loop-idiom -lowerswitch -separate-const-offset-from-gep -instsimplify -redundant-dbg-inst-elim -loop-deletion -scalarizer -instcombine -memcpyopt -irce -lower-guard-intrinsic -indvars -loop-distribute -mem2reg -gvn -aggressive-instcombine -loop-interchange -always-inline -rewrite-statepoints-for-gc -lower-widenable-condition -partial-inliner -sccp -alignment-from-assumptions -gvn-hoist -attributor -dse -bdce -insert-gcov-profiling -argpromotion -gvn -loop-distribute -loop-simplify -die -instnamer -memcpyopt -coro-elide -coro-split -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/adpcm,1.0027932960893855,12.703411340713501,opt -irce -consthoist -separate-const-offset-from-gep -sroa -add-discriminators -inferattrs -sroa -loop-data-prefetch -forceattrs -partially-inline-libcalls -loop-fusion -mldst-motion -flattencfg -loop-distribute -simplifycfg -callsite-splitting -separate-const-offset-from-gep -sccp -lower-constant-intrinsics -instcombine -indvars -loop-vectorize -add-discriminators -nary-reassociate -strip-debug-declare -float2int -loop-distribute -insert-gcov-profiling -jump-threading -reassociate -flattencfg -sink -add-discriminators -memcpyopt -strip-dead-prototypes -loop-vectorize -ipconstprop -loop-vectorize -lower-constant-intrinsics -prune-eh -correlated-propagation -loop-idiom -loop-fusion -coro-cleanup -lowerswitch -cross-dso-cfi -adce -strip-nondebug -speculative-execution -mergefunc -lower-widenable-condition -infer-address-spaces -alignment-from-assumptions -sccp -gvn -newgvn -strip-debug-declare -loop-sink -strip -div-rem-pairs -guard-widening -strip-debug-declare -slsr -strip-dead-prototypes -strip -loop-interchange -always-inline -mergefunc -sccp -gvn -tailcallelim -consthoist -separate-const-offset-from-gep -instcombine input.bc -o output.bc +benchmark://cbench-v1/adpcm,1.005586592178771,12.421398878097534,opt -loop-interchange -mldst-motion -instcombine -speculative-execution -loop-load-elim -loop-versioning -strip-debug-declare -partially-inline-libcalls -simplifycfg -libcalls-shrinkwrap -globaldce -globalopt -barrier -prune-eh -infer-address-spaces -reassociate -loop-unroll -callsite-splitting -reg2mem -loop-load-elim -dse -called-value-propagation -loop-versioning-licm -infer-address-spaces -mergefunc -loop-interchange -nary-reassociate -die -loop-data-prefetch -coro-early -loop-vectorize -constprop -newgvn -scalarizer -mergefunc -loop-guard-widening -globalsplit -loop-unswitch -correlated-propagation -partially-inline-libcalls -early-cse-memssa -strip-nondebug -sancov -loop-versioning -speculative-execution -newgvn -alignment-from-assumptions -mergereturn -licm -coro-split -mergeicmps -newgvn -lower-widenable-condition -strip-nondebug -redundant-dbg-inst-elim -globaldce -tailcallelim -jump-threading -coro-elide -instnamer -redundant-dbg-inst-elim -break-crit-edges -add-discriminators -mergefunc -argpromotion -add-discriminators -newgvn -tailcallelim -ipconstprop -lowerinvoke -attributor -insert-gcov-profiling -load-store-vectorizer -loop-versioning -indvars -lower-expect -simplifycfg -instsimplify -constmerge -loop-distribute -loop-load-elim -sink -cross-dso-cfi -cross-dso-cfi -loop-simplify -attributor -loop-reduce -loop-idiom -argpromotion -pgo-memop-opt -loop-load-elim -partial-inliner -mem2reg -instcombine -coro-early -mem2reg -gvn-hoist -sink -div-rem-pairs -tailcallelim -sroa -reassociate -callsite-splitting -aggressive-instcombine -aggressive-instcombine -loop-reroll -memcpyopt -ee-instrument -div-rem-pairs -break-crit-edges -globaldce -tailcallelim -early-cse-memssa -die -loop-reroll -functionattrs -strip -loop-distribute -load-store-vectorizer -div-rem-pairs -infer-address-spaces -slp-vectorizer -canonicalize-aliases -coro-cleanup -load-store-vectorizer -strip-debug-declare -cross-dso-cfi -loop-simplifycfg -gvn-hoist -sroa -simplifycfg -loop-versioning-licm -loop-vectorize -nary-reassociate -forceattrs -lower-matrix-intrinsics -barrier -partially-inline-libcalls -flattencfg -aggressive-instcombine -flattencfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/adpcm,1.005586592178771,12.565289497375488,opt -coro-cleanup -loop-versioning-licm -libcalls-shrinkwrap -loop-versioning-licm -redundant-dbg-inst-elim -lower-guard-intrinsic -loop-simplifycfg -slp-vectorizer -functionattrs -lower-widenable-condition -nary-reassociate -loop-idiom -adce -loop-instsimplify -lowerinvoke -constprop -cross-dso-cfi -globaldce -argpromotion -loop-unroll-and-jam -strip-nondebug -irce -strip -dse -load-store-vectorizer -loop-fusion -pgo-memop-opt -canonicalize-aliases -memcpyopt -load-store-vectorizer -slp-vectorizer -canonicalize-aliases -elim-avail-extern -separate-const-offset-from-gep -reassociate -alignment-from-assumptions -flattencfg -lcssa -globalopt -post-inline-ee-instrument -bdce -coro-split -sink -rpo-functionattrs -loop-reroll -reg2mem -consthoist -lower-matrix-intrinsics -strip-debug-declare -simplifycfg -alignment-from-assumptions -separate-const-offset-from-gep -always-inline -loop-distribute -loop-predication -loop-simplifycfg -deadargelim -lowerinvoke -loop-data-prefetch -loop-load-elim -libcalls-shrinkwrap -lcssa -loop-load-elim -float2int -scalarizer -scalarizer -nary-reassociate -lower-matrix-intrinsics -mergereturn -lower-expect -name-anon-globals -lowerswitch -ipconstprop -mergefunc -loop-reroll -coro-cleanup -guard-widening -loop-simplify -alignment-from-assumptions -div-rem-pairs -barrier -partial-inliner -loop-fusion -gvn-hoist -licm -strip-debug-declare -sink -aggressive-instcombine -loop-deletion -slsr -ee-instrument -lower-constant-intrinsics -mergereturn -insert-gcov-profiling -bdce -memcpyopt -simplifycfg -loop-versioning -globalopt -elim-avail-extern -loop-unswitch -prune-eh -ipconstprop -irce -inject-tli-mappings -lowerinvoke -rewrite-statepoints-for-gc -dse -forceattrs -sink -loop-fusion -alignment-from-assumptions -loop-unroll-and-jam -libcalls-shrinkwrap -scalarizer -instcombine -post-inline-ee-instrument -lower-guard-intrinsic -redundant-dbg-inst-elim -gvn -strip-debug-declare -cross-dso-cfi -instcombine -called-value-propagation -newgvn -lowerswitch -functionattrs -early-cse-memssa -inject-tli-mappings -mergeicmps -indvars -sancov -infer-address-spaces -die -loop-versioning-licm -div-rem-pairs -loop-vectorize -early-cse-memssa -ee-instrument -gvn-hoist -ipconstprop -alignment-from-assumptions -instcombine -constmerge -alignment-from-assumptions -gvn-hoist -dse -functionattrs -reg2mem -strip-debug-declare -lowerswitch -irce -memcpyopt -aggressive-instcombine -early-cse-memssa -globalopt -strip -loop-simplifycfg -loop-deletion -rewrite-statepoints-for-gc -partial-inliner -cross-dso-cfi -newgvn -sccp -post-inline-ee-instrument -correlated-propagation -adce -alignment-from-assumptions -deadargelim -loop-instsimplify -coro-split -attributor -strip-nondebug -ipsccp -break-crit-edges -insert-gcov-profiling -ipconstprop -sroa -elim-avail-extern -bdce -partial-inliner -loop-simplifycfg -jump-threading -inject-tli-mappings -lowerinvoke -loop-unswitch -lower-expect -attributor -nary-reassociate -globalopt -redundant-dbg-inst-elim -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/bitcount,0.9867256637168141,12.089999437332153,opt -canonicalize-aliases -globaldce -newgvn -callsite-splitting -sancov -globalsplit -sroa -scalarizer -inject-tli-mappings -die -mergeicmps -coro-split -loop-deletion -jump-threading -strip -coro-cleanup -infer-address-spaces -flattencfg -inferattrs -loop-idiom -lower-matrix-intrinsics -alignment-from-assumptions -indvars -mergereturn -globalopt -lowerswitch -lowerinvoke -sccp -inferattrs -jump-threading -mem2reg -strip-debug-declare -hotcoldsplit -simplifycfg -loop-predication -coro-cleanup -jump-threading -partially-inline-libcalls -mergeicmps -strip-dead-prototypes -guard-widening -simplifycfg -loop-unroll -memcpyopt -memcpyopt -instcombine -sccp -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/bitcount,0.991150442477876,12.189716339111328,opt -barrier -reassociate -sancov -partial-inliner -adce -globalsplit -gvn -cross-dso-cfi -inject-tli-mappings -nary-reassociate -coro-elide -loop-vectorize -loop-data-prefetch -mldst-motion -inferattrs -mergeicmps -add-discriminators -loop-fusion -mergefunc -ipsccp -loop-reduce -licm -coro-cleanup -strip-nondebug -loop-reroll -newgvn -deadargelim -coro-elide -barrier -load-store-vectorizer -gvn -lower-guard-intrinsic -always-inline -loop-reduce -always-inline -mergeicmps -lower-guard-intrinsic -die -alignment-from-assumptions -mergereturn -constprop -loop-idiom -correlated-propagation -ipconstprop -globaldce -scalarizer -gvn -partial-inliner -loop-fusion -coro-cleanup -functionattrs -partially-inline-libcalls -infer-address-spaces -mldst-motion -loop-unswitch -strip-nondebug -deadargelim -libcalls-shrinkwrap -inferattrs -rpo-functionattrs -loop-predication -loop-data-prefetch -post-inline-ee-instrument -loop-unswitch -newgvn -callsite-splitting -loop-deletion -ipsccp -inferattrs -early-cse-memssa -loop-unswitch -instnamer -lower-matrix-intrinsics -instsimplify -elim-avail-extern -loop-simplifycfg -ipsccp -attributor -simplifycfg -licm -float2int -instnamer -div-rem-pairs -loop-sink -reassociate -loop-unroll -ee-instrument -sroa -called-value-propagation -newgvn -mergefunc -bdce -loop-guard-widening -pgo-memop-opt -rpo-functionattrs -die -consthoist -loop-distribute -loop-load-elim -div-rem-pairs -nary-reassociate -nary-reassociate -rewrite-statepoints-for-gc -barrier -speculative-execution -instsimplify -sink -lower-widenable-condition -prune-eh -coro-elide -jump-threading -attributor -constprop -float2int -coro-elide -reassociate -loop-distribute -globalsplit -load-store-vectorizer -rpo-functionattrs -licm -strip-dead-prototypes -separate-const-offset-from-gep -rewrite-statepoints-for-gc -dse -constprop -licm -strip -loop-predication -inject-tli-mappings -aggressive-instcombine -constmerge -loop-versioning -licm -simple-loop-unswitch -elim-avail-extern -constmerge -loop-load-elim -dce -rpo-functionattrs -sancov -strip-nondebug -float2int -indvars -irce -strip -loop-reroll -gvn-hoist -infer-address-spaces -pgo-memop-opt -scalarizer -prune-eh -bdce -loop-instsimplify -rpo-functionattrs -ee-instrument -loop-idiom -redundant-dbg-inst-elim -scalarizer -aggressive-instcombine -partially-inline-libcalls -post-inline-ee-instrument -loop-unroll-and-jam -consthoist -scalarizer -indvars -lower-guard-intrinsic -lower-matrix-intrinsics -flattencfg -newgvn -globalopt -instnamer -irce -slsr -callsite-splitting -loop-distribute -ee-instrument -lowerswitch -rewrite-statepoints-for-gc -dce -flattencfg -canonicalize-aliases -load-store-vectorizer -insert-gcov-profiling -name-anon-globals -ipconstprop -loop-deletion -bdce -strip -instcombine -lowerswitch -pgo-memop-opt -loop-guard-widening -functionattrs -name-anon-globals -loop-unroll -instcombine -float2int -slsr -irce -loop-fusion -adce -loop-instsimplify -lowerinvoke -loop-reduce -loop-instsimplify -post-inline-ee-instrument -instnamer -prune-eh -loop-simplify -consthoist -canonicalize-aliases -guard-widening -lowerswitch -partially-inline-libcalls -elim-avail-extern -coro-cleanup -mergeicmps -loop-unswitch -mem2reg -licm -inferattrs -name-anon-globals -infer-address-spaces -loop-simplify -loop-instsimplify -elim-avail-extern -gvn-hoist -jump-threading -loop-reduce -functionattrs -globalsplit -add-discriminators -loop-unroll -loop-predication -slsr -loop-unswitch -instsimplify -newgvn -adce -constprop -callsite-splitting -deadargelim -constmerge -adce -flattencfg -dce -jump-threading -lower-widenable-condition -lowerswitch -licm -loop-data-prefetch -lower-constant-intrinsics -loop-vectorize -loop-reduce -strip -memcpyopt -loweratomic -constprop -ipsccp -div-rem-pairs -aggressive-instcombine -strip -correlated-propagation -loop-load-elim -ipsccp -deadargelim -strip -load-store-vectorizer -loop-distribute -deadargelim -lcssa -loop-reduce -strip-debug-declare -called-value-propagation -canonicalize-aliases -dse -scalarizer -loop-instsimplify -loop-vectorize -jump-threading -mergereturn -flattencfg -loop-simplifycfg -inject-tli-mappings -constprop -scalarizer -simple-loop-unswitch -sccp -insert-gcov-profiling -separate-const-offset-from-gep -mergeicmps -loop-guard-widening -loop-unroll -loop-deletion -loop-guard-widening -constmerge -bdce -libcalls-shrinkwrap -loop-distribute -simple-loop-unswitch -mergefunc -newgvn -loop-versioning-licm -always-inline -lowerswitch -loop-distribute -elim-avail-extern -newgvn -gvn-hoist -cross-dso-cfi -rpo-functionattrs -libcalls-shrinkwrap -dce -called-value-propagation -adce -mldst-motion -sroa -coro-cleanup -rewrite-statepoints-for-gc -insert-gcov-profiling -ee-instrument -simple-loop-unswitch -attributor -forceattrs -float2int -inject-tli-mappings -loop-data-prefetch -slsr -strip-nondebug -prune-eh -attributor -mergereturn -gvn -slsr -canonicalize-aliases -post-inline-ee-instrument -always-inline -bdce -licm -speculative-execution -tailcallelim -lower-matrix-intrinsics -coro-cleanup -loop-unroll -ipconstprop -inline -separate-const-offset-from-gep -loop-instsimplify -scalarizer -consthoist -nary-reassociate -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/bitcount,0.9933628318584071,15.541126012802124,opt -hotcoldsplit -globaldce -adce -loop-predication -ee-instrument -adce -always-inline -div-rem-pairs -loop-reduce -mergefunc -constprop -rewrite-statepoints-for-gc -gvn-hoist -sroa -nary-reassociate -coro-early -lower-guard-intrinsic -elim-avail-extern -sink -strip-dead-prototypes -loop-idiom -guard-widening -lowerswitch -mergefunc -inject-tli-mappings -redundant-dbg-inst-elim -gvn-hoist -separate-const-offset-from-gep -loop-load-elim -nary-reassociate -coro-cleanup -nary-reassociate -strip-nondebug -mldst-motion -globalopt -name-anon-globals -jump-threading -div-rem-pairs -lower-guard-intrinsic -lower-guard-intrinsic -guard-widening -strip-debug-declare -barrier -loop-reroll -reg2mem -strip -rpo-functionattrs -dce -ee-instrument -gvn-hoist -deadargelim -globalopt -loop-interchange -loop-interchange -sancov -div-rem-pairs -loop-guard-widening -loop-simplify -jump-threading -sink -loweratomic -lower-guard-intrinsic -mergeicmps -strip -lower-guard-intrinsic -inject-tli-mappings -jump-threading -loop-predication -infer-address-spaces -indvars -loop-simplifycfg -loop-vectorize -sink -loop-deletion -loop-vectorize -instcombine -lower-constant-intrinsics -strip -loop-versioning -gvn-hoist -partial-inliner -reassociate -inferattrs -loop-vectorize -redundant-dbg-inst-elim -lower-expect -break-crit-edges -loop-versioning-licm -forceattrs -strip-nondebug -inject-tli-mappings -reg2mem -loop-simplify -loop-predication -lower-expect -instnamer -flattencfg -instsimplify -cross-dso-cfi -barrier -loop-vectorize -tailcallelim -die -lcssa -instnamer -instsimplify -infer-address-spaces -inferattrs -argpromotion -loop-sink -flattencfg -memcpyopt -correlated-propagation -loop-fusion -insert-gcov-profiling -ipsccp -loop-simplify -redundant-dbg-inst-elim -mergeicmps -slsr -loop-data-prefetch -reg2mem -instcombine -lowerinvoke -die -gvn-hoist -globalsplit -strip-dead-prototypes -strip-nondebug -callsite-splitting -sroa -inject-tli-mappings -jump-threading -mldst-motion -loop-simplify -loop-simplify -guard-widening -loop-versioning-licm -loop-interchange -memcpyopt -cross-dso-cfi -insert-gcov-profiling -forceattrs -simplifycfg -mldst-motion -scalarizer -loop-vectorize -loweratomic -die -hotcoldsplit -consthoist -called-value-propagation -irce -constmerge -name-anon-globals -redundant-dbg-inst-elim -loop-distribute -prune-eh -loop-predication -insert-gcov-profiling -loop-simplifycfg -loweratomic -tailcallelim -instcombine -mergeicmps -div-rem-pairs -forceattrs -elim-avail-extern -constprop -lowerswitch -inline -lowerswitch -globaldce -forceattrs -rewrite-statepoints-for-gc -alignment-from-assumptions -irce -loop-fusion -indvars -loop-predication -sccp -canonicalize-aliases -prune-eh -functionattrs -nary-reassociate -loop-reduce -coro-cleanup -instcombine -lower-guard-intrinsic -irce -slsr -prune-eh -constprop -cross-dso-cfi -deadargelim -alignment-from-assumptions -name-anon-globals -prune-eh -early-cse-memssa -prune-eh -slp-vectorizer -early-cse-memssa -ee-instrument -loop-simplifycfg -libcalls-shrinkwrap -separate-const-offset-from-gep -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/bitcount,0.9955752212389379,12.356438875198364,opt -loop-predication -gvn-hoist -add-discriminators -prune-eh -loop-vectorize -globalsplit -callsite-splitting -mem2reg -loop-interchange -loop-simplify -infer-address-spaces -speculative-execution -float2int -coro-early -mergeicmps -cross-dso-cfi -loop-interchange -adce -loop-unroll-and-jam -instnamer -hotcoldsplit -coro-cleanup -lower-expect -loop-predication -infer-address-spaces -float2int -gvn -break-crit-edges -instnamer -loop-predication -called-value-propagation -argpromotion -callsite-splitting -instnamer -loop-interchange -loop-deletion -lower-guard-intrinsic -loop-predication -indvars -callsite-splitting -libcalls-shrinkwrap -elim-avail-extern -strip -pgo-memop-opt -callsite-splitting -aggressive-instcombine -sancov -loop-simplifycfg -forceattrs -sccp -lower-matrix-intrinsics -libcalls-shrinkwrap -pgo-memop-opt -gvn -slsr -redundant-dbg-inst-elim -strip-dead-prototypes -loop-distribute -coro-early -sroa -inferattrs -redundant-dbg-inst-elim -infer-address-spaces -correlated-propagation -loop-reroll -coro-split -strip-dead-prototypes -simple-loop-unswitch -pgo-memop-opt -strip -loop-distribute -instcombine -div-rem-pairs -consthoist -canonicalize-aliases -loop-sink -loop-guard-widening -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/bitcount,0.995575221238938,12.109670162200928,opt -lowerswitch -newgvn -redundant-dbg-inst-elim -loop-distribute -rewrite-statepoints-for-gc -canonicalize-aliases -globaldce -rpo-functionattrs -loop-distribute -loop-predication -coro-early -strip -irce -lowerinvoke -lowerswitch -globalopt -coro-cleanup -loop-unroll -argpromotion -loop-versioning -speculative-execution -die -add-discriminators -sancov -speculative-execution -strip-debug-declare -sancov -loop-vectorize -consthoist -gvn -globalopt -loop-interchange -flattencfg -loop-versioning -libcalls-shrinkwrap -ee-instrument -loop-fusion -loop-unroll-and-jam -infer-address-spaces -libcalls-shrinkwrap -globalopt -globaldce -dce -consthoist -loop-unroll -loop-interchange -coro-split -coro-elide -globaldce -instcombine -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0022123893805308,12.428935766220093,opt -aggressive-instcombine -strip-nondebug -loop-instsimplify -scalarizer -loop-unroll -adce -infer-address-spaces -prune-eh -deadargelim -scalarizer -lower-matrix-intrinsics -coro-elide -name-anon-globals -loop-versioning-licm -tailcallelim -loweratomic -tailcallelim -simplifycfg -loop-simplifycfg -insert-gcov-profiling -gvn-hoist -coro-split -guard-widening -slsr -loop-vectorize -scalarizer -reg2mem -functionattrs -insert-gcov-profiling -inferattrs -slp-vectorizer -early-cse-memssa -irce -memcpyopt -dce -libcalls-shrinkwrap -aggressive-instcombine -dse -ipconstprop -consthoist -loop-guard-widening -lcssa -loop-deletion -loop-sink -reg2mem -mergefunc -inject-tli-mappings -div-rem-pairs -sink -always-inline -called-value-propagation -sink -float2int -coro-elide -insert-gcov-profiling -attributor -sink -coro-split -gvn-hoist -mergereturn -argpromotion -argpromotion -lower-expect -partial-inliner -globalsplit -lower-expect -licm -loop-instsimplify -die -redundant-dbg-inst-elim -lower-constant-intrinsics -mem2reg -elim-avail-extern -inferattrs -lower-matrix-intrinsics -lower-matrix-intrinsics -guard-widening -mergereturn -loop-unroll -lower-widenable-condition -loop-predication -strip -loop-versioning-licm -partial-inliner -insert-gcov-profiling -inline -scalarizer -adce -div-rem-pairs -indvars -rewrite-statepoints-for-gc -constprop -loop-data-prefetch -memcpyopt -loop-vectorize -mldst-motion -loweratomic -adce -lower-constant-intrinsics -sroa -loop-simplifycfg -jump-threading -licm -mldst-motion -indvars -simple-loop-unswitch -rpo-functionattrs -slp-vectorizer -constmerge -consthoist -loop-idiom -loop-guard-widening -pgo-memop-opt -functionattrs -constmerge -aggressive-instcombine -ee-instrument -nary-reassociate -newgvn -gvn-hoist -loop-distribute -div-rem-pairs -pgo-memop-opt -die -redundant-dbg-inst-elim -functionattrs -cross-dso-cfi -canonicalize-aliases -constprop -elim-avail-extern -mergefunc -rewrite-statepoints-for-gc -instcombine -loop-simplify -mem2reg -loop-data-prefetch -instnamer -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0088495575221237,12.064459800720215,opt -loop-distribute -aggressive-instcombine -float2int -float2int -add-discriminators -functionattrs -float2int -libcalls-shrinkwrap -lowerswitch -consthoist -simple-loop-unswitch -slp-vectorizer -functionattrs -slsr -loop-sink -nary-reassociate -die -loop-deletion -memcpyopt -loop-deletion -break-crit-edges -lowerinvoke -inject-tli-mappings -loop-deletion -loop-fusion -barrier -memcpyopt -newgvn -loop-instsimplify -flattencfg -sink -forceattrs -irce -rewrite-statepoints-for-gc -barrier -break-crit-edges -coro-elide -lower-matrix-intrinsics -libcalls-shrinkwrap -name-anon-globals -slsr -callsite-splitting -lower-guard-intrinsic -loop-fusion -insert-gcov-profiling -partial-inliner -consthoist -prune-eh -ee-instrument -constmerge -lowerswitch -inject-tli-mappings -sroa -gvn-hoist -mergeicmps -tailcallelim -loop-guard-widening -indvars -deadargelim -tailcallelim -loop-interchange -globalsplit -lowerswitch -loop-idiom -redundant-dbg-inst-elim -coro-cleanup -sancov -loop-unroll -lower-widenable-condition -add-discriminators -barrier -scalarizer -nary-reassociate -constmerge -jump-threading -post-inline-ee-instrument -inject-tli-mappings -instcombine -coro-elide -callsite-splitting -rpo-functionattrs -jump-threading -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0088495575221237,12.131162881851196,opt -sancov -coro-split -loop-idiom -libcalls-shrinkwrap -loweratomic -lower-widenable-condition -globalopt -speculative-execution -flattencfg -strip-dead-prototypes -consthoist -newgvn -strip-nondebug -callsite-splitting -inject-tli-mappings -prune-eh -irce -loop-unswitch -loop-simplifycfg -simplifycfg -loop-fusion -rewrite-statepoints-for-gc -deadargelim -lowerswitch -nary-reassociate -globalsplit -loop-versioning-licm -die -licm -lowerinvoke -speculative-execution -loop-guard-widening -newgvn -strip-dead-prototypes -newgvn -strip-nondebug -dse -coro-early -loop-unroll-and-jam -licm -coro-split -loop-idiom -constmerge -adce -partial-inliner -float2int -speculative-execution -globalsplit -slsr -loop-unroll-and-jam -prune-eh -float2int -instcombine -loop-reduce -loop-simplify -loop-unroll -newgvn -loop-guard-widening -dse -sroa -loop-fusion -ipconstprop -scalarizer -indvars -loop-unroll-and-jam -inline -flattencfg -sink -coro-elide -speculative-execution -lower-guard-intrinsic -sancov -gvn-hoist -coro-split -loop-predication -barrier -dse -jump-threading -loop-reduce -separate-const-offset-from-gep -loop-versioning-licm -flattencfg -instsimplify -called-value-propagation -instnamer -strip-dead-prototypes -irce -canonicalize-aliases -lower-matrix-intrinsics -inject-tli-mappings -infer-address-spaces -name-anon-globals -simple-loop-unswitch -die -partial-inliner -newgvn -add-discriminators -aggressive-instcombine -sink -loop-versioning -loop-data-prefetch -coro-split -sroa -attributor -loop-simplify -loop-unroll -correlated-propagation -partially-inline-libcalls -barrier -globalsplit -called-value-propagation -inferattrs -inferattrs -argpromotion -slsr -prune-eh -guard-widening -loop-idiom -irce -tailcallelim -lower-widenable-condition -inject-tli-mappings -float2int -pgo-memop-opt -indvars -strip-nondebug -loop-interchange -flattencfg -redundant-dbg-inst-elim -elim-avail-extern -coro-early -constmerge -sroa -gvn-hoist -ipsccp -scalarizer -lcssa -constmerge -libcalls-shrinkwrap -globalsplit -loop-interchange -sroa -deadargelim -rewrite-statepoints-for-gc -loop-predication -libcalls-shrinkwrap -flattencfg -gvn-hoist -prune-eh -lower-matrix-intrinsics -inline -canonicalize-aliases -ee-instrument -loop-load-elim -attributor -globaldce -nary-reassociate -barrier -loop-simplify -newgvn -loop-instsimplify -memcpyopt -aggressive-instcombine -instcombine -functionattrs -separate-const-offset-from-gep -loop-deletion -barrier -newgvn -loop-unroll-and-jam -loop-predication -post-inline-ee-instrument -coro-split -slp-vectorizer -loop-versioning-licm -simple-loop-unswitch -rpo-functionattrs -inferattrs -div-rem-pairs -indvars -loop-versioning-licm -dse -sroa -sink -indvars -gvn-hoist -guard-widening -sink -loop-unroll-and-jam -coro-early -globalsplit -coro-cleanup -always-inline -simplifycfg -memcpyopt -newgvn input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.008849557522124,12.092485666275024,opt -loop-guard-widening -loop-sink -licm -attributor -canonicalize-aliases -rewrite-statepoints-for-gc -loop-vectorize -loweratomic -aggressive-instcombine -cross-dso-cfi -deadargelim -mergereturn -functionattrs -loop-reroll -loop-distribute -prune-eh -inferattrs -insert-gcov-profiling -loop-interchange -lower-widenable-condition -adce -instcombine -rpo-functionattrs -inline -mergeicmps -constmerge -nary-reassociate -instcombine -instnamer -loop-data-prefetch -constmerge -loop-versioning-licm -attributor -inline -newgvn -speculative-execution -strip-nondebug -early-cse-memssa -instsimplify -loop-versioning -loop-instsimplify -sroa -separate-const-offset-from-gep -functionattrs -lower-guard-intrinsic -post-inline-ee-instrument -functionattrs -instsimplify -mergeicmps -partial-inliner -constmerge -inject-tli-mappings -strip-debug-declare -barrier -forceattrs -prune-eh -loop-distribute -irce -strip-nondebug -reassociate -loweratomic -constmerge -redundant-dbg-inst-elim -elim-avail-extern -add-discriminators -bdce -ipsccp -ipsccp -break-crit-edges -lcssa -loop-simplifycfg -loop-deletion -lowerinvoke -lower-guard-intrinsic -reassociate -loop-sink -called-value-propagation -strip-debug-declare -break-crit-edges -scalarizer -flattencfg -deadargelim -div-rem-pairs -dse -instsimplify -functionattrs -instcombine -partial-inliner -name-anon-globals -libcalls-shrinkwrap -loop-deletion -rewrite-statepoints-for-gc -early-cse-memssa -tailcallelim -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0088495575221241,12.038225173950195,opt -strip -correlated-propagation -sroa -loop-versioning -mem2reg -add-discriminators -loop-predication -bdce -memcpyopt -sancov -loop-reroll -instcombine -partially-inline-libcalls -speculative-execution -loop-unroll -coro-cleanup -loop-versioning-licm -lower-widenable-condition -consthoist -simplifycfg -canonicalize-aliases -coro-early -break-crit-edges -loop-unswitch -rewrite-statepoints-for-gc -loop-unswitch -newgvn -coro-early -partial-inliner -coro-elide -bdce -instsimplify -coro-split -strip -flattencfg -inline -loop-guard-widening -ipsccp -loop-simplifycfg -globaldce -lcssa -adce -lower-expect -loop-simplifycfg -coro-cleanup -coro-split -globalsplit -mergefunc -loop-versioning-licm -libcalls-shrinkwrap -globalopt -functionattrs -licm -instcombine -sroa -infer-address-spaces -consthoist -partially-inline-libcalls -loop-data-prefetch -constmerge -strip-nondebug -globalopt -sccp -loop-unroll -ipsccp -loop-instsimplify -libcalls-shrinkwrap -speculative-execution -correlated-propagation -dce -strip-dead-prototypes -gvn -speculative-execution -inline -infer-address-spaces -constprop -float2int -functionattrs -loop-deletion -sroa -deadargelim -instsimplify -mergefunc -bdce -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0249363867684482,12.77646517753601,opt -hotcoldsplit -lowerswitch -canonicalize-aliases -mem2reg -speculative-execution -lower-expect -redundant-dbg-inst-elim -inferattrs -loop-vectorize -speculative-execution -aggressive-instcombine -loop-vectorize -loweratomic -lower-widenable-condition -guard-widening -early-cse-memssa -speculative-execution -lowerswitch -pgo-memop-opt -strip-dead-prototypes -lowerinvoke -always-inline -aggressive-instcombine -loop-sink -reg2mem -sroa -dce -coro-split -post-inline-ee-instrument -simplifycfg -redundant-dbg-inst-elim -globalopt -globaldce -loop-idiom -slp-vectorizer -globalopt -argpromotion -loop-versioning -jump-threading -argpromotion -strip-dead-prototypes -insert-gcov-profiling -lower-expect -strip-nondebug -globalsplit -loweratomic -coro-early -sancov -separate-const-offset-from-gep -loop-fusion -add-discriminators -lcssa -licm -lower-constant-intrinsics -libcalls-shrinkwrap -instcombine -argpromotion -jump-threading -hotcoldsplit -float2int -libcalls-shrinkwrap -elim-avail-extern -sroa -callsite-splitting -called-value-propagation -barrier -speculative-execution -redundant-dbg-inst-elim -slp-vectorizer -memcpyopt -lower-guard-intrinsic -argpromotion -flattencfg -always-inline -indvars -dse -loop-interchange -memcpyopt -mergereturn -lower-widenable-condition -scalarizer -ipconstprop -loop-unroll -loop-guard-widening -loop-reduce -attributor -indvars -early-cse-memssa -tailcallelim -sink -irce -slp-vectorizer -dce -prune-eh -name-anon-globals -load-store-vectorizer -slsr -sccp -coro-split -loop-rotate -strip-debug-declare -post-inline-ee-instrument -ee-instrument -memcpyopt -aggressive-instcombine -globaldce -strip-dead-prototypes -libcalls-shrinkwrap -strip-nondebug -rewrite-statepoints-for-gc -early-cse-memssa -canonicalize-aliases -callsite-splitting -die -instnamer -hotcoldsplit -lower-matrix-intrinsics -cross-dso-cfi -coro-cleanup -loop-versioning -correlated-propagation -newgvn -coro-split -ipconstprop -sancov -lowerinvoke -partial-inliner -scalarizer -loop-reroll -slsr -gvn -instcombine -loop-deletion -bdce -slsr -loop-rotate -alignment-from-assumptions -lower-matrix-intrinsics -loop-predication -loop-instsimplify -infer-address-spaces -instnamer -always-inline -lower-constant-intrinsics -loop-unroll -early-cse-memssa -adce -loop-reroll -cross-dso-cfi -forceattrs -callsite-splitting -div-rem-pairs -speculative-execution -redundant-dbg-inst-elim -loop-versioning -loop-data-prefetch -lower-expect -slsr -correlated-propagation -name-anon-globals -partial-inliner -dse -ipsccp -constmerge -pgo-memop-opt -loop-reduce -gvn-hoist -speculative-execution -lowerswitch -ee-instrument -globalsplit -guard-widening -load-store-vectorizer -loop-idiom -licm -separate-const-offset-from-gep -mergeicmps -simple-loop-unswitch -loop-predication -mldst-motion -loweratomic -bdce -early-cse-memssa -inferattrs -mergeicmps -consthoist -mergefunc -ee-instrument -sccp -break-crit-edges -lower-constant-intrinsics -mldst-motion -called-value-propagation -loweratomic -ipconstprop -sccp -deadargelim -loop-data-prefetch -loop-sink -separate-const-offset-from-gep -guard-widening -loop-fusion -gvn -slp-vectorizer -called-value-propagation -scalarizer -attributor -pgo-memop-opt -loop-reduce -instnamer -break-crit-edges -pgo-memop-opt -mldst-motion -adce -memcpyopt -partially-inline-libcalls -loop-simplifycfg -reassociate -lower-matrix-intrinsics -sccp -loop-idiom -insert-gcov-profiling -div-rem-pairs -mergeicmps -licm -add-discriminators -licm -strip-nondebug -flattencfg -loop-vectorize -aggressive-instcombine -loop-versioning -partially-inline-libcalls -loop-versioning -flattencfg -simplifycfg -infer-address-spaces -break-crit-edges -ipconstprop -coro-cleanup -early-cse-memssa -loop-versioning -aggressive-instcombine -loop-vectorize -mergereturn -speculative-execution -slp-vectorizer -indvars -loop-reroll -infer-address-spaces -sancov -loop-load-elim -instcombine -inline -inline -float2int -loop-vectorize -aggressive-instcombine -speculative-execution -mergereturn -indvars -loop-simplify -strip-debug-declare -sccp -consthoist -loop-unroll -jump-threading -alignment-from-assumptions -loop-versioning-licm -pgo-memop-opt -loop-unswitch -loop-deletion -reassociate -loop-versioning -ee-instrument -functionattrs -mldst-motion -lower-widenable-condition -flattencfg -coro-cleanup -strip-nondebug -ipsccp -inject-tli-mappings -loop-fusion -name-anon-globals -barrier -scalarizer -slp-vectorizer -strip-nondebug -sink -loop-unswitch -forceattrs -coro-cleanup -aggressive-instcombine -sink -deadargelim -infer-address-spaces -loop-versioning -loop-deletion -called-value-propagation -lower-constant-intrinsics -constmerge -slp-vectorizer -coro-elide -strip-dead-prototypes -partial-inliner -redundant-dbg-inst-elim -ipconstprop -loop-instsimplify -simplifycfg -loop-predication -instcombine input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0300254452926212,13.093162536621094,opt -ipsccp -scalarizer -mem2reg -break-crit-edges -loop-guard-widening -separate-const-offset-from-gep -inject-tli-mappings -lowerinvoke -rewrite-statepoints-for-gc -separate-const-offset-from-gep -inline -attributor -ee-instrument -loop-interchange -loop-distribute -loop-unroll -correlated-propagation -sccp -coro-early -loop-predication -loop-deletion -dce -loop-instsimplify -loop-unroll-and-jam -mergefunc -coro-cleanup -lower-matrix-intrinsics -lowerinvoke -ipconstprop -gvn-hoist -lower-widenable-condition -loop-rotate -gvn-hoist -separate-const-offset-from-gep -sroa -lower-constant-intrinsics -strip-debug-declare -loop-sink -adce -loop-interchange -coro-cleanup -loop-unroll-and-jam -loop-guard-widening -loop-fusion -coro-elide -post-inline-ee-instrument -irce -mergereturn -instcombine -load-store-vectorizer -lowerswitch -correlated-propagation -memcpyopt -strip-nondebug -cross-dso-cfi -loop-fusion -argpromotion -irce -lowerinvoke -slsr -elim-avail-extern -speculative-execution -loop-fusion -separate-const-offset-from-gep -loop-versioning -inline -loop-fusion -coro-split -loop-instsimplify -loweratomic -licm -lower-widenable-condition -loop-rotate -elim-avail-extern -globalsplit -loop-vectorize -loop-deletion -lower-widenable-condition -newgvn -loop-reroll -loop-versioning -libcalls-shrinkwrap -loop-predication -reg2mem -loop-rotate -strip-debug-declare -insert-gcov-profiling -strip-debug-declare -div-rem-pairs -globaldce -loop-versioning-licm -reg2mem -strip -separate-const-offset-from-gep -loop-unswitch -nary-reassociate -irce -mldst-motion -rpo-functionattrs -constmerge -mergefunc -bdce -consthoist -strip-debug-declare -simplifycfg -mem2reg -alignment-from-assumptions -loop-instsimplify -jump-threading -correlated-propagation -strip-debug-declare -break-crit-edges -constmerge -lower-constant-intrinsics -prune-eh -indvars -loweratomic -separate-const-offset-from-gep -prune-eh -name-anon-globals -early-cse-memssa -indvars -forceattrs -loop-rotate -load-store-vectorizer -globaldce -sancov -partial-inliner -instcombine -elim-avail-extern -bdce -irce -lcssa -mldst-motion -instsimplify -loop-guard-widening -loop-rotate -jump-threading -break-crit-edges -always-inline -post-inline-ee-instrument -partially-inline-libcalls -barrier -insert-gcov-profiling -simple-loop-unswitch -deadargelim -strip -strip -gvn -ipsccp -lowerinvoke -partial-inliner -lower-constant-intrinsics -called-value-propagation -loop-idiom -coro-cleanup -slp-vectorizer -instcombine -prune-eh -dce -elim-avail-extern -constprop -loop-fusion -deadargelim -loop-instsimplify -instcombine -lower-guard-intrinsic -break-crit-edges -loweratomic -cross-dso-cfi -partial-inliner -loop-interchange -loop-guard-widening -indvars -irce -lower-matrix-intrinsics -gvn -loop-unroll-and-jam -load-store-vectorizer -mem2reg -globaldce -loop-versioning -strip-dead-prototypes -loop-sink -strip-dead-prototypes -reassociate -indvars -lower-guard-intrinsic -loop-interchange -gvn -callsite-splitting -loop-interchange -sccp -attributor -loop-predication -constprop -speculative-execution -loop-idiom -name-anon-globals -coro-elide -elim-avail-extern -pgo-memop-opt -simplifycfg -sink -globalopt -mem2reg -reg2mem -constprop -name-anon-globals -argpromotion -coro-cleanup -jump-threading -called-value-propagation -reg2mem -rewrite-statepoints-for-gc -loop-sink -globalsplit -mldst-motion -lower-constant-intrinsics -callsite-splitting -barrier -infer-address-spaces -lowerswitch -consthoist -ee-instrument -add-discriminators -forceattrs -hotcoldsplit -loop-unroll -mergefunc -attributor -lowerswitch -coro-early -reassociate -lower-widenable-condition -prune-eh -loop-predication -ee-instrument -deadargelim -loop-distribute -newgvn -name-anon-globals -canonicalize-aliases -memcpyopt -dse -sancov -flattencfg -loweratomic -coro-cleanup -strip-nondebug -inject-tli-mappings -prune-eh -gvn -speculative-execution -correlated-propagation -loop-unswitch -strip -sroa -lowerinvoke -redundant-dbg-inst-elim -mem2reg -mergereturn -barrier -tailcallelim -loop-sink -pgo-memop-opt -lcssa -instsimplify -functionattrs -licm -strip -strip-dead-prototypes -lower-matrix-intrinsics -loop-sink -guard-widening -loop-versioning-licm -lower-constant-intrinsics -functionattrs -indvars -loop-unroll-and-jam -elim-avail-extern -loop-sink -globaldce -licm -pgo-memop-opt -instcombine -lower-guard-intrinsic -mldst-motion -jump-threading -callsite-splitting -coro-split -mergeicmps -insert-gcov-profiling -coro-cleanup -sccp -add-discriminators -early-cse-memssa -licm -div-rem-pairs -globaldce -functionattrs -loop-vectorize -div-rem-pairs -loop-predication -inferattrs -alignment-from-assumptions -dce -inject-tli-mappings -memcpyopt -lower-matrix-intrinsics -loop-predication -licm -newgvn -tailcallelim -adce -memcpyopt -early-cse-memssa -coro-elide -dce -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.033587786259542,12.856059074401855,opt -lower-matrix-intrinsics -lower-matrix-intrinsics -sink -dse -loop-interchange -scalarizer -cross-dso-cfi -instnamer -loop-fusion -lower-expect -break-crit-edges -infer-address-spaces -post-inline-ee-instrument -sancov -barrier -coro-split -ipsccp -loop-load-elim -lower-widenable-condition -strip-debug-declare -forceattrs -add-discriminators -loop-fusion -strip-debug-declare -lower-constant-intrinsics -load-store-vectorizer -deadargelim -loop-unroll-and-jam -loop-data-prefetch -gvn-hoist -deadargelim -sink -loop-load-elim -lower-widenable-condition -adce -slp-vectorizer -callsite-splitting -lower-expect -reassociate -instnamer -elim-avail-extern -strip-nondebug -lower-constant-intrinsics -lowerswitch -strip-debug-declare -irce -gvn-hoist -loop-simplify -loop-interchange -separate-const-offset-from-gep -loop-simplify -break-crit-edges -loop-data-prefetch -dce -mergefunc -redundant-dbg-inst-elim -instsimplify -deadargelim -mldst-motion -loop-guard-widening -loop-unroll -correlated-propagation -hotcoldsplit -gvn-hoist -mergefunc -loop-interchange -ee-instrument -correlated-propagation -alignment-from-assumptions -coro-early -loop-simplify -mldst-motion -loop-distribute -guard-widening -post-inline-ee-instrument -loop-reroll -dce -sroa -globalsplit -canonicalize-aliases -lower-widenable-condition -loop-load-elim -add-discriminators -coro-early -loop-vectorize -mergefunc -simple-loop-unswitch -alignment-from-assumptions -strip -constprop -div-rem-pairs -libcalls-shrinkwrap -simple-loop-unswitch -loop-idiom -gvn-hoist -newgvn -post-inline-ee-instrument -strip-dead-prototypes -instcombine -dse -partial-inliner -lower-widenable-condition -sccp -adce -speculative-execution -simplifycfg -slp-vectorizer -newgvn -mldst-motion -memcpyopt -slsr -load-store-vectorizer -mergeicmps -argpromotion -rpo-functionattrs -correlated-propagation -strip-dead-prototypes -memcpyopt -loop-predication -alignment-from-assumptions -adce -deadargelim -partially-inline-libcalls -tailcallelim -elim-avail-extern -lower-expect -globaldce -nary-reassociate -irce -loop-reroll -loop-distribute -loop-instsimplify -loop-reroll -lower-matrix-intrinsics -loop-data-prefetch -tailcallelim -loop-reduce -name-anon-globals -canonicalize-aliases -instnamer -memcpyopt -lower-guard-intrinsic -cross-dso-cfi -simple-loop-unswitch -memcpyopt -pgo-memop-opt -break-crit-edges -strip-debug-declare -lower-constant-intrinsics -flattencfg -loop-simplifycfg -globaldce -sink -loop-vectorize -reassociate -loop-instsimplify -callsite-splitting -globalsplit -lowerswitch -insert-gcov-profiling -slp-vectorizer -flattencfg -partial-inliner -ipsccp -elim-avail-extern -mergereturn -rewrite-statepoints-for-gc -loop-unroll-and-jam -loop-unswitch -strip-debug-declare -mergefunc -constmerge -redundant-dbg-inst-elim -barrier -alignment-from-assumptions -flattencfg -ee-instrument -nary-reassociate -loop-predication -bdce -slsr -elim-avail-extern -inject-tli-mappings -coro-elide -licm -infer-address-spaces -die -sccp -partially-inline-libcalls -loop-distribute -callsite-splitting -float2int -lower-widenable-condition -instsimplify -instcombine -ipconstprop -constprop -prune-eh -loop-guard-widening -ipconstprop -correlated-propagation -mergeicmps -loop-unswitch -ipconstprop -separate-const-offset-from-gep -separate-const-offset-from-gep -instnamer -die -inline -sancov -loop-interchange -canonicalize-aliases -sroa -loop-fusion -lowerinvoke -strip-dead-prototypes -loop-instsimplify -instnamer -lower-constant-intrinsics -gvn input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.033587786259542,13.356575012207031,opt -globaldce -infer-address-spaces -always-inline -loop-fusion -constprop -bdce -globaldce -sink -loweratomic -memcpyopt -loop-sink -lower-expect -newgvn -pgo-memop-opt -callsite-splitting -strip-debug-declare -jump-threading -loop-unswitch -loop-simplify -loop-simplify -inferattrs -loop-unswitch -separate-const-offset-from-gep -loop-predication -instnamer -alignment-from-assumptions -load-store-vectorizer -loop-data-prefetch -simple-loop-unswitch -elim-avail-extern -loop-unswitch -globalsplit -mem2reg -globalopt -reassociate -consthoist -gvn -sink -post-inline-ee-instrument -instcombine -dse -simplifycfg -flattencfg -load-store-vectorizer -load-store-vectorizer -float2int -loop-load-elim -tailcallelim -elim-avail-extern -coro-split -globaldce -licm -coro-split -strip-debug-declare -ee-instrument -prune-eh -loop-reroll -pgo-memop-opt -lowerinvoke -adce -loop-vectorize -scalarizer -sccp -loop-versioning-licm -always-inline -guard-widening -dse -deadargelim -libcalls-shrinkwrap -called-value-propagation -coro-elide -dce -lower-widenable-condition -loop-vectorize -correlated-propagation -loop-unroll -coro-elide -loop-instsimplify -coro-split -simple-loop-unswitch -loop-unroll -loop-simplifycfg -loop-deletion -lower-guard-intrinsic -globalopt -argpromotion -loop-simplifycfg -simplifycfg -argpromotion -mem2reg -gvn-hoist -lower-guard-intrinsic -guard-widening -separate-const-offset-from-gep -simple-loop-unswitch -hotcoldsplit -sink -newgvn -globalsplit -loop-guard-widening -correlated-propagation -slsr -prune-eh -inject-tli-mappings -break-crit-edges -coro-cleanup -licm -strip-dead-prototypes -loop-deletion -rpo-functionattrs -rpo-functionattrs -loop-interchange -licm -gvn -slsr -instnamer -instcombine -attributor -constprop -memcpyopt -coro-cleanup -cross-dso-cfi -mergeicmps -instnamer -always-inline -lcssa -separate-const-offset-from-gep -loop-simplify -argpromotion -licm -simple-loop-unswitch -argpromotion -loop-versioning -loop-distribute -globalsplit -sccp -lcssa -partial-inliner -redundant-dbg-inst-elim -loop-simplify -strip-dead-prototypes -memcpyopt -strip-dead-prototypes -slp-vectorizer -adce -loop-unroll-and-jam -instsimplify -mergereturn -loop-reroll -instcombine -coro-early -loop-reroll -memcpyopt -correlated-propagation -inline -slp-vectorizer -simple-loop-unswitch -coro-cleanup -strip-nondebug -slsr -nary-reassociate -loop-versioning -lower-widenable-condition -float2int -loop-predication -loop-versioning -strip -loweratomic -consthoist -separate-const-offset-from-gep -mergefunc -loop-versioning-licm -instsimplify -loop-unroll-and-jam -cross-dso-cfi -prune-eh -simple-loop-unswitch -loop-data-prefetch -elim-avail-extern -indvars -pgo-memop-opt -forceattrs -mem2reg -constmerge -dce -bdce -loop-distribute -loop-idiom -post-inline-ee-instrument -argpromotion -loop-vectorize -indvars -globaldce -instcombine input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0346055979643767,12.67380666732788,opt -constmerge -partially-inline-libcalls -correlated-propagation -coro-elide -lowerswitch -coro-split -functionattrs -add-discriminators -sroa -instcombine -slp-vectorizer -loop-versioning-licm -loop-distribute -name-anon-globals -loop-predication -cross-dso-cfi -lower-expect -float2int -lcssa -lowerswitch -forceattrs -reg2mem -hotcoldsplit -correlated-propagation -strip-dead-prototypes -globalsplit -coro-split -loop-reroll -alignment-from-assumptions -loop-sink -reg2mem -early-cse-memssa -lower-expect -loop-versioning -gvn-hoist -newgvn -loweratomic -alignment-from-assumptions -loop-vectorize -coro-split -loop-sink -instnamer -loop-unroll -tailcallelim -pgo-memop-opt -functionattrs -ipconstprop -sink -pgo-memop-opt -dce -hotcoldsplit -globalopt -attributor -strip -loop-reroll -cross-dso-cfi -aggressive-instcombine -strip-dead-prototypes -rpo-functionattrs -loop-sink -break-crit-edges -canonicalize-aliases -loop-unroll-and-jam -globaldce -hotcoldsplit -bdce -aggressive-instcombine -mergefunc -consthoist -always-inline -insert-gcov-profiling -correlated-propagation -div-rem-pairs -strip -prune-eh -mergeicmps -loop-interchange -globaldce -prune-eh -loop-vectorize -jump-threading -instnamer -insert-gcov-profiling -reg2mem -simple-loop-unswitch -nary-reassociate -forceattrs -loop-unroll-and-jam -globalopt -globalsplit -lowerinvoke -loop-load-elim -lower-widenable-condition -loop-guard-widening -simplifycfg -coro-elide -deadargelim -jump-threading -libcalls-shrinkwrap -loop-predication -loop-load-elim -attributor -called-value-propagation -instcombine -scalarizer -newgvn -globalsplit -insert-gcov-profiling -strip-nondebug -loop-interchange -pgo-memop-opt -libcalls-shrinkwrap -loop-guard-widening -break-crit-edges -loweratomic -newgvn -loop-instsimplify -loop-unswitch -sccp -always-inline -elim-avail-extern -lower-guard-intrinsic -rewrite-statepoints-for-gc -slp-vectorizer -mem2reg -forceattrs -sroa -functionattrs -loop-simplifycfg -coro-elide -globalsplit -elim-avail-extern -guard-widening -loop-idiom -irce -add-discriminators -separate-const-offset-from-gep -libcalls-shrinkwrap -mem2reg -add-discriminators -callsite-splitting -name-anon-globals -called-value-propagation -infer-address-spaces -loop-unroll -dce -mergefunc -flattencfg -deadargelim -sroa -lower-constant-intrinsics -loop-predication -rpo-functionattrs -tailcallelim -loop-data-prefetch -elim-avail-extern -load-store-vectorizer -mergeicmps -prune-eh -bdce -dce -globalopt -strip-debug-declare -strip-nondebug -slsr -loop-interchange -loop-reduce -lowerswitch -elim-avail-extern -globalopt -callsite-splitting -newgvn -lower-expect -ee-instrument -sancov -lowerswitch -licm -add-discriminators -gvn -early-cse-memssa -correlated-propagation -add-discriminators -memcpyopt -adce -mergereturn -strip-nondebug -callsite-splitting -break-crit-edges -loop-distribute -loop-simplifycfg -strip-nondebug -lcssa -mem2reg -attributor -dse -strip-debug-declare -strip -dce -loop-reduce -post-inline-ee-instrument -loop-distribute -loop-idiom -loop-unroll-and-jam -canonicalize-aliases -licm -deadargelim -loop-load-elim -speculative-execution -loop-unswitch -redundant-dbg-inst-elim -rpo-functionattrs -separate-const-offset-from-gep -flattencfg -die -lower-guard-intrinsic -loop-unroll-and-jam -lowerswitch -globalopt -coro-split -loop-reduce -loop-deletion -coro-split -mem2reg -adce -nary-reassociate -early-cse-memssa -float2int -newgvn -functionattrs -indvars -forceattrs -canonicalize-aliases -early-cse-memssa -slp-vectorizer -irce -loop-unroll -sccp -sink -globalsplit -strip-debug-declare -lower-expect -sancov -sancov -gvn-hoist -loop-reduce -barrier -newgvn -lowerswitch -ee-instrument -lower-constant-intrinsics -early-cse-memssa -loop-fusion -coro-elide -licm -callsite-splitting -dse -instnamer -aggressive-instcombine -newgvn -flattencfg -loop-deletion -strip-nondebug -load-store-vectorizer -speculative-execution -lower-constant-intrinsics -coro-elide -loop-simplifycfg -indvars -early-cse-memssa -strip-nondebug -loop-idiom -dce -hotcoldsplit -lower-guard-intrinsic -partially-inline-libcalls -alignment-from-assumptions -tailcallelim -hotcoldsplit -loop-simplifycfg -globalopt -constprop -ee-instrument -lcssa -functionattrs -loop-sink -loop-reduce -loop-vectorize -argpromotion -flattencfg -sroa -deadargelim -mem2reg -sccp -always-inline -lower-expect -ipconstprop -reassociate -slp-vectorizer -lowerinvoke -loop-vectorize -inject-tli-mappings -insert-gcov-profiling -correlated-propagation -loop-vectorize -ipconstprop -name-anon-globals -instcombine -loop-versioning-licm -rewrite-statepoints-for-gc -bdce -name-anon-globals -consthoist -float2int -infer-address-spaces -prune-eh -div-rem-pairs -simple-loop-unswitch -consthoist -lower-expect -mldst-motion -loop-simplifycfg -ee-instrument -loop-interchange -constmerge -consthoist -loop-unroll-and-jam -loop-distribute -jump-threading -loop-data-prefetch -mem2reg -instnamer -constprop -sink -loop-distribute -slsr -post-inline-ee-instrument -loop-vectorize -gvn-hoist -mldst-motion -constmerge -loop-reroll -indvars -forceattrs -die -insert-gcov-profiling -argpromotion -correlated-propagation -pgo-memop-opt -instcombine -licm -reassociate -coro-early -name-anon-globals -lower-widenable-condition -dce -loop-instsimplify -lower-constant-intrinsics -elim-avail-extern -loop-guard-widening -loop-simplifycfg -partial-inliner -gvn -irce -post-inline-ee-instrument -adce -constprop -callsite-splitting -loop-fusion -attributor -inferattrs -strip-dead-prototypes -inline -aggressive-instcombine -gvn-hoist -mergefunc -speculative-execution -die -forceattrs -insert-gcov-profiling -callsite-splitting -slsr -loop-simplify -loop-versioning-licm -add-discriminators -rpo-functionattrs -sccp -die -loop-interchange -strip -globaldce -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0417302798982189,12.396470785140991,opt -prune-eh -loop-idiom -nary-reassociate -post-inline-ee-instrument -loop-unswitch -slsr -reassociate -separate-const-offset-from-gep -loop-fusion -loop-deletion -coro-elide -slsr -forceattrs -mergeicmps -globaldce -elim-avail-extern -pgo-memop-opt -loop-predication -canonicalize-aliases -instsimplify -loop-fusion -simplifycfg -simple-loop-unswitch -attributor -canonicalize-aliases -loop-predication -licm -hotcoldsplit -ipsccp -indvars -partial-inliner -tailcallelim -coro-cleanup -lcssa -strip-dead-prototypes -sancov -scalarizer -float2int -loop-unswitch -strip-dead-prototypes -loop-versioning -strip-dead-prototypes -globaldce -callsite-splitting -gvn -mem2reg -instcombine -memcpyopt -functionattrs -add-discriminators -slsr -deadargelim -mergereturn -lcssa -loop-distribute -guard-widening -lower-expect -loop-idiom -licm -coro-split -strip-nondebug -rpo-functionattrs -loop-predication -hotcoldsplit -reassociate -lower-matrix-intrinsics -coro-cleanup -rewrite-statepoints-for-gc -lcssa -lowerswitch -lcssa -mem2reg -loop-simplify -strip-dead-prototypes -loop-vectorize -coro-early -loop-predication -attributor -reassociate -forceattrs -sccp -newgvn -add-discriminators -mldst-motion -loop-deletion -sink -loop-predication -newgvn -loop-data-prefetch -mergeicmps -loop-unroll -globalsplit -adce -argpromotion -rewrite-statepoints-for-gc -loop-simplifycfg -partial-inliner -loop-guard-widening -loop-load-elim -sroa -simplifycfg -consthoist -separate-const-offset-from-gep -globaldce -bdce -loop-instsimplify -canonicalize-aliases -barrier -ipconstprop -rpo-functionattrs -rpo-functionattrs -deadargelim -bdce -loweratomic -ipsccp -coro-early -loop-simplifycfg -load-store-vectorizer -argpromotion -gvn-hoist -indvars -globalsplit -gvn -coro-split -lowerinvoke -reassociate -rewrite-statepoints-for-gc -sccp -coro-early -bdce -strip-nondebug -infer-address-spaces -dse -simple-loop-unswitch -callsite-splitting -irce -mergefunc -sccp -infer-address-spaces -slp-vectorizer -argpromotion -called-value-propagation -deadargelim -flattencfg -hotcoldsplit -loop-distribute -partial-inliner -strip -instcombine input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.043765903307888,12.748835325241089,opt -rpo-functionattrs -constmerge -functionattrs -scalarizer -canonicalize-aliases -jump-threading -loop-simplify -lower-constant-intrinsics -loop-interchange -aggressive-instcombine -loop-versioning -float2int -newgvn -loop-simplify -partially-inline-libcalls -loop-distribute -irce -lower-widenable-condition -instcombine -licm -sccp -coro-cleanup -dse -partially-inline-libcalls -lower-guard-intrinsic -lower-matrix-intrinsics -gvn -alignment-from-assumptions -guard-widening -rewrite-statepoints-for-gc -consthoist -dce -rewrite-statepoints-for-gc -mldst-motion -loop-guard-widening -instsimplify -attributor -mergereturn -strip-debug-declare -ipconstprop -instnamer -alignment-from-assumptions -loop-unroll-and-jam -prune-eh -dse -loop-idiom -loop-unroll -add-discriminators -strip-debug-declare -globaldce -loop-versioning -name-anon-globals -argpromotion -gvn -constprop -attributor -rewrite-statepoints-for-gc -lcssa -mergefunc -ipsccp -loop-idiom -loop-fusion -loop-versioning -called-value-propagation -flattencfg -guard-widening -inline -functionattrs -barrier -insert-gcov-profiling -partially-inline-libcalls -name-anon-globals -loop-versioning -infer-address-spaces -strip -bdce -add-discriminators -name-anon-globals -constmerge -barrier -mem2reg -loop-simplifycfg -redundant-dbg-inst-elim -coro-split -loop-guard-widening -strip-dead-prototypes -slsr -mem2reg -alignment-from-assumptions -partial-inliner -irce -memcpyopt -strip-nondebug -early-cse-memssa -coro-cleanup -loop-sink -separate-const-offset-from-gep -inject-tli-mappings -early-cse-memssa -tailcallelim -loop-unroll -licm -loop-vectorize -prune-eh -partially-inline-libcalls -newgvn -loop-reroll -break-crit-edges -post-inline-ee-instrument -rewrite-statepoints-for-gc -rpo-functionattrs -libcalls-shrinkwrap -ipsccp -nary-reassociate -load-store-vectorizer -mldst-motion -post-inline-ee-instrument -always-inline -rpo-functionattrs -flattencfg -coro-cleanup -simple-loop-unswitch -aggressive-instcombine -simple-loop-unswitch -coro-early -ipsccp -loop-guard-widening -adce -div-rem-pairs -instcombine -lower-widenable-condition -sancov -dse -loop-simplifycfg -loop-predication -memcpyopt -dce -dse -infer-address-spaces -loop-rotate -callsite-splitting -break-crit-edges -dce -partially-inline-libcalls -bdce -ipsccp -redundant-dbg-inst-elim -loop-idiom -slp-vectorizer -mergereturn -reassociate -loop-deletion -loop-fusion -jump-threading -gvn-hoist -simplifycfg -simple-loop-unswitch -loop-versioning-licm -always-inline -irce -instcombine input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0478371501272268,12.708849906921387,opt -sink -loop-vectorize -consthoist -coro-cleanup -coro-early -scalarizer -sroa -guard-widening -consthoist -correlated-propagation -loop-guard-widening -loop-idiom -instcombine -newgvn -instnamer -lcssa -strip-dead-prototypes -canonicalize-aliases -lowerinvoke -reassociate -redundant-dbg-inst-elim -ipsccp -pgo-memop-opt -add-discriminators -loop-unroll -canonicalize-aliases -indvars -coro-early -forceattrs -loop-guard-widening -loop-guard-widening -lowerswitch -ipconstprop -loop-versioning-licm -lcssa -rewrite-statepoints-for-gc -indvars -indvars -coro-cleanup -partially-inline-libcalls -loop-deletion -mem2reg -elim-avail-extern -lcssa -memcpyopt -irce -early-cse-memssa -coro-early -loop-unroll -loop-guard-widening -name-anon-globals -separate-const-offset-from-gep -loop-predication -canonicalize-aliases -ipsccp -prune-eh -consthoist -adce -called-value-propagation -loop-sink -loop-deletion -jump-threading -loop-instsimplify -adce -loop-unroll -hotcoldsplit -libcalls-shrinkwrap -consthoist -partially-inline-libcalls -infer-address-spaces -slp-vectorizer -rpo-functionattrs -sink -instcombine -dse -constprop -argpromotion -infer-address-spaces -tailcallelim -newgvn -flattencfg -mergereturn -memcpyopt -loop-unroll-and-jam -coro-cleanup -reassociate -div-rem-pairs -ee-instrument -dse -simple-loop-unswitch -strip-dead-prototypes -memcpyopt -libcalls-shrinkwrap -correlated-propagation -loop-data-prefetch -strip -simple-loop-unswitch -partial-inliner -mergefunc -loop-unroll -lowerswitch -sink -lower-matrix-intrinsics -loop-deletion -inferattrs -constprop -loop-data-prefetch -mem2reg -strip-debug-declare -attributor -lower-expect -gvn-hoist -nary-reassociate -partially-inline-libcalls -globalsplit -pgo-memop-opt -lower-widenable-condition -sancov -early-cse-memssa -consthoist -inferattrs -consthoist -reg2mem -partial-inliner -name-anon-globals -loop-vectorize -strip-debug-declare -constmerge -loop-guard-widening -div-rem-pairs -scalarizer -pgo-memop-opt -ipsccp -sccp -rpo-functionattrs -instsimplify -constmerge -loop-load-elim -coro-cleanup -lower-constant-intrinsics -mem2reg -always-inline -tailcallelim -gvn-hoist -dse -attributor -lower-expect -lowerinvoke -bdce -newgvn -mem2reg -instcombine -globalopt -elim-avail-extern -rpo-functionattrs -slsr -slsr -loweratomic -always-inline -libcalls-shrinkwrap -sancov -deadargelim -mergefunc -globaldce -loop-data-prefetch -dse -separate-const-offset-from-gep -globalsplit -globalsplit -tailcallelim -newgvn -ee-instrument -sccp -loop-versioning-licm -loop-simplify -reassociate -loop-simplifycfg -globalsplit -reassociate -post-inline-ee-instrument -ee-instrument -loop-instsimplify -break-crit-edges -constmerge -gvn-hoist -newgvn -attributor -globaldce -separate-const-offset-from-gep -mergereturn -simplifycfg -instsimplify -load-store-vectorizer -loop-instsimplify -inferattrs -irce -loweratomic -gvn -adce -loop-interchange -consthoist -argpromotion -irce -loop-versioning -reg2mem -loop-simplifycfg -strip-nondebug -strip-dead-prototypes -loop-deletion -loop-simplifycfg -inferattrs -inferattrs -strip-debug-declare -coro-elide -loop-load-elim -adce -flattencfg -inject-tli-mappings -reassociate -mergeicmps -sccp -loop-versioning-licm -name-anon-globals -rewrite-statepoints-for-gc -licm -sccp -loop-guard-widening -loop-unroll -speculative-execution -lowerinvoke -loop-deletion -mergereturn -correlated-propagation -indvars -insert-gcov-profiling -nary-reassociate -coro-early -dce -loop-reduce -functionattrs -mergereturn -simplifycfg -ee-instrument -loop-unswitch -loop-distribute -speculative-execution -loop-instsimplify -gvn-hoist -reassociate -loop-reduce -loop-unroll -loop-data-prefetch -deadargelim -coro-split -mergefunc -sroa -loop-unroll -functionattrs -lowerswitch -lcssa -canonicalize-aliases -redundant-dbg-inst-elim -correlated-propagation -loop-data-prefetch -irce -slp-vectorizer -loop-data-prefetch -coro-split -loop-simplify -loop-distribute -indvars -div-rem-pairs -indvars -loop-guard-widening -instcombine -mergeicmps -loop-unswitch -attributor -sroa -loop-data-prefetch -gvn input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0498727735368956,12.672531366348267,opt -alignment-from-assumptions -loop-vectorize -attributor -speculative-execution -loop-guard-widening -called-value-propagation -consthoist -aggressive-instcombine -break-crit-edges -constprop -inferattrs -loop-versioning-licm -instnamer -rpo-functionattrs -break-crit-edges -strip -load-store-vectorizer -name-anon-globals -globalopt -post-inline-ee-instrument -correlated-propagation -insert-gcov-profiling -partial-inliner -loop-idiom -globaldce -memcpyopt -tailcallelim -globaldce -insert-gcov-profiling -sink -coro-cleanup -irce -loop-deletion -slp-vectorizer -loop-deletion -lowerswitch -flattencfg -partially-inline-libcalls -cross-dso-cfi -lower-expect -always-inline -loop-guard-widening -cross-dso-cfi -rewrite-statepoints-for-gc -indvars -aggressive-instcombine -strip-dead-prototypes -loop-reduce -newgvn -sroa -scalarizer -loop-instsimplify -argpromotion -instcombine -constprop -rewrite-statepoints-for-gc -coro-split -hotcoldsplit -callsite-splitting -globaldce -correlated-propagation -sancov -jump-threading -forceattrs -scalarizer -globalopt -called-value-propagation -functionattrs -instnamer -ee-instrument -constmerge -attributor -memcpyopt -coro-split -loop-versioning-licm -lowerinvoke -loop-versioning -partially-inline-libcalls -guard-widening -loop-unroll-and-jam -lower-expect -slp-vectorizer -barrier -loop-versioning-licm -simple-loop-unswitch -tailcallelim -strip-debug-declare -callsite-splitting -rewrite-statepoints-for-gc -gvn-hoist -ee-instrument -dse -cross-dso-cfi -lower-constant-intrinsics -alignment-from-assumptions -constmerge -loop-distribute -scalarizer -inferattrs -sccp -add-discriminators -break-crit-edges -dse -correlated-propagation -instcombine -loop-versioning -sroa -tailcallelim -gvn-hoist -gvn -float2int -simplifycfg -float2int -loop-versioning -constprop -div-rem-pairs -inline -slsr -loop-guard-widening -loop-unroll -loop-distribute -gvn-hoist -bdce -insert-gcov-profiling -coro-cleanup -slp-vectorizer -reassociate -simplifycfg -add-discriminators -coro-elide -loop-versioning -barrier -prune-eh -loop-unroll -inline -called-value-propagation -strip-dead-prototypes -reg2mem -sink -bdce -add-discriminators -partial-inliner -gvn -lower-constant-intrinsics -scalarizer -mem2reg -indvars -scalarizer -loop-load-elim -loop-idiom -instsimplify -correlated-propagation -lcssa -redundant-dbg-inst-elim -loop-instsimplify -early-cse-memssa -called-value-propagation -partially-inline-libcalls -redundant-dbg-inst-elim -infer-address-spaces -loop-unroll-and-jam -loop-versioning -loop-simplifycfg -dce -inject-tli-mappings -globalsplit -rpo-functionattrs -loop-unroll -loop-unroll -infer-address-spaces -dce -instnamer -load-store-vectorizer -constmerge -sccp -hotcoldsplit -lower-matrix-intrinsics -tailcallelim -functionattrs -sink -sroa -loop-idiom -mergefunc -adce -lower-widenable-condition -licm -dce -gvn -always-inline -canonicalize-aliases -memcpyopt -ipsccp -loop-sink -coro-split -loop-unroll-and-jam -jump-threading -slp-vectorizer -loop-idiom -gvn -canonicalize-aliases -argpromotion -deadargelim -hotcoldsplit -coro-split -constprop -newgvn -loop-sink -deadargelim -loop-interchange -loop-distribute -guard-widening -coro-split -barrier -mem2reg -mergefunc -adce -memcpyopt -barrier -adce -loop-versioning-licm -strip-nondebug -sink -prune-eh -instcombine input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0519083969465652,12.692818880081177,opt -gvn-hoist -elim-avail-extern -loop-reduce -sink -coro-early -callsite-splitting -instnamer -called-value-propagation -lower-matrix-intrinsics -loop-distribute -instnamer -cross-dso-cfi -nary-reassociate -globalopt -argpromotion -lower-matrix-intrinsics -redundant-dbg-inst-elim -gvn -lowerswitch -gvn-hoist -mergefunc -coro-elide -lower-constant-intrinsics -aggressive-instcombine -correlated-propagation -lower-matrix-intrinsics -slp-vectorizer -loop-data-prefetch -ipsccp -indvars -mergefunc -prune-eh -lower-guard-intrinsic -bdce -coro-early -loop-simplify -reg2mem -irce -cross-dso-cfi -loop-instsimplify -sroa -loop-deletion -simple-loop-unswitch -functionattrs -sccp -strip-dead-prototypes -dce -callsite-splitting -globalsplit -hotcoldsplit -forceattrs -separate-const-offset-from-gep -correlated-propagation -aggressive-instcombine -loop-simplify -lower-matrix-intrinsics -early-cse-memssa -mem2reg -sink -licm -barrier -cross-dso-cfi -mergeicmps -elim-avail-extern -rpo-functionattrs -consthoist -lcssa -lowerinvoke -aggressive-instcombine -reg2mem -reg2mem -sink -partially-inline-libcalls -simplifycfg -memcpyopt -elim-avail-extern -break-crit-edges -loop-simplify -callsite-splitting -name-anon-globals -loweratomic -indvars -early-cse-memssa -loop-unroll -partial-inliner -cross-dso-cfi -lower-matrix-intrinsics -early-cse-memssa -div-rem-pairs -elim-avail-extern -separate-const-offset-from-gep -speculative-execution -callsite-splitting -instnamer -globaldce -loop-rotate -lowerinvoke -consthoist -loop-idiom -loop-simplify -libcalls-shrinkwrap -irce -loop-distribute -lower-expect -mergefunc -slsr -barrier -nary-reassociate -dce -lower-guard-intrinsic -lower-guard-intrinsic -irce -strip -coro-elide -loop-data-prefetch -mergefunc -mergefunc -mergeicmps -lcssa -canonicalize-aliases -loop-simplify -jump-threading -float2int -loop-vectorize -loop-sink -prune-eh -div-rem-pairs -instsimplify -loop-vectorize -irce -float2int -coro-elide -barrier -early-cse-memssa -early-cse-memssa -argpromotion -inline -prune-eh -slp-vectorizer -mem2reg -guard-widening -adce -inferattrs -simplifycfg -loweratomic -instcombine -simple-loop-unswitch -indvars -loweratomic -lower-widenable-condition -aggressive-instcombine -dse -irce -lowerswitch -alignment-from-assumptions -loop-predication -strip-dead-prototypes -inline -flattencfg -die -lowerinvoke -irce -loop-data-prefetch -add-discriminators -ipsccp -div-rem-pairs -loop-reroll -reg2mem -loop-distribute -lower-constant-intrinsics -adce -mem2reg -libcalls-shrinkwrap -lowerswitch -insert-gcov-profiling -instcombine -rewrite-statepoints-for-gc -speculative-execution -coro-elide -scalarizer -rpo-functionattrs -ipconstprop -nary-reassociate -ee-instrument -ipconstprop -partial-inliner -loop-deletion -lcssa -mem2reg -strip -coro-elide -loop-idiom -mergeicmps -globalsplit -mergereturn -reassociate -bdce -canonicalize-aliases -cross-dso-cfi -deadargelim -constmerge -mergereturn -lcssa -loop-predication -aggressive-instcombine -loop-guard-widening -functionattrs -early-cse-memssa -loop-instsimplify -instnamer -load-store-vectorizer -adce -lower-constant-intrinsics -partial-inliner -strip-nondebug -loop-fusion -flattencfg -ipconstprop -coro-elide -forceattrs -loop-idiom -globalsplit -constprop -deadargelim -scalarizer -memcpyopt -globalsplit -div-rem-pairs -tailcallelim -alignment-from-assumptions -newgvn -mergeicmps -instsimplify -lower-matrix-intrinsics -loop-reduce -loop-deletion -post-inline-ee-instrument -coro-split -tailcallelim -canonicalize-aliases -break-crit-edges -canonicalize-aliases -indvars -die -loop-deletion -argpromotion -partially-inline-libcalls -loop-fusion -mergefunc -lower-guard-intrinsic -ipsccp -loop-reroll -div-rem-pairs -barrier -jump-threading -coro-elide -ee-instrument -lcssa -loweratomic -gvn -argpromotion -loop-predication -dce -instsimplify -loop-guard-widening -loop-deletion -argpromotion -constprop -instcombine -sancov -sink -hotcoldsplit -inject-tli-mappings -redundant-dbg-inst-elim -strip-nondebug -loop-versioning-licm -instsimplify -dce -partial-inliner -ipsccp -speculative-execution -sroa -infer-address-spaces -alignment-from-assumptions -lcssa -lcssa -scalarizer -ee-instrument -globalopt -lower-matrix-intrinsics -gvn-hoist -mergeicmps -infer-address-spaces -instcombine -globalopt -coro-early -float2int -mem2reg -sancov -sink -inject-tli-mappings -loweratomic -lower-widenable-condition -always-inline -simplifycfg -reg2mem -argpromotion -strip-dead-prototypes -gvn-hoist -constmerge -inline -early-cse-memssa -lower-widenable-condition -reg2mem -coro-elide -instcombine -mem2reg -dse -flattencfg -loop-unroll-and-jam -sroa -consthoist -mldst-motion -ee-instrument -mergereturn -infer-address-spaces -ee-instrument -gvn -rewrite-statepoints-for-gc -guard-widening -mergefunc -mergereturn -callsite-splitting -canonicalize-aliases -instnamer -alignment-from-assumptions -argpromotion -simplifycfg -flattencfg -loop-reduce -gvn -loop-deletion -loop-versioning -flattencfg -strip -cross-dso-cfi -instsimplify -attributor -early-cse-memssa -insert-gcov-profiling -separate-const-offset-from-gep -indvars -slp-vectorizer -newgvn -functionattrs -loop-guard-widening -lower-widenable-condition -rpo-functionattrs -mergeicmps -load-store-vectorizer -reassociate -div-rem-pairs -loop-simplifycfg -post-inline-ee-instrument -redundant-dbg-inst-elim -dse -coro-split -bdce -attributor -forceattrs -lower-constant-intrinsics -loop-guard-widening -instcombine -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.1169348539290735,23.584031105041504,opt -loop-reduce -mem2reg -instnamer -called-value-propagation -loop-idiom -globalopt -loop-versioning -loop-unroll-and-jam -loop-instsimplify -insert-gcov-profiling -loop-instsimplify -strip-nondebug -coro-split -globalopt -mem2reg -alignment-from-assumptions -pgo-memop-opt -sink -loop-interchange -loop-deletion -consthoist -hotcoldsplit -separate-const-offset-from-gep -mem2reg -dce -div-rem-pairs -newgvn -functionattrs -dce -loop-data-prefetch -lcssa -inferattrs -correlated-propagation -sancov -strip-nondebug -speculative-execution -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.1241212310576472,25.40641736984253,opt -rpo-functionattrs -mergeicmps -loop-predication -correlated-propagation -lowerinvoke -simplifycfg -post-inline-ee-instrument -pgo-memop-opt -inferattrs -ipconstprop -div-rem-pairs -loop-unroll-and-jam -mem2reg -mldst-motion -sroa -loop-vectorize -redundant-dbg-inst-elim -strip -infer-address-spaces -canonicalize-aliases -loop-versioning -aggressive-instcombine -strip-dead-prototypes -lower-guard-intrinsic -licm -loop-unroll -separate-const-offset-from-gep -inject-tli-mappings -loweratomic -inferattrs -lower-widenable-condition -dce -lowerinvoke -mergereturn -add-discriminators -cross-dso-cfi -coro-split -coro-split -speculative-execution -loop-instsimplify -rewrite-statepoints-for-gc -jump-threading -globalsplit -newgvn -nary-reassociate input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.1369317294172785,25.428560495376587,opt -globalsplit -sancov -simple-loop-unswitch -functionattrs -partially-inline-libcalls -globaldce -pgo-memop-opt -indvars -forceattrs -loop-reduce -coro-split -newgvn -loop-simplifycfg -inject-tli-mappings -bdce -forceattrs -simplifycfg -consthoist -functionattrs -indvars -memcpyopt -hotcoldsplit -rpo-functionattrs -newgvn -flattencfg -bdce -dce -always-inline -simple-loop-unswitch -loop-reroll -insert-gcov-profiling -callsite-splitting -mergeicmps -instnamer -constprop -consthoist -add-discriminators -separate-const-offset-from-gep -correlated-propagation -slp-vectorizer -memcpyopt -slp-vectorizer -instnamer -nary-reassociate -lower-constant-intrinsics -functionattrs -lower-guard-intrinsic -loop-guard-widening -irce -loop-deletion -sccp -reassociate -loop-guard-widening -speculative-execution -reg2mem -coro-split -pgo-memop-opt -strip-nondebug -cross-dso-cfi -mem2reg -inject-tli-mappings -loop-load-elim -loop-deletion -lower-widenable-condition -argpromotion -sroa -loop-versioning-licm -inferattrs -loop-guard-widening -loop-interchange -die -correlated-propagation -partially-inline-libcalls -lower-guard-intrinsic -loop-reduce -cross-dso-cfi -lower-guard-intrinsic -loop-predication -lower-matrix-intrinsics -consthoist -sancov -mergefunc -strip-debug-declare -coro-elide -instnamer -strip -licm -reassociate -canonicalize-aliases -loop-sink -redundant-dbg-inst-elim -ipconstprop -sroa -globalopt -consthoist -name-anon-globals -mergefunc -partial-inliner -gvn-hoist -ipconstprop -loop-deletion -redundant-dbg-inst-elim -reassociate -libcalls-shrinkwrap -instcombine -lower-expect -lowerinvoke -globalopt -mem2reg -sancov -hotcoldsplit -insert-gcov-profiling -loop-fusion -nary-reassociate -forceattrs -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.1409935947508203,24.855397701263428,opt -loop-unswitch -loop-versioning -loop-guard-widening -mldst-motion -mldst-motion -loop-idiom -loop-versioning-licm -constprop -reassociate -inferattrs -coro-cleanup -loop-simplifycfg -adce -add-discriminators -sroa -cross-dso-cfi -pgo-memop-opt -consthoist -callsite-splitting -loop-simplify -simple-loop-unswitch -callsite-splitting -alignment-from-assumptions -loop-fusion -post-inline-ee-instrument -dce -partial-inliner -ee-instrument -prune-eh -reassociate -irce -memcpyopt -functionattrs -tailcallelim -loop-vectorize -inject-tli-mappings -deadargelim -gvn -name-anon-globals -loop-data-prefetch -sccp -loop-versioning-licm -mergeicmps -always-inline -mergereturn -loop-rotate -loop-sink -coro-cleanup -nary-reassociate -loop-simplifycfg -dse -simplifycfg -loop-deletion -jump-threading -memcpyopt -globalsplit -loop-instsimplify -die -inferattrs -instcombine -coro-split -consthoist -dce -mergefunc -forceattrs -name-anon-globals -lower-widenable-condition -loop-simplify -pgo-memop-opt -jump-threading input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.1423996250585842,23.81988525390625,opt -simplifycfg -loop-simplify -gvn-hoist -early-cse-memssa -loop-instsimplify -correlated-propagation -functionattrs -simple-loop-unswitch -ipconstprop -loop-reduce -separate-const-offset-from-gep -tailcallelim -instnamer -loop-distribute -loop-load-elim -redundant-dbg-inst-elim -inject-tli-mappings -loop-deletion -loop-simplify -simplifycfg -ipsccp -elim-avail-extern -slsr -called-value-propagation -loop-deletion -loop-instsimplify -gvn-hoist -elim-avail-extern -canonicalize-aliases -reg2mem -break-crit-edges -lowerinvoke -loop-reduce -break-crit-edges -loop-instsimplify -rewrite-statepoints-for-gc -correlated-propagation -lower-guard-intrinsic -loop-sink -guard-widening -coro-early -loop-predication -simple-loop-unswitch -simplifycfg -canonicalize-aliases -reg2mem -globalsplit -strip-dead-prototypes -mergefunc -loop-predication -loop-unswitch -sink -loop-guard-widening -loop-predication -mergefunc -loop-instsimplify -lower-widenable-condition -sroa -gvn -instcombine -loop-fusion -globalsplit -ipsccp -partial-inliner -partially-inline-libcalls -alignment-from-assumptions -attributor -globalopt -early-cse-memssa -name-anon-globals -lower-constant-intrinsics -called-value-propagation -coro-early -deadargelim -loop-sink -break-crit-edges -rpo-functionattrs -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.1469301671613812,23.125929832458496,opt -load-store-vectorizer -sroa -lower-expect -mergeicmps -dse -globaldce -loop-interchange -gvn-hoist -simplifycfg -argpromotion -simplifycfg -lower-guard-intrinsic -coro-early -globaldce -loop-interchange -simple-loop-unswitch -libcalls-shrinkwrap -loop-simplify -loop-distribute -loop-guard-widening -scalarizer -scalarizer -strip-debug-declare -sancov -loop-simplify -slsr -instnamer -pgo-memop-opt -lower-guard-intrinsic -lower-constant-intrinsics -loop-unroll-and-jam -name-anon-globals -called-value-propagation -constmerge -mldst-motion -consthoist -canonicalize-aliases -redundant-dbg-inst-elim -memcpyopt -float2int -gvn -partially-inline-libcalls -loop-versioning -adce -speculative-execution -lower-guard-intrinsic -name-anon-globals -mergeicmps -loop-vectorize -adce -callsite-splitting -libcalls-shrinkwrap -add-discriminators -cross-dso-cfi -slp-vectorizer -newgvn -ipsccp -loop-vectorize -consthoist -always-inline -instsimplify -strip-debug-declare -functionattrs -early-cse-memssa -instcombine input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.1548195594438369,23.729283809661865,opt -correlated-propagation -break-crit-edges -separate-const-offset-from-gep -name-anon-globals -slsr -sancov -loop-sink -barrier -prune-eh -forceattrs -constprop -deadargelim -mem2reg -coro-split -simplifycfg -gvn-hoist -deadargelim -loop-guard-widening -sroa -constprop -globalopt -guard-widening -loop-guard-widening -consthoist -die -newgvn -jump-threading -sroa -aggressive-instcombine -loweratomic -indvars -coro-split -instcombine -slp-vectorizer -post-inline-ee-instrument -newgvn -dse input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.1548195594438382,24.505677223205566,opt -strip -break-crit-edges -loop-fusion -rewrite-statepoints-for-gc -redundant-dbg-inst-elim -div-rem-pairs -separate-const-offset-from-gep -memcpyopt -redundant-dbg-inst-elim -sroa -simple-loop-unswitch -sccp -instcombine -mem2reg -gvn -loop-sink -barrier -insert-gcov-profiling -globalopt -instnamer -forceattrs -loop-versioning-licm -mergeicmps -tailcallelim -indvars -coro-early -reassociate -post-inline-ee-instrument -globalopt -inferattrs -bdce -dce -loop-interchange -ipsccp -loop-interchange -argpromotion -sroa -argpromotion -separate-const-offset-from-gep -called-value-propagation -mergefunc -separate-const-offset-from-gep -simplifycfg -loop-simplifycfg -insert-gcov-profiling -loop-simplify -adce -rpo-functionattrs -break-crit-edges -strip-dead-prototypes -mergereturn -ipsccp -loweratomic -callsite-splitting -ipsccp -instnamer -forceattrs -slp-vectorizer -guard-widening -adce -deadargelim -loop-idiom -mldst-motion -load-store-vectorizer -indvars -inferattrs -loop-versioning -deadargelim -lcssa -simplifycfg -functionattrs -coro-cleanup -coro-cleanup -lower-widenable-condition -loop-fusion -sancov -post-inline-ee-instrument -mem2reg -loweratomic -loop-fusion -rewrite-statepoints-for-gc -correlated-propagation -sroa -indvars -coro-elide -licm -loop-load-elim -loop-unroll-and-jam -licm -loop-instsimplify -sroa -loop-versioning-licm -simple-loop-unswitch -functionattrs -canonicalize-aliases -libcalls-shrinkwrap -loop-deletion -loop-deletion -loop-versioning -mergefunc -loop-simplify -instcombine -coro-cleanup -correlated-propagation -prune-eh -globaldce -forceattrs -lower-constant-intrinsics -dce -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.1602093422902673,29.369541883468628,opt -name-anon-globals -float2int -constmerge -prune-eh -loop-guard-widening -loop-load-elim -dse -lower-constant-intrinsics -loop-instsimplify -ipsccp -tailcallelim -cross-dso-cfi -constprop -strip-debug-declare -coro-cleanup -loop-guard-widening -loop-simplifycfg -loop-reduce -loop-simplify -consthoist -barrier -canonicalize-aliases -gvn -rewrite-statepoints-for-gc -partially-inline-libcalls -post-inline-ee-instrument -instnamer -partially-inline-libcalls -sroa -loop-versioning -coro-early -bdce -loop-unroll-and-jam -sink -loop-versioning-licm -strip-debug-declare -newgvn -slp-vectorizer -loop-idiom -newgvn -simplifycfg -loweratomic -loop-instsimplify -sccp -coro-split -forceattrs -licm -licm -early-cse-memssa -rewrite-statepoints-for-gc -strip-dead-prototypes -functionattrs -functionattrs -lcssa -constmerge -loop-versioning -indvars -strip-dead-prototypes -consthoist -pgo-memop-opt -lower-expect -partially-inline-libcalls -canonicalize-aliases -sink -loop-guard-widening -speculative-execution -coro-early -rewrite-statepoints-for-gc -separate-const-offset-from-gep -tailcallelim -loop-versioning -cross-dso-cfi -coro-cleanup -gvn -aggressive-instcombine -loop-data-prefetch -sroa -lowerinvoke -sancov -loop-predication -strip-dead-prototypes -loop-distribute -guard-widening -loop-simplifycfg -globalopt -called-value-propagation -lower-expect -early-cse-memssa -mergereturn -loop-load-elim -coro-split -instcombine -name-anon-globals -insert-gcov-profiling -loop-unroll-and-jam -globalopt -strip-debug-declare -strip -separate-const-offset-from-gep -strip-debug-declare -partially-inline-libcalls -globalsplit -mergefunc -die -loop-versioning-licm -irce -loop-predication -gvn -loop-versioning -tailcallelim input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.1766911420090613,27.65174961090088,opt -pgo-memop-opt -coro-elide -coro-cleanup -pgo-memop-opt -slsr -lower-matrix-intrinsics -loop-deletion -loop-versioning-licm -post-inline-ee-instrument -strip-dead-prototypes -sink -adce -lower-guard-intrinsic -strip-nondebug -coro-early -mem2reg -constmerge -adce -strip-nondebug -mergeicmps -irce -slsr -irce -tailcallelim -ipsccp -die -memcpyopt -separate-const-offset-from-gep -loop-load-elim -gvn -reassociate -pgo-memop-opt -separate-const-offset-from-gep -loop-data-prefetch -early-cse-memssa -scalarizer -lcssa -aggressive-instcombine -lower-guard-intrinsic -loop-sink -die -tailcallelim -dse -nary-reassociate -load-store-vectorizer -dce -lower-guard-intrinsic -callsite-splitting -adce -loop-load-elim -rpo-functionattrs -strip-debug-declare -loop-unswitch -slp-vectorizer -sink -inject-tli-mappings -loop-idiom -lowerinvoke -sccp -load-store-vectorizer -loweratomic -inferattrs -constmerge -hotcoldsplit -cross-dso-cfi -mldst-motion -loop-sink -lower-constant-intrinsics -separate-const-offset-from-gep -loop-fusion -loop-vectorize -strip-nondebug -lowerinvoke -div-rem-pairs -aggressive-instcombine -insert-gcov-profiling -mergeicmps -instcombine -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/crc32,0.9921875,11.82210922241211,opt -instsimplify -instsimplify -loop-unswitch -partial-inliner -constprop -coro-split -slp-vectorizer -mergeicmps -callsite-splitting -mergereturn -sroa -attributor -name-anon-globals -aggressive-instcombine -scalarizer -globalopt -cross-dso-cfi -break-crit-edges -flattencfg -instnamer -loop-reduce -mergefunc -libcalls-shrinkwrap -sccp -loop-instsimplify -constprop -coro-split -indvars -deadargelim -loop-unroll -jump-threading -indvars -loop-guard-widening -loop-simplifycfg -deadargelim -bdce -constmerge -strip-nondebug -forceattrs -loop-reroll -inferattrs -mergefunc -sancov -speculative-execution -ipconstprop -speculative-execution -lower-guard-intrinsic -hotcoldsplit -lower-guard-intrinsic -forceattrs -adce -coro-cleanup -adce -pgo-memop-opt -slsr -dce -early-cse-memssa -ipconstprop -loop-predication -coro-elide -inject-tli-mappings -infer-address-spaces -argpromotion -float2int -separate-const-offset-from-gep -dce -loop-versioning-licm -coro-early -slp-vectorizer -adce -nary-reassociate -libcalls-shrinkwrap -instnamer -coro-early -add-discriminators -alignment-from-assumptions -lower-widenable-condition -rewrite-statepoints-for-gc -lower-widenable-condition -coro-early -argpromotion -pgo-memop-opt -inject-tli-mappings -lower-guard-intrinsic -mem2reg -lower-matrix-intrinsics -loop-sink -scalarizer -die -loop-fusion -slsr -coro-split -globaldce -inject-tli-mappings -ee-instrument -lower-constant-intrinsics -speculative-execution -dce -loop-reduce -strip -loop-unroll -prune-eh -callsite-splitting -post-inline-ee-instrument -instsimplify -mergefunc -adce -simplifycfg -callsite-splitting -gvn -globaldce -coro-early -early-cse-memssa -loop-data-prefetch -lower-expect -mergereturn -loop-vectorize -instnamer -sink -loop-versioning -cross-dso-cfi -instcombine -sancov -gvn-hoist -memcpyopt -loop-sink -nary-reassociate -loop-data-prefetch -lower-widenable-condition -add-discriminators -memcpyopt -mergefunc -inject-tli-mappings -sroa -barrier -loop-versioning -sccp -loop-data-prefetch -scalarizer -barrier -mergefunc -indvars -sccp -jump-threading -newgvn input.bc -o output.bc +benchmark://cbench-v1/crc32,0.9921875,11.96300196647644,opt -correlated-propagation -called-value-propagation -loop-versioning -slp-vectorizer -simple-loop-unswitch -always-inline -prune-eh -sroa -reg2mem -loop-idiom -nary-reassociate -prune-eh -reassociate -callsite-splitting -dce -loop-predication -float2int -partially-inline-libcalls -globaldce -coro-elide -rewrite-statepoints-for-gc -coro-split -tailcallelim -inferattrs -sancov -adce -lower-guard-intrinsic -loop-idiom -strip-nondebug -name-anon-globals -jump-threading -float2int -post-inline-ee-instrument -alignment-from-assumptions -loop-data-prefetch -tailcallelim -loop-load-elim -simple-loop-unswitch -sink -attributor -elim-avail-extern -aggressive-instcombine -break-crit-edges -lowerswitch -lowerinvoke -globalsplit -mergereturn -strip -indvars -loop-unroll-and-jam -loop-unroll -separate-const-offset-from-gep -infer-address-spaces -loop-versioning -loop-predication -loop-instsimplify -deadargelim -simplifycfg -strip-dead-prototypes -lowerinvoke -lower-constant-intrinsics -irce -inject-tli-mappings -partially-inline-libcalls -strip -constmerge -partial-inliner -pgo-memop-opt -infer-address-spaces -inline -irce -break-crit-edges -lower-matrix-intrinsics -globalsplit -slp-vectorizer -sroa -slp-vectorizer -loop-deletion -post-inline-ee-instrument -loop-unroll-and-jam -simple-loop-unswitch -mem2reg -mergereturn -sancov -loop-data-prefetch -simplifycfg -add-discriminators -gvn input.bc -o output.bc +benchmark://cbench-v1/crc32,0.9921875,12.11146593093872,opt -simple-loop-unswitch -loop-load-elim -nary-reassociate -nary-reassociate -slsr -post-inline-ee-instrument -lower-matrix-intrinsics -indvars -globalopt -mergereturn -coro-split -adce -simple-loop-unswitch -attributor -constmerge -strip-nondebug -separate-const-offset-from-gep -argpromotion -loop-interchange -gvn -strip-nondebug -add-discriminators -constmerge -mergeicmps -reg2mem -strip-debug-declare -speculative-execution -break-crit-edges -strip -loop-data-prefetch -name-anon-globals -globaldce -strip-dead-prototypes -loweratomic -sccp -partial-inliner -ee-instrument -aggressive-instcombine -scalarizer -forceattrs -argpromotion -argpromotion -instsimplify -strip-nondebug -ipconstprop -add-discriminators -loop-data-prefetch -globaldce -instsimplify -globalopt -alignment-from-assumptions -strip-dead-prototypes -newgvn -ee-instrument -strip-nondebug -loop-idiom -ipconstprop -guard-widening -correlated-propagation -gvn -lowerswitch -tailcallelim -barrier -dce -instnamer -loop-instsimplify -jump-threading -barrier -reg2mem -loop-vectorize -inline -loop-sink -mergefunc -licm -insert-gcov-profiling -constprop -aggressive-instcombine -lower-matrix-intrinsics -indvars -argpromotion -sroa -loop-data-prefetch -loop-predication -licm -loop-interchange -callsite-splitting -load-store-vectorizer -flattencfg -constmerge -reassociate -lower-matrix-intrinsics -jump-threading -loop-data-prefetch -coro-split -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,11.723689317703247,opt -partially-inline-libcalls -inferattrs -mem2reg -scalarizer -always-inline -coro-elide -loop-reroll -constmerge -loop-reroll -globalsplit -early-cse-memssa -insert-gcov-profiling -sroa -insert-gcov-profiling -jump-threading -simple-loop-unswitch -adce -deadargelim -simplifycfg -sccp -rpo-functionattrs -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,11.768340826034546,opt -strip -strip-debug-declare -prune-eh -add-discriminators -loop-interchange -infer-address-spaces -callsite-splitting -loop-interchange -loop-versioning -globalsplit -infer-address-spaces -rpo-functionattrs -attributor -loop-unswitch -guard-widening -deadargelim -loop-data-prefetch -loop-data-prefetch -newgvn -speculative-execution -instcombine -lower-guard-intrinsic -loop-sink -early-cse-memssa -loop-unroll -constmerge -inferattrs -called-value-propagation -lowerswitch -strip-nondebug -dce -redundant-dbg-inst-elim -sink -mergefunc -pgo-memop-opt -loop-distribute -sink -loop-deletion -name-anon-globals -lcssa -loop-idiom -irce -lowerswitch -loop-versioning-licm -bdce -prune-eh -rpo-functionattrs -loop-unroll-and-jam -loweratomic -libcalls-shrinkwrap -strip-dead-prototypes -strip-dead-prototypes -break-crit-edges -lower-expect -globaldce -slsr -adce -instcombine -insert-gcov-profiling -nary-reassociate -infer-address-spaces -prune-eh -load-store-vectorizer -argpromotion -ipconstprop -dse -tailcallelim -scalarizer -inferattrs -mldst-motion -slp-vectorizer -loop-fusion -reassociate -post-inline-ee-instrument -constprop -lcssa -globaldce -loweratomic -sancov -strip-dead-prototypes -lowerinvoke -mldst-motion -jump-threading -loop-predication -lower-matrix-intrinsics -load-store-vectorizer -globaldce -mergeicmps -float2int -loop-vectorize -gvn -tailcallelim -redundant-dbg-inst-elim -globalopt -irce -loop-load-elim -lcssa -called-value-propagation -speculative-execution -loop-instsimplify -simple-loop-unswitch -newgvn -reassociate -redundant-dbg-inst-elim -sroa -mergereturn -globalsplit -sroa -lower-matrix-intrinsics -called-value-propagation -mldst-motion -barrier -elim-avail-extern -dce -tailcallelim -loop-versioning -callsite-splitting -partially-inline-libcalls -aggressive-instcombine -simple-loop-unswitch -globaldce -dse -bdce -separate-const-offset-from-gep -mergeicmps -sancov -speculative-execution -elim-avail-extern -flattencfg -adce -forceattrs -flattencfg -loop-simplify -canonicalize-aliases -loop-load-elim -die -scalarizer -strip-dead-prototypes -cross-dso-cfi -lowerswitch -strip -nary-reassociate -slsr -bdce -instcombine -newgvn -float2int -cross-dso-cfi -canonicalize-aliases -loop-predication -partial-inliner -coro-elide -irce -globaldce -coro-elide -argpromotion -rewrite-statepoints-for-gc -reassociate -ipconstprop -early-cse-memssa -constmerge -coro-elide -loop-reroll -infer-address-spaces -coro-elide -coro-split -gvn-hoist -cross-dso-cfi -loop-versioning-licm -loop-distribute -tailcallelim -pgo-memop-opt -lower-guard-intrinsic -forceattrs -loop-interchange -nary-reassociate -sink -early-cse-memssa -coro-cleanup -loop-vectorize -loop-instsimplify -loop-versioning -mem2reg -lcssa -strip-nondebug -strip-dead-prototypes -coro-early -gvn -redundant-dbg-inst-elim -scalarizer -ipsccp -infer-address-spaces -instcombine -lower-matrix-intrinsics -irce -barrier -correlated-propagation -lower-constant-intrinsics -gvn-hoist -slp-vectorizer -loop-vectorize -loop-instsimplify -loop-instsimplify -instsimplify -deadargelim -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,11.806458950042725,opt -lcssa -strip -always-inline -prune-eh -argpromotion -scalarizer -ee-instrument -inject-tli-mappings -lcssa -lower-expect -coro-cleanup -partial-inliner -loop-sink -sink -ipsccp -forceattrs -globalsplit -correlated-propagation -loop-guard-widening -strip-nondebug -name-anon-globals -load-store-vectorizer -rewrite-statepoints-for-gc -mldst-motion -mldst-motion -speculative-execution -attributor -name-anon-globals -tailcallelim -loop-fusion -alignment-from-assumptions -newgvn -separate-const-offset-from-gep -div-rem-pairs -lower-constant-intrinsics -inferattrs -forceattrs -globalsplit -loop-simplifycfg -callsite-splitting -bdce -sroa -mergefunc -lowerswitch -sroa -flattencfg -mergefunc -mergefunc -elim-avail-extern -loop-unroll -flattencfg -inferattrs -reassociate -strip-debug-declare -ipconstprop -gvn-hoist -speculative-execution -instsimplify -loop-deletion -gvn-hoist -guard-widening -loop-interchange -bdce -lower-matrix-intrinsics -cross-dso-cfi -loop-versioning -redundant-dbg-inst-elim -loop-simplifycfg -libcalls-shrinkwrap -tailcallelim -jump-threading -globalsplit -div-rem-pairs -constprop -ipconstprop -rewrite-statepoints-for-gc -loop-load-elim -lowerswitch -inject-tli-mappings -insert-gcov-profiling -break-crit-edges -called-value-propagation -simplifycfg -inject-tli-mappings -add-discriminators -dce -aggressive-instcombine -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,11.919891834259033,opt -globalsplit -loop-unroll-and-jam -barrier -partially-inline-libcalls -gvn-hoist -loop-interchange -loop-data-prefetch -lower-guard-intrinsic -lcssa -mem2reg -mergereturn -hotcoldsplit -newgvn -barrier -pgo-memop-opt -reassociate -simplifycfg -die -deadargelim -libcalls-shrinkwrap -lowerinvoke -mergeicmps -loop-vectorize -loop-fusion -mldst-motion -loop-vectorize -post-inline-ee-instrument -load-store-vectorizer -rpo-functionattrs -sancov -load-store-vectorizer -loop-fusion -lowerswitch -consthoist -libcalls-shrinkwrap -loop-versioning -globalsplit -post-inline-ee-instrument -constmerge -loop-guard-widening -adce -inject-tli-mappings -cross-dso-cfi -instcombine -float2int -loop-reroll -loop-vectorize -prune-eh -sccp -coro-elide -dce -elim-avail-extern -nary-reassociate -simplifycfg -gvn input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,11.926751136779785,opt -name-anon-globals -load-store-vectorizer -loop-versioning -float2int -bdce -float2int -loop-fusion -loop-distribute -loop-guard-widening -nary-reassociate -instsimplify -loop-interchange -sccp -lower-matrix-intrinsics -gvn-hoist -nary-reassociate -break-crit-edges -cross-dso-cfi -insert-gcov-profiling -prune-eh -loop-simplifycfg -loop-load-elim -mem2reg -die -strip-dead-prototypes -mergereturn -loop-vectorize -add-discriminators -loop-fusion -licm -strip-dead-prototypes -aggressive-instcombine -rewrite-statepoints-for-gc -ipsccp -deadargelim -loweratomic -reassociate -loop-predication -consthoist -div-rem-pairs -gvn-hoist -strip-dead-prototypes -lower-widenable-condition -correlated-propagation -inject-tli-mappings -ipconstprop -dse -reassociate -loop-unroll -barrier -strip -rpo-functionattrs -insert-gcov-profiling -gvn -instcombine -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,11.97989559173584,opt -coro-elide -loop-unroll -early-cse-memssa -loop-simplify -always-inline -lower-expect -loop-interchange -loop-versioning-licm -lower-matrix-intrinsics -indvars -loop-unroll -elim-avail-extern -partially-inline-libcalls -loop-guard-widening -constmerge -ee-instrument -loweratomic -div-rem-pairs -adce -loop-unroll -loop-deletion -reassociate -constmerge -memcpyopt -consthoist -reassociate -simple-loop-unswitch -correlated-propagation -globalopt -aggressive-instcombine -coro-elide -attributor -lower-constant-intrinsics -partially-inline-libcalls -coro-split -reassociate -loop-simplify -licm -hotcoldsplit -tailcallelim -flattencfg -lower-matrix-intrinsics -die -strip-dead-prototypes -rewrite-statepoints-for-gc -argpromotion -instsimplify -inferattrs -break-crit-edges -mergeicmps -coro-early -loop-vectorize -ipconstprop -loop-deletion -lowerinvoke -break-crit-edges -constprop -instcombine -inject-tli-mappings -loop-distribute -partial-inliner -loop-unroll-and-jam -guard-widening -instsimplify -reassociate -coro-early -lower-constant-intrinsics -newgvn -ipsccp -tailcallelim -coro-elide -sroa -loop-simplify -loop-guard-widening -loop-load-elim -loop-sink -lcssa -slp-vectorizer -loop-reduce -mergefunc -load-store-vectorizer -lower-guard-intrinsic -prune-eh -ipsccp -dse -reassociate -loop-guard-widening -mergereturn -lower-widenable-condition -constmerge -inferattrs -attributor -loop-interchange -ee-instrument -load-store-vectorizer -simplifycfg -aggressive-instcombine -simplifycfg -lowerswitch -newgvn -loop-reduce -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,12.256370306015015,opt -separate-const-offset-from-gep -coro-split -globalopt -attributor -irce -lowerinvoke -consthoist -globalopt -mergeicmps -lcssa -loop-deletion -argpromotion -name-anon-globals -strip-debug-declare -constprop -scalarizer -sroa -die -sink -slsr -consthoist -dse -barrier -lcssa -ipsccp -always-inline -pgo-memop-opt -infer-address-spaces -slp-vectorizer -lower-expect -infer-address-spaces -loop-fusion -loop-sink -mem2reg -loop-reduce -strip-debug-declare -coro-cleanup -strip -pgo-memop-opt -instsimplify -constmerge -loop-unroll-and-jam -lowerinvoke -loop-guard-widening -loop-load-elim -loop-simplify -constprop -early-cse-memssa -irce -div-rem-pairs -post-inline-ee-instrument -div-rem-pairs -ee-instrument -ee-instrument -div-rem-pairs -lowerswitch -lower-matrix-intrinsics -lower-expect -strip-debug-declare -prune-eh -prune-eh -early-cse-memssa -instcombine -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.9540816326530615,12.104652643203735,opt -loop-reduce -loop-sink -mem2reg -pgo-memop-opt -pgo-memop-opt -bdce -hotcoldsplit -sancov -slp-vectorizer -instsimplify -reassociate -newgvn -speculative-execution -libcalls-shrinkwrap -mem2reg -elim-avail-extern -loop-simplify -irce -ipsccp -indvars -flattencfg -indvars -jump-threading -sroa -simple-loop-unswitch -lower-expect -loop-distribute -constprop -pgo-memop-opt -coro-early -inferattrs -loop-data-prefetch -newgvn -functionattrs -instsimplify -argpromotion -instcombine input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.9693877551020408,12.26811695098877,opt -scalarizer -loop-sink -functionattrs -deadargelim -loop-simplifycfg -loop-sink -simple-loop-unswitch -slsr -pgo-memop-opt -loop-interchange -elim-avail-extern -indvars -loop-deletion -insert-gcov-profiling -mldst-motion -bdce -slsr -loop-unroll -speculative-execution -lower-expect -functionattrs -lower-widenable-condition -correlated-propagation -strip -loop-unroll -simple-loop-unswitch -dce -loop-vectorize -mldst-motion -tailcallelim -break-crit-edges -mergeicmps -insert-gcov-profiling -slp-vectorizer -lower-matrix-intrinsics -bdce -globaldce -name-anon-globals -ipconstprop -post-inline-ee-instrument -separate-const-offset-from-gep -loop-simplifycfg -gvn-hoist -sink -loop-sink -inject-tli-mappings -argpromotion -irce -coro-split -sink -loop-load-elim -lower-guard-intrinsic -early-cse-memssa -inferattrs -loop-predication -speculative-execution -licm -early-cse-memssa -forceattrs -infer-address-spaces -rpo-functionattrs -sroa -deadargelim -simple-loop-unswitch -correlated-propagation -strip-nondebug -loop-interchange -rpo-functionattrs -indvars -partial-inliner -lower-constant-intrinsics -early-cse-memssa -called-value-propagation -simplifycfg -loop-guard-widening -forceattrs -post-inline-ee-instrument -mem2reg -jump-threading -canonicalize-aliases -ee-instrument -newgvn -callsite-splitting -rpo-functionattrs -loweratomic -strip -loop-unroll-and-jam -prune-eh -instcombine -die -canonicalize-aliases -nary-reassociate -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.9693877551020409,11.962674379348755,opt -forceattrs -infer-address-spaces -rewrite-statepoints-for-gc -hotcoldsplit -add-discriminators -name-anon-globals -die -loweratomic -newgvn -mem2reg -dse -speculative-execution -memcpyopt -simplifycfg -insert-gcov-profiling -sroa -globaldce -pgo-memop-opt -tailcallelim -lower-constant-intrinsics -lower-expect -speculative-execution -instcombine input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.9693877551020409,12.425644397735596,opt -elim-avail-extern -rpo-functionattrs -jump-threading -loop-instsimplify -loop-simplify -alignment-from-assumptions -simple-loop-unswitch -inject-tli-mappings -load-store-vectorizer -sroa -instnamer -attributor -die -bdce -strip -always-inline -reassociate -loop-predication -coro-cleanup -sink -loop-unroll -scalarizer -mergeicmps -lcssa -instnamer -adce -coro-split -redundant-dbg-inst-elim -lcssa -constprop -elim-avail-extern -loop-unswitch -loop-unroll-and-jam -loweratomic -nary-reassociate -bdce -partially-inline-libcalls -gvn-hoist -inferattrs -irce -loop-unswitch -separate-const-offset-from-gep -sancov -ipsccp -constmerge -sroa -instnamer -redundant-dbg-inst-elim -loop-idiom -loop-distribute -slp-vectorizer -loop-vectorize -simple-loop-unswitch -float2int -sancov -sancov -slsr -called-value-propagation -loop-reduce -globaldce -scalarizer -prune-eh -loop-predication -lower-expect -loop-deletion -slsr -mem2reg -add-discriminators -loop-versioning -loop-reroll -forceattrs -lower-widenable-condition -loop-load-elim -coro-cleanup -partially-inline-libcalls -attributor -libcalls-shrinkwrap -loweratomic -called-value-propagation -instsimplify -loop-sink -called-value-propagation -jump-threading -load-store-vectorizer -sroa -constprop -slp-vectorizer -mldst-motion -guard-widening -gvn -loop-versioning-licm -dse -loop-predication -loop-reroll -hotcoldsplit -licm -mergereturn -sink -mergeicmps -div-rem-pairs -functionattrs -lower-expect -rpo-functionattrs -loop-predication -loop-data-prefetch -elim-avail-extern -always-inline -guard-widening -div-rem-pairs -prune-eh -strip -licm -reg2mem -loop-sink -rewrite-statepoints-for-gc -inject-tli-mappings -loop-sink -lower-matrix-intrinsics -strip-dead-prototypes -sroa -loop-sink -globaldce -barrier -post-inline-ee-instrument -dse -prune-eh -deadargelim -libcalls-shrinkwrap -rpo-functionattrs -forceattrs -name-anon-globals -sink -simplifycfg -gvn -loop-guard-widening -loop-guard-widening -slsr -loop-unroll -consthoist -loop-interchange -slsr -inferattrs -lower-widenable-condition -mem2reg -strip-debug-declare -simplifycfg -loop-reroll -lcssa -lower-constant-intrinsics -barrier -sancov -cross-dso-cfi -lower-expect -coro-elide -loop-load-elim -dse -simple-loop-unswitch -aggressive-instcombine -coro-elide -lower-guard-intrinsic -cross-dso-cfi -insert-gcov-profiling -early-cse-memssa -lowerinvoke -lower-expect -callsite-splitting -lowerinvoke -loop-reroll -load-store-vectorizer -guard-widening -rpo-functionattrs -instnamer -coro-cleanup -loop-versioning-licm -loop-data-prefetch -dce -coro-elide -loop-instsimplify -mergefunc -always-inline -instsimplify -ipsccp -instnamer -constprop -jump-threading -lower-expect -loop-fusion -ipsccp -coro-cleanup -break-crit-edges -ipsccp -loop-simplify -loop-unroll-and-jam -bdce -strip-debug-declare -dse -loop-reduce -slp-vectorizer -gvn -forceattrs -lowerswitch -rewrite-statepoints-for-gc -inject-tli-mappings -reassociate -licm -lowerswitch -name-anon-globals -pgo-memop-opt -dse -gvn-hoist -nary-reassociate -functionattrs -nary-reassociate -loop-deletion -loop-guard-widening -consthoist -barrier -loop-reroll -rpo-functionattrs -separate-const-offset-from-gep -strip-dead-prototypes -strip-debug-declare -instsimplify -nary-reassociate -mergefunc -lowerinvoke -flattencfg -loop-predication -reassociate -pgo-memop-opt -indvars -loop-distribute -mergefunc -aggressive-instcombine -coro-elide -loop-idiom -barrier -loop-vectorize -consthoist -simplifycfg -sroa -insert-gcov-profiling -lowerswitch -lcssa -instcombine input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.9744897959183674,12.125283002853394,opt -functionattrs -loop-distribute -callsite-splitting -dce -sancov -add-discriminators -argpromotion -simplifycfg -loop-reduce -ee-instrument -redundant-dbg-inst-elim -instnamer -reg2mem -sink -partially-inline-libcalls -strip-debug-declare -loop-unroll -loop-predication -callsite-splitting -slsr -libcalls-shrinkwrap -partially-inline-libcalls -deadargelim -dce -argpromotion -forceattrs -aggressive-instcombine -barrier -div-rem-pairs -lower-constant-intrinsics -globaldce -ipsccp -barrier -rewrite-statepoints-for-gc -loop-data-prefetch -memcpyopt -callsite-splitting -ee-instrument -loop-unswitch -indvars -strip -memcpyopt -scalarizer -constmerge -coro-early -loop-distribute -lower-expect -lower-expect -loop-instsimplify -argpromotion -reassociate -slp-vectorizer -pgo-memop-opt -insert-gcov-profiling -functionattrs -loop-unroll -loop-reduce -callsite-splitting -lower-widenable-condition -coro-elide -coro-early -newgvn -loop-instsimplify -lower-widenable-condition -gvn-hoist -jump-threading -sroa -strip -ipsccp -strip-dead-prototypes -adce -memcpyopt -load-store-vectorizer -partially-inline-libcalls -indvars -early-cse-memssa -hotcoldsplit -newgvn -guard-widening -loop-unroll-and-jam -tailcallelim -lcssa -ee-instrument -newgvn -loweratomic -lowerinvoke -flattencfg -instsimplify -loop-interchange -speculative-execution -reassociate -always-inline -instcombine -lower-matrix-intrinsics -loop-predication -guard-widening -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.9795918367346937,11.949142694473267,opt -instnamer -partially-inline-libcalls -loop-distribute -loop-predication -die -lower-expect -early-cse-memssa -rpo-functionattrs -redundant-dbg-inst-elim -separate-const-offset-from-gep -loop-load-elim -strip-nondebug -loop-versioning-licm -sancov -add-discriminators -float2int -loop-simplifycfg -inferattrs -alignment-from-assumptions -strip-debug-declare -loop-versioning -memcpyopt -indvars -loop-guard-widening -irce -guard-widening -loop-simplifycfg -lower-constant-intrinsics -argpromotion -loop-reroll -argpromotion -lowerinvoke -gvn-hoist -loop-unroll-and-jam -dse -sancov -newgvn -mem2reg -argpromotion -loop-load-elim -scalarizer -loop-sink -forceattrs -break-crit-edges -loop-unroll-and-jam -irce -canonicalize-aliases -memcpyopt -dce -mergereturn -adce -coro-elide -bdce -loop-predication -mem2reg -loop-reduce -simplifycfg -add-discriminators -scalarizer -libcalls-shrinkwrap -always-inline -reassociate -lower-constant-intrinsics -ipconstprop -aggressive-instcombine -called-value-propagation -gvn-hoist -die -loop-versioning-licm -loop-sink -mldst-motion -lower-guard-intrinsic -div-rem-pairs -mergeicmps -memcpyopt -loop-distribute -forceattrs -ipconstprop -rewrite-statepoints-for-gc -load-store-vectorizer -loop-versioning-licm -loop-reduce -simplifycfg -coro-elide -simple-loop-unswitch -loop-reroll -licm -loop-versioning -callsite-splitting -correlated-propagation -lower-guard-intrinsic -inferattrs -loop-guard-widening -cross-dso-cfi -name-anon-globals -loop-interchange -div-rem-pairs -dce -irce -loop-distribute -coro-early -loop-versioning -lower-guard-intrinsic -globalopt -loop-versioning-licm -instcombine -aggressive-instcombine -sink -jump-threading input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.9795918367346937,12.17411756515503,opt -dse -loop-reduce -gvn-hoist -float2int -libcalls-shrinkwrap -called-value-propagation -instnamer -sink -rpo-functionattrs -loop-fusion -loop-versioning-licm -loop-distribute -instsimplify -ipsccp -sancov -loop-distribute -dce -lowerswitch -newgvn -instsimplify -aggressive-instcombine -globalsplit -lower-widenable-condition -mergefunc -ipconstprop -sroa -die -loop-sink -loop-reroll -sroa -globaldce -loop-distribute -speculative-execution -add-discriminators -sccp -tailcallelim -partially-inline-libcalls -functionattrs -loop-reroll -loweratomic -forceattrs -globalsplit -loop-load-elim -consthoist -instcombine -deadargelim -loop-instsimplify -div-rem-pairs -dse -instcombine -coro-elide -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.9795918367346939,12.16299557685852,opt -loop-versioning -coro-early -scalarizer -bdce -nary-reassociate -partially-inline-libcalls -alignment-from-assumptions -div-rem-pairs -lcssa -newgvn -constmerge -forceattrs -alignment-from-assumptions -mem2reg -globaldce -mergefunc -separate-const-offset-from-gep -loop-unswitch -lower-widenable-condition -attributor -loop-versioning -alignment-from-assumptions -flattencfg -cross-dso-cfi -lower-constant-intrinsics -strip -instcombine -functionattrs -loop-vectorize -ipsccp -simplifycfg -attributor -aggressive-instcombine -lower-matrix-intrinsics -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.9795918367346939,12.400394678115845,opt -coro-early -ipconstprop -canonicalize-aliases -lower-constant-intrinsics -instnamer -early-cse-memssa -lower-constant-intrinsics -float2int -mergefunc -loop-load-elim -mergereturn -loop-unroll -loop-idiom -libcalls-shrinkwrap -rpo-functionattrs -lcssa -strip-dead-prototypes -scalarizer -loop-fusion -reassociate -bdce -coro-cleanup -inject-tli-mappings -reassociate -loop-fusion -globaldce -reg2mem -strip -ipconstprop -reg2mem -sink -loop-simplifycfg -aggressive-instcombine -loop-instsimplify -prune-eh -reg2mem -tailcallelim -early-cse-memssa -barrier -barrier -mldst-motion -loop-data-prefetch -forceattrs -loop-versioning -sink -strip-dead-prototypes -speculative-execution -loop-deletion -slp-vectorizer -ipsccp -jump-threading -pgo-memop-opt -coro-split -loop-unroll -lowerinvoke -callsite-splitting -scalarizer -loop-simplify -irce -instnamer -sroa -instsimplify -cross-dso-cfi -newgvn -rpo-functionattrs -loop-reduce -attributor -loop-simplifycfg -coro-split -sroa -lower-expect -coro-early -ee-instrument -strip -lower-matrix-intrinsics -gvn-hoist -strip-debug-declare -separate-const-offset-from-gep -sancov -newgvn -loop-fusion -slsr -gvn-hoist -loop-simplify -strip -loop-guard-widening -simple-loop-unswitch -sroa -forceattrs -slp-vectorizer -loop-idiom -strip-dead-prototypes -sancov -canonicalize-aliases -simple-loop-unswitch -scalarizer -guard-widening -ipsccp -inject-tli-mappings -aggressive-instcombine -licm -elim-avail-extern -loop-versioning-licm -float2int -gvn-hoist -coro-split -coro-early -loop-reduce -coro-elide -simplifycfg -partially-inline-libcalls -canonicalize-aliases -loop-versioning-licm -loop-data-prefetch -callsite-splitting -simple-loop-unswitch -deadargelim -loop-deletion -loop-vectorize -functionattrs -loweratomic -jump-threading -loop-reroll -guard-widening -pgo-memop-opt -reg2mem -coro-elide -slsr -separate-const-offset-from-gep -coro-cleanup -sancov -elim-avail-extern -deadargelim -mem2reg -instcombine -constmerge -reg2mem -instsimplify -lower-expect -callsite-splitting -globaldce -sroa -loop-fusion -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.9948979591836736,11.850993156433105,opt -strip -sroa -globaldce -coro-split -lower-constant-intrinsics -loop-versioning -lower-constant-intrinsics -load-store-vectorizer -cross-dso-cfi -dce -lower-widenable-condition -loop-reroll -barrier -dce -loop-distribute -cross-dso-cfi -always-inline -newgvn -strip-debug-declare -loop-reroll -loop-predication -jump-threading -prune-eh -memcpyopt -gvn-hoist -libcalls-shrinkwrap -elim-avail-extern -mldst-motion -loop-reroll -callsite-splitting -float2int -loop-guard-widening -correlated-propagation -lowerinvoke -strip-debug-declare -slp-vectorizer -sccp -instcombine -dce -barrier -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/ghostscript,0.977961552919373,340.80205249786377,opt -libcalls-shrinkwrap -loop-unroll-and-jam -constmerge -lowerinvoke -loweratomic -inject-tli-mappings -ipsccp -consthoist -instsimplify -indvars -loop-simplifycfg -loop-instsimplify -rewrite-statepoints-for-gc -rewrite-statepoints-for-gc -sccp -functionattrs -strip-debug-declare -coro-cleanup -lowerinvoke -die -cross-dso-cfi -loop-sink -loop-predication -loop-guard-widening -add-discriminators -loop-distribute -mergereturn -guard-widening -loop-simplify -instnamer -prune-eh -pgo-memop-opt -deadargelim -slp-vectorizer -called-value-propagation -lower-matrix-intrinsics -die -strip -jump-threading -inject-tli-mappings -newgvn -loop-predication -deadargelim -gvn -elim-avail-extern -dse -infer-address-spaces -instnamer -loweratomic -loop-data-prefetch -mem2reg -dse -instcombine -bdce -memcpyopt -instsimplify -dse -licm -loop-vectorize -jump-threading -sroa -loop-sink -argpromotion -loop-unroll -loop-fusion -coro-early -gvn-hoist -loop-sink -post-inline-ee-instrument -coro-early -early-cse-memssa -callsite-splitting -libcalls-shrinkwrap -loop-distribute -scalarizer -scalarizer -loop-load-elim -sink -instnamer -break-crit-edges -inject-tli-mappings -loop-versioning-licm -separate-const-offset-from-gep -lowerswitch -partially-inline-libcalls -memcpyopt -strip -strip-nondebug -loop-vectorize -canonicalize-aliases -bdce -mergereturn -instnamer -scalarizer -indvars -die -partial-inliner -slsr -coro-elide -load-store-vectorizer -post-inline-ee-instrument -strip-debug-declare -ipconstprop -rewrite-statepoints-for-gc -called-value-propagation -bdce -mergereturn -forceattrs -ipsccp -die -reassociate -tailcallelim -lower-widenable-condition -infer-address-spaces -break-crit-edges -insert-gcov-profiling -memcpyopt -callsite-splitting -die -inject-tli-mappings -hotcoldsplit -mergefunc -name-anon-globals -instcombine -inject-tli-mappings -instnamer -constmerge -post-inline-ee-instrument -sroa -constmerge -attributor -loop-data-prefetch -scalarizer -sccp -slp-vectorizer -scalarizer -forceattrs -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/ghostscript,0.9786958764238445,435.53417801856995,opt -load-store-vectorizer -loop-sink -jump-threading -flattencfg -memcpyopt -consthoist -ipsccp -correlated-propagation -sccp -die -die -loop-unroll -sink -slsr -canonicalize-aliases -loop-unroll -post-inline-ee-instrument -correlated-propagation -deadargelim -forceattrs -mem2reg -loop-instsimplify -globalsplit -mergeicmps -deadargelim -loop-deletion -correlated-propagation -constmerge -lower-expect -callsite-splitting -loweratomic -always-inline -strip-dead-prototypes -loop-distribute -dce -canonicalize-aliases -irce -coro-split -loop-vectorize -mergeicmps -coro-cleanup -lowerswitch -called-value-propagation -hotcoldsplit -globaldce -always-inline -slp-vectorizer -dce -coro-elide -argpromotion -mldst-motion -memcpyopt -forceattrs -rpo-functionattrs -loop-deletion -loop-unroll -mldst-motion -simplifycfg -lower-expect -slp-vectorizer -loop-load-elim -gvn -lower-guard-intrinsic -licm -irce -dse -loop-fusion -redundant-dbg-inst-elim -instcombine -mldst-motion -strip-debug-declare -add-discriminators -gvn -div-rem-pairs -instsimplify -tailcallelim -loop-reduce -loop-unroll-and-jam -inferattrs -break-crit-edges -coro-cleanup -ipconstprop -lower-matrix-intrinsics -ipsccp -loop-interchange -name-anon-globals -break-crit-edges -lower-expect -tailcallelim -rewrite-statepoints-for-gc -die -newgvn -guard-widening -break-crit-edges -loop-unroll -hotcoldsplit -loop-unroll -lcssa -cross-dso-cfi -loop-predication -loop-deletion -libcalls-shrinkwrap -forceattrs -called-value-propagation -die -barrier -die -attributor -sink -loop-versioning -bdce -pgo-memop-opt -loop-versioning-licm -inferattrs -loop-distribute -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/ghostscript,0.9787745539421807,293.76403188705444,opt -partially-inline-libcalls -newgvn -tailcallelim -sroa -instcombine -simplifycfg -slp-vectorizer input.bc -o output.bc +benchmark://cbench-v1/ghostscript,0.9810343471077269,331.94740438461304,opt -newgvn -partially-inline-libcalls -nary-reassociate -pgo-memop-opt -attributor -strip -loop-distribute -loop-fusion -reg2mem -redundant-dbg-inst-elim -loop-load-elim -loop-sink -pgo-memop-opt -loop-deletion -cross-dso-cfi -jump-threading -argpromotion -reassociate -inferattrs -slp-vectorizer -barrier -lower-widenable-condition -correlated-propagation -newgvn -loweratomic -ipconstprop -separate-const-offset-from-gep -consthoist -loop-fusion -loop-unroll -loop-idiom -gvn -lower-guard-intrinsic -load-store-vectorizer -name-anon-globals -loop-vectorize -ipconstprop -globalopt -reg2mem -loop-versioning -coro-cleanup -insert-gcov-profiling -separate-const-offset-from-gep -loop-unroll -forceattrs -sroa -strip -div-rem-pairs -mergereturn -rewrite-statepoints-for-gc -reg2mem -loop-data-prefetch -loop-unswitch -mem2reg -nary-reassociate -lower-expect -lower-matrix-intrinsics -libcalls-shrinkwrap -memcpyopt -sccp -loop-instsimplify -forceattrs -loop-guard-widening -sancov -loop-unroll-and-jam -alignment-from-assumptions -loop-unroll-and-jam -simple-loop-unswitch -slsr -sink -loop-unswitch -coro-cleanup -strip -licm -deadargelim -tailcallelim -argpromotion -rewrite-statepoints-for-gc -aggressive-instcombine -licm -loop-instsimplify -gvn -partial-inliner -inject-tli-mappings -loop-data-prefetch -tailcallelim -newgvn -always-inline -lower-widenable-condition -name-anon-globals -loop-data-prefetch -callsite-splitting -instsimplify -ipconstprop -instcombine -loop-unroll-and-jam -coro-split -strip-debug-declare -constmerge -newgvn -slp-vectorizer -add-discriminators -coro-elide -inject-tli-mappings -sroa -libcalls-shrinkwrap -float2int -inferattrs -guard-widening -indvars -loop-reduce -insert-gcov-profiling -speculative-execution -insert-gcov-profiling -cross-dso-cfi -slp-vectorizer -gvn-hoist -partial-inliner -prune-eh -indvars -inject-tli-mappings -coro-elide -loop-guard-widening -irce -constmerge -loop-vectorize -partially-inline-libcalls -functionattrs -infer-address-spaces -deadargelim -jump-threading -globalopt -lower-matrix-intrinsics -instcombine input.bc -o output.bc +benchmark://cbench-v1/ghostscript,0.9854839978669648,299.6495168209076,opt -loop-interchange -attributor -loop-versioning-licm -memcpyopt -coro-elide -add-discriminators -loop-reroll -flattencfg -simple-loop-unswitch -called-value-propagation -sancov -infer-address-spaces -ipsccp -attributor -strip-dead-prototypes -bdce -adce -inject-tli-mappings -attributor -strip-dead-prototypes -simple-loop-unswitch -strip -coro-elide -globalsplit -loop-idiom -guard-widening -dce -div-rem-pairs -redundant-dbg-inst-elim -die -loop-simplify -indvars -loop-simplify -tailcallelim -name-anon-globals -bdce -mergefunc -mem2reg -slsr -slsr -indvars -name-anon-globals -coro-split -newgvn -post-inline-ee-instrument -sccp -cross-dso-cfi -correlated-propagation -irce -gvn -load-store-vectorizer -instcombine -attributor -memcpyopt -instnamer -loop-load-elim -separate-const-offset-from-gep -strip-dead-prototypes -correlated-propagation -globaldce -alignment-from-assumptions -gvn-hoist -instnamer -bdce -globalsplit -argpromotion -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/ghostscript,0.9911312952942102,297.16990852355957,opt -sroa -instsimplify -strip-dead-prototypes -loop-unroll -guard-widening -float2int -pgo-memop-opt -lowerswitch -jump-threading -dce -strip -loop-sink -loop-predication -strip-nondebug -ee-instrument -sink -globalopt -float2int -lowerswitch -pgo-memop-opt -loop-distribute -coro-split -inferattrs -gvn -hotcoldsplit -loop-unroll -irce -instnamer -lcssa -constprop -separate-const-offset-from-gep -slsr -callsite-splitting -bdce -sancov -consthoist -div-rem-pairs -bdce -dse -strip-debug-declare -mergereturn -inject-tli-mappings -load-store-vectorizer -sink -adce -partially-inline-libcalls -indvars -globalsplit -called-value-propagation -globalsplit -mergereturn -pgo-memop-opt -lower-matrix-intrinsics -always-inline -post-inline-ee-instrument -licm -speculative-execution -indvars -coro-cleanup -irce -loop-fusion -barrier -mergefunc -loop-sink -jump-threading -alignment-from-assumptions -loop-interchange -partially-inline-libcalls -loop-reroll -memcpyopt -sink -strip-dead-prototypes -libcalls-shrinkwrap -name-anon-globals -reassociate -speculative-execution -mergereturn -strip-debug-declare -mldst-motion -rewrite-statepoints-for-gc -loop-reroll -add-discriminators -argpromotion -scalarizer -post-inline-ee-instrument -always-inline -strip-debug-declare -tailcallelim -loop-reduce -separate-const-offset-from-gep -loop-unroll-and-jam -called-value-propagation -flattencfg -canonicalize-aliases -loop-predication -separate-const-offset-from-gep -dse -add-discriminators -ee-instrument -attributor -lower-expect -add-discriminators -break-crit-edges -loop-predication -lowerswitch -forceattrs -loop-versioning -loop-versioning-licm -memcpyopt -reassociate -functionattrs -libcalls-shrinkwrap -lowerswitch -partially-inline-libcalls -alignment-from-assumptions -loop-load-elim -lower-matrix-intrinsics -infer-address-spaces -loop-distribute -separate-const-offset-from-gep -insert-gcov-profiling -elim-avail-extern -div-rem-pairs -canonicalize-aliases -ee-instrument -lower-constant-intrinsics -gvn -separate-const-offset-from-gep -alignment-from-assumptions -elim-avail-extern -prune-eh -jump-threading -alignment-from-assumptions -coro-early -instcombine -jump-threading -name-anon-globals -lower-expect -ipconstprop -newgvn -loop-interchange -name-anon-globals -sccp -newgvn -name-anon-globals -flattencfg -sroa -dce -constmerge -lowerswitch -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/ghostscript,0.9913017632506052,329.5422034263611,opt -strip-dead-prototypes -lower-widenable-condition -loop-instsimplify -name-anon-globals -canonicalize-aliases -simplifycfg -loop-predication -canonicalize-aliases -partially-inline-libcalls -loop-predication -loop-interchange -loop-vectorize -pgo-memop-opt -adce -loop-sink -scalarizer -called-value-propagation -lower-constant-intrinsics -loop-unswitch -gvn -globalopt -sink -loop-idiom -pgo-memop-opt -loop-sink -flattencfg -rpo-functionattrs -loop-simplify -loop-idiom -loop-versioning-licm -load-store-vectorizer -coro-early -inferattrs -loop-versioning-licm -die -redundant-dbg-inst-elim -float2int -libcalls-shrinkwrap -loop-reduce -simplifycfg -deadargelim -slp-vectorizer -canonicalize-aliases -name-anon-globals -mldst-motion -rewrite-statepoints-for-gc -aggressive-instcombine -lower-matrix-intrinsics -inferattrs -loop-reduce -redundant-dbg-inst-elim -loop-load-elim -simplifycfg -alignment-from-assumptions -mergereturn -irce -coro-early -forceattrs -slsr -lower-widenable-condition -irce -div-rem-pairs -barrier -gvn -tailcallelim -globaldce -ipconstprop -instcombine -mldst-motion -simple-loop-unswitch -jump-threading -globalopt -globalopt -rewrite-statepoints-for-gc -scalarizer -simple-loop-unswitch -nary-reassociate -loop-distribute -loop-predication -coro-early -lower-widenable-condition -lower-widenable-condition -loop-fusion -loop-rotate -loop-load-elim -lower-expect -mldst-motion -slp-vectorizer -break-crit-edges -guard-widening -coro-early -inferattrs -newgvn -rewrite-statepoints-for-gc -licm -slp-vectorizer -gvn -strip-dead-prototypes -simplifycfg -sink -reassociate -loop-reduce -mem2reg -early-cse-memssa -loop-load-elim -sroa -add-discriminators -indvars -alignment-from-assumptions -attributor -separate-const-offset-from-gep -ee-instrument -lower-widenable-condition -globalopt -loop-sink -pgo-memop-opt -called-value-propagation -sccp -hotcoldsplit -loop-load-elim -mergereturn -pgo-memop-opt -instcombine -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/ghostscript,0.9960224143507793,278.31543612480164,opt -reassociate -loop-deletion -dse -coro-cleanup -reg2mem -loop-predication -ipconstprop -cross-dso-cfi -loop-unroll -dce -lower-matrix-intrinsics -bdce -lcssa -loop-unswitch -deadargelim -coro-early -always-inline -memcpyopt -loop-idiom -barrier -dce -add-discriminators -loop-reduce -bdce -sccp -lower-matrix-intrinsics -globalopt -consthoist -sroa -sink -reassociate -aggressive-instcombine -insert-gcov-profiling -jump-threading -coro-elide -div-rem-pairs -strip-dead-prototypes -elim-avail-extern -loop-interchange -float2int -coro-early -loop-distribute -licm -coro-elide -deadargelim -licm -load-store-vectorizer -hotcoldsplit -attributor -div-rem-pairs -called-value-propagation -loop-rotate -globalsplit -instcombine -slsr -strip-nondebug -coro-elide -prune-eh -argpromotion -instsimplify -loop-simplifycfg -callsite-splitting -guard-widening -attributor -loop-interchange -loweratomic -loop-reroll -loop-idiom -coro-cleanup -sccp -libcalls-shrinkwrap -globalsplit -sccp -jump-threading -mergefunc -simplifycfg -mergeicmps -nary-reassociate -lower-guard-intrinsic -lcssa -cross-dso-cfi -early-cse-memssa -infer-address-spaces -bdce -slp-vectorizer input.bc -o output.bc +benchmark://cbench-v1/ghostscript,1.0014642760357022,562.3493282794952,opt -jump-threading -flattencfg -mergereturn -die -sroa -loop-predication -reassociate -loop-instsimplify -gvn -flattencfg -bdce -simplifycfg -insert-gcov-profiling -loweratomic -lowerinvoke -loop-guard-widening -loop-idiom -called-value-propagation -coro-cleanup -tailcallelim -partially-inline-libcalls -ipconstprop -elim-avail-extern -hotcoldsplit -loop-idiom -mergereturn -attributor -loop-sink -die -licm -lower-constant-intrinsics -alignment-from-assumptions -instsimplify -canonicalize-aliases -loop-versioning -loop-versioning-licm -loop-distribute -reassociate -coro-cleanup -lower-guard-intrinsic -loop-data-prefetch -mldst-motion -adce -callsite-splitting -tailcallelim -loop-idiom -coro-split -functionattrs -mldst-motion -flattencfg -deadargelim -rpo-functionattrs -lowerswitch -loop-simplify -reg2mem -dse -cross-dso-cfi -gvn-hoist -gvn-hoist -memcpyopt -libcalls-shrinkwrap -hotcoldsplit -loop-reroll -coro-cleanup -aggressive-instcombine -gvn-hoist -loop-idiom -slp-vectorizer -redundant-dbg-inst-elim -globalsplit -loop-unroll -loop-idiom -loop-instsimplify -loop-data-prefetch -ipconstprop -sccp -loop-instsimplify -post-inline-ee-instrument -sroa -loop-simplify -loop-simplify -irce -simplifycfg -lcssa -loop-fusion -ipsccp -loop-versioning-licm -partially-inline-libcalls -partially-inline-libcalls -argpromotion -float2int -newgvn -div-rem-pairs -instnamer -coro-split -lcssa -lower-widenable-condition -indvars -jump-threading -scalarizer -float2int -loop-instsimplify -correlated-propagation -barrier -hotcoldsplit -load-store-vectorizer -instcombine -irce -elim-avail-extern -loop-versioning-licm -correlated-propagation -redundant-dbg-inst-elim -coro-split -sancov -instcombine -constmerge -float2int -globaldce -die -redundant-dbg-inst-elim -lower-matrix-intrinsics -argpromotion -lower-constant-intrinsics -loop-fusion -div-rem-pairs -insert-gcov-profiling -insert-gcov-profiling -strip-debug-declare -loop-deletion -cross-dso-cfi -loop-unroll-and-jam -gvn -ipconstprop -loop-versioning -loop-interchange -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/ghostscript,1.0049654256016645,283.5457594394684,opt -lowerinvoke -scalarizer -adce -coro-split -early-cse-memssa -post-inline-ee-instrument -flattencfg -loop-instsimplify -loweratomic -memcpyopt -elim-avail-extern -sroa -loop-fusion -loop-sink -sancov -speculative-execution -die -newgvn -mergefunc -loop-data-prefetch -jump-threading -loop-predication -coro-elide -coro-split -redundant-dbg-inst-elim -mem2reg -redundant-dbg-inst-elim -loop-reduce -coro-elide -jump-threading -sancov -dce -constmerge -nary-reassociate -attributor -instnamer -lower-expect -alignment-from-assumptions -loop-simplify -simple-loop-unswitch -sccp -instcombine -canonicalize-aliases -loop-versioning -simplifycfg -slsr -loop-distribute -instcombine -loop-simplify -loop-guard-widening -insert-gcov-profiling -jump-threading -prune-eh -constmerge -infer-address-spaces -ee-instrument -loop-load-elim -div-rem-pairs -lower-constant-intrinsics -sccp -coro-split -mem2reg -lcssa -jump-threading -load-store-vectorizer -early-cse-memssa -strip-dead-prototypes -dse -consthoist -irce -add-discriminators -lowerinvoke -loop-fusion -tailcallelim -loop-interchange -sroa -mem2reg -adce -guard-widening -partially-inline-libcalls -loop-fusion -lower-guard-intrinsic -add-discriminators -post-inline-ee-instrument -slp-vectorizer -partially-inline-libcalls -rpo-functionattrs -cross-dso-cfi -strip -lower-matrix-intrinsics -separate-const-offset-from-gep -gvn-hoist -lower-widenable-condition -instcombine input.bc -o output.bc +benchmark://cbench-v1/gsm,1.0170567729083666,23.498672485351562,opt -licm -inline -attributor -loop-load-elim -globalsplit -forceattrs -gvn -coro-early -add-discriminators -coro-early -early-cse-memssa -loop-unroll -argpromotion -libcalls-shrinkwrap -dse -div-rem-pairs -jump-threading -loop-deletion -lower-expect -coro-cleanup -aggressive-instcombine -mldst-motion -nary-reassociate -dce -sroa -instnamer -loop-reduce -guard-widening -post-inline-ee-instrument -guard-widening -loop-unroll-and-jam -loop-idiom -globalopt -irce -lowerinvoke -cross-dso-cfi -hotcoldsplit -lowerinvoke -speculative-execution -loop-predication -strip -deadargelim -functionattrs -deadargelim -speculative-execution -instcombine -called-value-propagation -simplifycfg -loop-reroll -float2int -deadargelim -dse -dce -flattencfg -bdce -gvn -mem2reg -lower-matrix-intrinsics -forceattrs -callsite-splitting -loop-predication -inject-tli-mappings -strip-debug-declare -coro-early -lower-widenable-condition -gvn -load-store-vectorizer -loop-simplifycfg -forceattrs -deadargelim -called-value-propagation -canonicalize-aliases -prune-eh -argpromotion -loop-deletion -simplifycfg -indvars -dce -inferattrs -loop-simplify -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/gsm,1.0220368525896417,15.433346271514893,opt -constmerge -break-crit-edges -inline -mergefunc -loop-reduce -lower-expect -ipconstprop -guard-widening -break-crit-edges -adce -indvars -loop-predication -simplifycfg -mergefunc -memcpyopt -insert-gcov-profiling -separate-const-offset-from-gep -functionattrs -bdce -float2int -tailcallelim -partial-inliner -lower-matrix-intrinsics -loop-unswitch -mem2reg -strip -name-anon-globals -instcombine -redundant-dbg-inst-elim -instnamer -loop-deletion -prune-eh -called-value-propagation -simple-loop-unswitch -strip -loop-unswitch -lower-constant-intrinsics -pgo-memop-opt -consthoist -loweratomic -lower-widenable-condition -loop-versioning -loop-unroll-and-jam -strip-dead-prototypes -loop-instsimplify -gvn-hoist -rewrite-statepoints-for-gc -early-cse-memssa -lowerinvoke -licm -instsimplify -add-discriminators -slsr -lower-matrix-intrinsics -inferattrs -globalsplit -ipconstprop -instcombine -loop-load-elim -hotcoldsplit -correlated-propagation -dce -insert-gcov-profiling -rewrite-statepoints-for-gc -irce -loop-sink -inject-tli-mappings -lower-widenable-condition -strip-nondebug -always-inline -loop-data-prefetch -loop-data-prefetch -name-anon-globals -strip -dce -loop-interchange -constmerge -loop-instsimplify -infer-address-spaces -cross-dso-cfi -licm -irce -barrier -coro-cleanup -add-discriminators -loop-simplify -coro-elide -rewrite-statepoints-for-gc -reg2mem -adce -loop-data-prefetch -break-crit-edges -infer-address-spaces -licm -loop-predication -ipconstprop -dce -sroa -adce -strip -lower-widenable-condition -loop-rotate -lcssa -mergefunc -pgo-memop-opt -sancov -loop-rotate -consthoist -aggressive-instcombine -loop-distribute -strip -loop-distribute -pgo-memop-opt -loweratomic -sancov -irce -lower-expect -adce -loop-idiom -irce -die -gvn -loop-instsimplify -loop-unroll-and-jam -indvars -functionattrs -slsr -mldst-motion -dce -ipconstprop -inject-tli-mappings -correlated-propagation -reg2mem -loop-idiom -loop-interchange -sancov -sancov -argpromotion -globalsplit -memcpyopt -rpo-functionattrs -loop-guard-widening -lower-guard-intrinsic -loop-unroll-and-jam -insert-gcov-profiling -attributor -libcalls-shrinkwrap -slsr -loop-idiom -redundant-dbg-inst-elim -die -cross-dso-cfi -argpromotion -load-store-vectorizer -gvn-hoist -loop-unroll -reassociate -rpo-functionattrs -loop-fusion -loop-reroll -lowerswitch -mergereturn -loop-deletion -add-discriminators -correlated-propagation -lower-guard-intrinsic -strip-nondebug -coro-cleanup -loop-data-prefetch -insert-gcov-profiling -loop-unroll -guard-widening -sroa -simplifycfg -constprop -die -load-store-vectorizer -separate-const-offset-from-gep -tailcallelim -loop-deletion -always-inline -float2int -coro-cleanup -libcalls-shrinkwrap -sroa -elim-avail-extern -libcalls-shrinkwrap -separate-const-offset-from-gep -lower-guard-intrinsic -canonicalize-aliases -slp-vectorizer input.bc -o output.bc +benchmark://cbench-v1/gsm,1.027390438247013,14.184420108795166,opt -newgvn -lower-constant-intrinsics -inline -constprop -functionattrs -inferattrs -inject-tli-mappings -reg2mem -die -sroa -loop-idiom -loop-unroll-and-jam -lcssa -loop-deletion -loop-load-elim -constmerge -mergeicmps -strip-debug-declare -consthoist -inject-tli-mappings -dce -cross-dso-cfi -instcombine -mergereturn -libcalls-shrinkwrap -redundant-dbg-inst-elim -simplifycfg -constprop -aggressive-instcombine -loop-guard-widening -dce -correlated-propagation -gvn -always-inline -guard-widening -hotcoldsplit -add-discriminators -mldst-motion -globalopt -instsimplify -attributor -prune-eh -mem2reg -guard-widening -argpromotion -consthoist -sccp -always-inline -loop-unroll-and-jam -memcpyopt -infer-address-spaces -lcssa -ee-instrument -lower-widenable-condition -speculative-execution -canonicalize-aliases -lower-expect -guard-widening -reassociate -argpromotion -libcalls-shrinkwrap -loop-versioning-licm -instcombine -loop-interchange -gvn -reassociate -globaldce -div-rem-pairs -early-cse-memssa -instsimplify -tailcallelim -loop-versioning-licm -mldst-motion -alignment-from-assumptions -sancov -loop-instsimplify -speculative-execution -loop-simplify -lcssa -gvn -gvn-hoist -memcpyopt -loop-versioning-licm -inject-tli-mappings -partial-inliner -slsr -mem2reg -always-inline -name-anon-globals -rpo-functionattrs -callsite-splitting -loop-reroll -loop-idiom -strip -sink -gvn -strip-nondebug -loop-guard-widening -loop-distribute -early-cse-memssa -newgvn -correlated-propagation -mem2reg -instcombine -loop-data-prefetch -dce -lowerswitch -loop-versioning-licm -loop-vectorize -mergefunc -sroa -loop-idiom -loop-interchange -speculative-execution -loop-deletion -loop-vectorize -add-discriminators -loop-unroll-and-jam -instnamer -gvn -instsimplify -mergefunc -div-rem-pairs -instsimplify -nary-reassociate -add-discriminators -dce -constprop -gvn-hoist -loop-simplify -loop-unroll-and-jam -lower-guard-intrinsic -name-anon-globals -sroa -lowerswitch -strip-debug-declare -deadargelim -memcpyopt -die -separate-const-offset-from-gep -early-cse-memssa -post-inline-ee-instrument -rewrite-statepoints-for-gc -mergereturn -coro-split -instcombine -guard-widening -prune-eh -nary-reassociate -mldst-motion -ee-instrument -slp-vectorizer -loop-instsimplify -infer-address-spaces -post-inline-ee-instrument -redundant-dbg-inst-elim -loop-interchange -libcalls-shrinkwrap -coro-early -loop-reduce -irce -indvars -loop-interchange -early-cse-memssa -adce -prune-eh -load-store-vectorizer -indvars -coro-split -inject-tli-mappings -mldst-motion -adce -slp-vectorizer -loop-simplify -loweratomic -dce -called-value-propagation -instnamer -float2int -bdce -simple-loop-unswitch -ipsccp input.bc -o output.bc +benchmark://cbench-v1/gsm,1.0277639442231072,15.189532041549683,opt -argpromotion -mldst-motion -globaldce -globaldce -alignment-from-assumptions -sink -lower-widenable-condition -argpromotion -loop-versioning -lcssa -instcombine -argpromotion -loop-predication -loop-distribute -tailcallelim -lower-matrix-intrinsics -redundant-dbg-inst-elim -ipsccp -deadargelim -loweratomic -loop-unroll-and-jam -loop-rotate -loop-vectorize -reassociate -add-discriminators -loop-versioning -loop-versioning -slsr -inferattrs -instnamer -strip-debug-declare -aggressive-instcombine -coro-split -mergereturn -loop-sink -add-discriminators -bdce -ipsccp -forceattrs -globalopt -strip-dead-prototypes -inject-tli-mappings -early-cse-memssa -lower-widenable-condition -canonicalize-aliases -lower-matrix-intrinsics -sroa -slp-vectorizer -insert-gcov-profiling -mem2reg -mergeicmps -redundant-dbg-inst-elim -add-discriminators -reg2mem -strip-debug-declare -lower-expect -loop-deletion -redundant-dbg-inst-elim -break-crit-edges -ipsccp -redundant-dbg-inst-elim -jump-threading -mergereturn -coro-early -loop-fusion -indvars -float2int -strip-dead-prototypes -bdce -loop-versioning -attributor -inline -loop-instsimplify -mldst-motion -called-value-propagation -die -lower-guard-intrinsic -globalsplit -scalarizer -barrier -loop-fusion -inferattrs -instcombine -sroa -strip-dead-prototypes -reassociate -lower-widenable-condition -mergereturn -loop-interchange -loop-sink -newgvn -speculative-execution -reg2mem -aggressive-instcombine -argpromotion -loop-idiom -inferattrs -elim-avail-extern -load-store-vectorizer -dse -inject-tli-mappings -loop-reroll -rewrite-statepoints-for-gc -irce -coro-split -dse -instcombine -irce -inline -loop-distribute -elim-avail-extern -loop-versioning -load-store-vectorizer -always-inline -ipconstprop -called-value-propagation -strip-dead-prototypes -rpo-functionattrs -loop-load-elim -constmerge -partially-inline-libcalls -loop-unswitch -pgo-memop-opt -sroa -lower-matrix-intrinsics -loop-simplify -bdce -bdce -name-anon-globals -mem2reg -break-crit-edges -lower-guard-intrinsic -loop-fusion -rpo-functionattrs -strip-nondebug -sroa -sink -instsimplify -loop-guard-widening -coro-cleanup -speculative-execution -alignment-from-assumptions -simplifycfg -instsimplify -argpromotion -constprop -consthoist -memcpyopt -ipsccp -coro-elide -dse -lowerinvoke -sroa -lower-guard-intrinsic -slp-vectorizer -argpromotion -alignment-from-assumptions -elim-avail-extern -coro-cleanup -constprop -constprop -alignment-from-assumptions -loop-unswitch -sccp -speculative-execution -post-inline-ee-instrument -lower-expect -lower-expect -instsimplify -lower-constant-intrinsics -lower-constant-intrinsics -mldst-motion -simplifycfg -loop-simplify -sancov -loop-distribute -strip-dead-prototypes -load-store-vectorizer -consthoist -called-value-propagation -post-inline-ee-instrument -mergereturn -memcpyopt -irce -strip-dead-prototypes -lower-guard-intrinsic -strip-dead-prototypes -div-rem-pairs -strip-debug-declare -alignment-from-assumptions -loop-idiom -lower-guard-intrinsic -loop-idiom -aggressive-instcombine -infer-address-spaces -loop-sink -hotcoldsplit -coro-split -lower-widenable-condition -loop-instsimplify -newgvn -argpromotion -partial-inliner -early-cse-memssa -pgo-memop-opt -reg2mem -die -loop-versioning-licm -post-inline-ee-instrument -argpromotion -tailcallelim -loop-unroll-and-jam -jump-threading -rewrite-statepoints-for-gc -guard-widening -instnamer -inferattrs -nary-reassociate -sroa -argpromotion -deadargelim -early-cse-memssa -redundant-dbg-inst-elim -functionattrs -ee-instrument -ipconstprop -ee-instrument -dse -post-inline-ee-instrument -tailcallelim -reg2mem -loop-fusion -sccp -die -sroa -loop-deletion -functionattrs -sccp -rpo-functionattrs -coro-early -constprop -loop-simplify -instcombine -ipconstprop -loop-vectorize -mergeicmps -sroa -loweratomic -globalsplit -libcalls-shrinkwrap -always-inline -alignment-from-assumptions -speculative-execution -rpo-functionattrs -dce -globaldce -libcalls-shrinkwrap -sroa -constmerge -lower-expect -ipsccp -loop-versioning-licm -insert-gcov-profiling -always-inline -dce -lower-matrix-intrinsics -loop-reroll -slp-vectorizer -mldst-motion -div-rem-pairs -gvn-hoist -mldst-motion -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/gsm,1.028261952191235,14.138127088546753,opt -add-discriminators -lower-matrix-intrinsics -coro-elide -loop-guard-widening -alignment-from-assumptions -canonicalize-aliases -dse -constprop -loop-data-prefetch -always-inline -loop-simplify -ee-instrument -loop-simplifycfg -ipconstprop -separate-const-offset-from-gep -loop-interchange -inject-tli-mappings -reassociate -loop-unroll -ipsccp -inferattrs -gvn-hoist -ipconstprop -mergeicmps -mldst-motion -indvars -inject-tli-mappings -early-cse-memssa -simple-loop-unswitch -early-cse-memssa -float2int -loop-vectorize -loop-simplify -ipconstprop -loop-reduce -indvars -loop-instsimplify -aggressive-instcombine -slsr -inject-tli-mappings -sroa -slp-vectorizer -flattencfg -gvn -attributor -loop-guard-widening -separate-const-offset-from-gep -newgvn -float2int -sancov -ee-instrument -called-value-propagation -instsimplify -coro-split -functionattrs -insert-gcov-profiling -separate-const-offset-from-gep -div-rem-pairs -loop-load-elim -tailcallelim -irce -simple-loop-unswitch -memcpyopt -slsr -loop-unroll -instcombine -name-anon-globals -early-cse-memssa -argpromotion -deadargelim -loop-deletion -lower-guard-intrinsic -separate-const-offset-from-gep -jump-threading -inject-tli-mappings -adce -mem2reg -called-value-propagation -gvn-hoist -nary-reassociate -attributor -loop-fusion -post-inline-ee-instrument -dse -adce -redundant-dbg-inst-elim -insert-gcov-profiling -break-crit-edges -post-inline-ee-instrument -lcssa -slsr -ee-instrument -gvn -bdce -lowerinvoke -sink -inferattrs -instcombine -add-discriminators -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/gsm,1.0292579681274896,14.405534267425537,opt -deadargelim -insert-gcov-profiling -loweratomic -inferattrs -bdce -forceattrs -lower-constant-intrinsics -instcombine -callsite-splitting -prune-eh -lower-expect -speculative-execution -ipsccp -strip-debug-declare -loop-idiom -loop-unswitch -rpo-functionattrs -loop-fusion -redundant-dbg-inst-elim -loop-reduce -libcalls-shrinkwrap -newgvn -flattencfg -loop-instsimplify -rpo-functionattrs -early-cse-memssa -loop-guard-widening -prune-eh -instnamer -coro-early -loop-versioning-licm -forceattrs -dse -add-discriminators -lcssa -flattencfg -called-value-propagation -loop-data-prefetch -loop-unroll-and-jam -instnamer -loop-idiom -globalopt -lower-matrix-intrinsics -cross-dso-cfi -loop-unroll-and-jam -gvn -ee-instrument -speculative-execution -loop-unroll-and-jam -slsr -loop-load-elim -cross-dso-cfi -div-rem-pairs -loop-interchange -sroa -instsimplify -loop-deletion -libcalls-shrinkwrap -dse -loop-distribute -adce -instnamer -insert-gcov-profiling -mergereturn -cross-dso-cfi -loweratomic -mergeicmps -ipconstprop -always-inline -instsimplify -loop-reduce -functionattrs -lower-guard-intrinsic -loop-data-prefetch -mem2reg -jump-threading -loop-simplify -ipsccp -reassociate -separate-const-offset-from-gep -licm -simplifycfg -jump-threading -loop-idiom -loop-deletion -callsite-splitting -instcombine -lower-constant-intrinsics -ipsccp -strip-dead-prototypes -constprop -ipconstprop -partial-inliner -flattencfg -lower-expect -load-store-vectorizer -sancov -loop-simplify -ipconstprop -globalsplit -lower-widenable-condition -flattencfg -irce -instcombine -loweratomic -strip-dead-prototypes -flattencfg -dse -gvn-hoist -mem2reg -rewrite-statepoints-for-gc -ee-instrument -partially-inline-libcalls -gvn -break-crit-edges -rpo-functionattrs -name-anon-globals -coro-early -scalarizer -dse -loop-simplify -always-inline -always-inline -lcssa -bdce -always-inline -loop-interchange -slsr -elim-avail-extern -instnamer -nary-reassociate -forceattrs -name-anon-globals -constprop -correlated-propagation -sccp -aggressive-instcombine -redundant-dbg-inst-elim -reg2mem -loop-versioning-licm -break-crit-edges -ipsccp -inject-tli-mappings -elim-avail-extern -mergefunc -libcalls-shrinkwrap -speculative-execution -alignment-from-assumptions -coro-elide -strip-dead-prototypes -insert-gcov-profiling -lower-guard-intrinsic -infer-address-spaces -coro-split -lower-matrix-intrinsics -insert-gcov-profiling -alignment-from-assumptions -lower-matrix-intrinsics -break-crit-edges -rewrite-statepoints-for-gc -strip-dead-prototypes -globaldce -dse -loop-data-prefetch -reg2mem -ipconstprop -partially-inline-libcalls -indvars -argpromotion -argpromotion -constprop -attributor -strip-nondebug -strip -lower-expect -libcalls-shrinkwrap -guard-widening -loop-sink -simple-loop-unswitch -slsr -separate-const-offset-from-gep -loweratomic -coro-elide -rewrite-statepoints-for-gc -loop-versioning -loop-data-prefetch -reg2mem -loop-fusion -inline -infer-address-spaces -loop-sink -memcpyopt -strip -gvn -instcombine -loop-load-elim -instnamer -strip-dead-prototypes -adce -lower-matrix-intrinsics -loop-guard-widening -lower-matrix-intrinsics -partially-inline-libcalls -tailcallelim -correlated-propagation -aggressive-instcombine -deadargelim -loop-interchange -globalsplit -strip-nondebug -aggressive-instcombine -mem2reg -globalopt -dse -correlated-propagation -dce -mergeicmps -instsimplify -forceattrs -callsite-splitting -scalarizer -redundant-dbg-inst-elim -called-value-propagation -name-anon-globals -separate-const-offset-from-gep -loop-versioning -loop-sink -loop-simplify -add-discriminators -ee-instrument -loop-versioning -lower-widenable-condition -instnamer -slp-vectorizer -loop-load-elim -loop-unroll -loop-versioning-licm -loop-distribute -sancov -loop-predication -name-anon-globals -loop-guard-widening -bdce -guard-widening -instsimplify -constprop -loop-vectorize -canonicalize-aliases -prune-eh -coro-early -loop-versioning-licm -loop-interchange -loop-guard-widening -loop-load-elim -infer-address-spaces -libcalls-shrinkwrap -globalopt -loop-reroll -name-anon-globals -lowerswitch -simplifycfg -adce -gvn -ipsccp -strip -forceattrs -instcombine -sccp -loop-simplifycfg -dce -tailcallelim -loop-data-prefetch -gvn -slsr -mergereturn -strip-debug-declare -alignment-from-assumptions -globaldce -lcssa -loop-vectorize -loop-load-elim -sccp -loop-data-prefetch -dse -loop-vectorize -loop-fusion -loop-data-prefetch -globalsplit -gvn-hoist -loop-versioning-licm -loop-interchange -mergefunc -deadargelim -memcpyopt -rpo-functionattrs -aggressive-instcombine -lower-guard-intrinsic -load-store-vectorizer -loop-load-elim -rewrite-statepoints-for-gc -load-store-vectorizer -aggressive-instcombine -die -lower-expect -mergefunc -strip-dead-prototypes -attributor -insert-gcov-profiling -loop-versioning-licm -float2int -infer-address-spaces -loop-instsimplify -slsr -loop-versioning -globalsplit -lcssa -ipconstprop -partially-inline-libcalls -alignment-from-assumptions -lower-guard-intrinsic -coro-elide -loop-sink -called-value-propagation -forceattrs -partial-inliner -loop-rotate input.bc -o output.bc +benchmark://cbench-v1/gsm,1.0334910358565736,14.459441900253296,opt -hotcoldsplit -scalarizer -instsimplify -loop-instsimplify -coro-split -aggressive-instcombine -loop-idiom -loop-predication -instsimplify -partially-inline-libcalls -canonicalize-aliases -inferattrs -loop-simplify -correlated-propagation -simple-loop-unswitch -bdce -coro-split -sccp -float2int -simplifycfg -mldst-motion -loop-simplify -float2int -sroa -globaldce -instnamer -slp-vectorizer -loop-vectorize -simple-loop-unswitch -guard-widening -coro-early -div-rem-pairs -loop-simplifycfg -lower-widenable-condition -attributor -newgvn -loop-interchange -globalsplit -lowerinvoke -canonicalize-aliases -dse -reassociate -div-rem-pairs -mldst-motion -mldst-motion -canonicalize-aliases -lower-widenable-condition -loop-interchange -sancov -infer-address-spaces -infer-address-spaces -loweratomic -tailcallelim -loop-load-elim -loop-simplify -mergefunc -alignment-from-assumptions -mergefunc -speculative-execution -aggressive-instcombine -loop-reroll -ee-instrument -bdce -float2int -gvn-hoist -argpromotion -coro-split -newgvn -slsr -ipconstprop -globalsplit -dse -jump-threading -instsimplify -newgvn -ee-instrument -gvn-hoist -gvn-hoist -loop-predication -post-inline-ee-instrument -instcombine -dse input.bc -o output.bc +benchmark://cbench-v1/gsm,1.0352340637450197,15.297012329101562,opt -insert-gcov-profiling -lower-matrix-intrinsics -loop-instsimplify -gvn -memcpyopt -lower-guard-intrinsic -called-value-propagation -loop-predication -lower-guard-intrinsic -loop-simplify -called-value-propagation -slp-vectorizer -lower-constant-intrinsics -speculative-execution -barrier -loop-sink -name-anon-globals -gvn-hoist -deadargelim -lowerinvoke -deadargelim -loop-instsimplify -loop-instsimplify -guard-widening -strip-debug-declare -hotcoldsplit -adce -attributor -die -insert-gcov-profiling -infer-address-spaces -die -loop-versioning -loop-interchange -slsr -instnamer -correlated-propagation -coro-elide -lower-guard-intrinsic -lowerswitch -loop-unroll -libcalls-shrinkwrap -loop-predication -loop-idiom -simplifycfg -early-cse-memssa -loop-reroll -lower-expect -break-crit-edges -loop-load-elim -gvn-hoist -ipsccp -sancov -loop-unswitch -canonicalize-aliases -early-cse-memssa -inferattrs -strip-nondebug -newgvn -early-cse-memssa -guard-widening -loop-unswitch -mergefunc -callsite-splitting -correlated-propagation -hotcoldsplit -gvn-hoist -globaldce -loop-interchange -instnamer -newgvn -mergereturn -lowerswitch -cross-dso-cfi -always-inline -pgo-memop-opt -flattencfg -loop-interchange -mem2reg -mergeicmps -loop-versioning-licm -consthoist -loop-simplify -irce -inferattrs -mergeicmps -early-cse-memssa -coro-elide -loop-unroll -speculative-execution -coro-elide -lower-guard-intrinsic -simple-loop-unswitch -redundant-dbg-inst-elim -globaldce -insert-gcov-profiling -loop-versioning-licm -instnamer -adce -gvn -loop-fusion -loop-deletion -lower-expect -adce -jump-threading -loop-interchange -instsimplify -insert-gcov-profiling -inferattrs -mergereturn -inferattrs -add-discriminators -coro-split -irce -newgvn -separate-const-offset-from-gep -dse -coro-elide -memcpyopt -loop-idiom -lower-guard-intrinsic -strip -irce -globalopt -loop-versioning -barrier -early-cse-memssa -gvn-hoist -strip -tailcallelim -sccp -lower-matrix-intrinsics -lower-guard-intrinsic -callsite-splitting -indvars -consthoist -early-cse-memssa -loop-guard-widening -speculative-execution -argpromotion -strip -insert-gcov-profiling -post-inline-ee-instrument -loop-unroll-and-jam -slsr -newgvn -prune-eh -argpromotion -constmerge -speculative-execution -redundant-dbg-inst-elim -loop-instsimplify -loop-reroll -instcombine -coro-early -lower-expect -post-inline-ee-instrument -loop-distribute -slp-vectorizer -pgo-memop-opt -loop-predication -slp-vectorizer -simplifycfg -forceattrs -coro-split -lower-guard-intrinsic -instsimplify -sink -coro-early -early-cse-memssa -aggressive-instcombine -jump-threading -separate-const-offset-from-gep -mem2reg -rewrite-statepoints-for-gc -sccp -slp-vectorizer -loop-reroll -coro-elide -cross-dso-cfi -gvn-hoist -jump-threading -coro-split -loop-versioning-licm -constprop -gvn -indvars -loop-sink -prune-eh -mergeicmps -tailcallelim -indvars -elim-avail-extern -lower-guard-intrinsic -instcombine input.bc -o output.bc +benchmark://cbench-v1/gsm,1.048057768924303,16.46152639389038,opt -coro-split -lower-matrix-intrinsics -add-discriminators -mergeicmps -lower-constant-intrinsics -loop-unroll-and-jam -redundant-dbg-inst-elim -inject-tli-mappings -barrier -argpromotion -barrier -canonicalize-aliases -separate-const-offset-from-gep -mem2reg -loop-data-prefetch -loop-guard-widening -simplifycfg -consthoist -loop-idiom -deadargelim -loop-sink -lower-expect -lower-constant-intrinsics -reassociate -instcombine -newgvn -globaldce -lowerinvoke -mergefunc -loop-instsimplify -strip-nondebug -prune-eh -constprop -dse -sancov -loop-unroll-and-jam -float2int -canonicalize-aliases -barrier -constprop -loop-fusion -slp-vectorizer -loop-simplifycfg -name-anon-globals -strip-nondebug -strip -sancov -flattencfg -correlated-propagation -redundant-dbg-inst-elim -sroa -strip-dead-prototypes -lowerswitch -callsite-splitting -post-inline-ee-instrument -newgvn -loop-versioning -dce -prune-eh -globalsplit -loop-unroll-and-jam -cross-dso-cfi -die -sink -adce -redundant-dbg-inst-elim -barrier -dse -memcpyopt -loop-data-prefetch -loop-unswitch -gvn -loop-fusion -sancov -slp-vectorizer -loweratomic -break-crit-edges -indvars -sink -loop-fusion -loop-predication -mergeicmps -aggressive-instcombine -loop-versioning-licm -barrier -add-discriminators -guard-widening -early-cse-memssa -early-cse-memssa -strip-dead-prototypes -pgo-memop-opt -lowerswitch -add-discriminators -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/gsm,1.050921314741036,13.954805850982666,opt -newgvn -loop-instsimplify -mergereturn -memcpyopt -loop-reduce -sroa -elim-avail-extern -lower-guard-intrinsic -guard-widening -dce -loop-vectorize -reassociate -argpromotion -loop-instsimplify -loop-instsimplify -coro-early -instcombine -lower-widenable-condition -attributor -always-inline -name-anon-globals -indvars -always-inline -globalopt -lowerswitch -inferattrs -loop-simplify -ipconstprop -speculative-execution -globalsplit -sancov -gvn-hoist -called-value-propagation -mldst-motion -dse -loop-data-prefetch -inferattrs -lower-guard-intrinsic -loop-reroll -early-cse-memssa -called-value-propagation -separate-const-offset-from-gep -sink -strip-nondebug -ipconstprop -lower-matrix-intrinsics -loop-fusion -loop-versioning-licm -aggressive-instcombine -prune-eh -loop-sink -guard-widening -jump-threading -lower-matrix-intrinsics -mergefunc -loop-guard-widening -lower-widenable-condition -loop-simplifycfg -newgvn -mem2reg -lcssa -loop-interchange -functionattrs -loop-unroll-and-jam -coro-cleanup -break-crit-edges -lower-matrix-intrinsics -name-anon-globals -tailcallelim -loop-simplify -bdce -redundant-dbg-inst-elim -inferattrs -hotcoldsplit -simplifycfg -ipsccp -ipsccp -float2int -loop-sink -functionattrs -licm -div-rem-pairs -alignment-from-assumptions -div-rem-pairs -deadargelim -rewrite-statepoints-for-gc -loop-unswitch -loop-guard-widening -cross-dso-cfi -instnamer -hotcoldsplit -consthoist -lowerinvoke -functionattrs -lower-guard-intrinsic -aggressive-instcombine -nary-reassociate -lower-constant-intrinsics -canonicalize-aliases -loop-predication -bdce -gvn -infer-address-spaces -slp-vectorizer -gvn -lower-matrix-intrinsics -reassociate -nary-reassociate -attributor -mergefunc -loop-idiom -loop-simplifycfg -lower-matrix-intrinsics -reassociate -lower-matrix-intrinsics -loop-distribute -instcombine input.bc -o output.bc +benchmark://cbench-v1/ispell,0.9370865587614357,15.787727355957031,opt -lcssa -simplifycfg -loop-load-elim -slsr -libcalls-shrinkwrap -globalopt -simplifycfg -loop-instsimplify -adce -simplifycfg -strip-dead-prototypes -hotcoldsplit -dce -aggressive-instcombine -loop-unroll-and-jam -loop-data-prefetch -ipconstprop -functionattrs -coro-early -loop-unroll -lower-matrix-intrinsics -loop-simplify -pgo-memop-opt -bdce -name-anon-globals -loop-load-elim -lower-matrix-intrinsics -coro-cleanup -prune-eh -correlated-propagation -strip-debug-declare -coro-early -jump-threading -cross-dso-cfi -sroa -loweratomic -insert-gcov-profiling -post-inline-ee-instrument -partial-inliner -prune-eh -loop-load-elim -add-discriminators -inject-tli-mappings -lower-widenable-condition -coro-split -deadargelim -prune-eh -loop-unroll -rewrite-statepoints-for-gc -inject-tli-mappings -sccp -strip-debug-declare -mergereturn -load-store-vectorizer -lower-matrix-intrinsics -instcombine -attributor -loop-simplify -mldst-motion -reassociate -lower-constant-intrinsics -simplifycfg -coro-split -loop-data-prefetch -loweratomic -argpromotion -cross-dso-cfi -canonicalize-aliases -bdce -loop-fusion -tailcallelim -adce -alignment-from-assumptions -callsite-splitting -add-discriminators -barrier -reassociate -newgvn input.bc -o output.bc +benchmark://cbench-v1/ispell,0.9480647431386349,15.543245077133179,opt -coro-elide -dce -mergereturn -slp-vectorizer -gvn-hoist -lowerswitch -mergefunc -lowerinvoke -alignment-from-assumptions -lcssa -loop-reduce -loop-reduce -scalarizer -infer-address-spaces -constprop -partial-inliner -scalarizer -die -mergefunc -strip-debug-declare -loweratomic -prune-eh -early-cse-memssa -jump-threading -globalsplit -flattencfg -loop-vectorize -instsimplify -lower-matrix-intrinsics -callsite-splitting -irce -strip-debug-declare -mergefunc -aggressive-instcombine -deadargelim -gvn-hoist -coro-cleanup -early-cse-memssa -loop-distribute -loop-unswitch -gvn -loop-guard-widening -loop-versioning-licm -mem2reg -globalsplit -cross-dso-cfi -loop-sink -aggressive-instcombine -instcombine -mergefunc -loop-sink -dce -guard-widening -loop-vectorize -lower-guard-intrinsic -loop-sink -name-anon-globals -coro-early -loop-guard-widening -loop-versioning -simplifycfg -libcalls-shrinkwrap -separate-const-offset-from-gep -libcalls-shrinkwrap -loop-versioning -alignment-from-assumptions -loop-versioning -gvn -coro-cleanup -sancov -loweratomic -speculative-execution -loop-versioning -reg2mem -redundant-dbg-inst-elim -loop-sink -loop-sink -strip-nondebug -pgo-memop-opt -coro-split -coro-early -name-anon-globals -consthoist -correlated-propagation -callsite-splitting -guard-widening -loop-guard-widening -guard-widening -barrier -loop-vectorize -add-discriminators -ipsccp -instnamer -coro-early -constprop -infer-address-spaces -add-discriminators -rewrite-statepoints-for-gc -slsr -inferattrs -dce -loweratomic -globaldce -inject-tli-mappings -deadargelim -nary-reassociate -slp-vectorizer -mem2reg -correlated-propagation -constmerge -strip-nondebug -adce -partial-inliner -tailcallelim -ipsccp -mem2reg -aggressive-instcombine -jump-threading -sccp -guard-widening -name-anon-globals -gvn -strip -div-rem-pairs -loop-unroll -globalsplit -partially-inline-libcalls -simplifycfg -correlated-propagation input.bc -o output.bc +benchmark://cbench-v1/ispell,0.9583391977480648,16.2684326171875,opt -jump-threading -loop-reduce -lower-expect -insert-gcov-profiling -add-discriminators -rpo-functionattrs -deadargelim -break-crit-edges -loop-distribute -flattencfg -early-cse-memssa -constmerge -float2int -slp-vectorizer -jump-threading -strip -loop-unroll -strip-nondebug -lower-expect -newgvn -globalsplit -separate-const-offset-from-gep -mem2reg -ipsccp -simplifycfg -sroa -loop-versioning-licm -flattencfg -pgo-memop-opt -float2int -loop-unroll -lower-constant-intrinsics -memcpyopt -deadargelim -libcalls-shrinkwrap -loop-distribute -constprop -loop-simplify -gvn -slsr -sink -canonicalize-aliases -slsr -lower-constant-intrinsics -loop-idiom -indvars -hotcoldsplit -rewrite-statepoints-for-gc -globalopt -loop-simplifycfg -rpo-functionattrs -lower-constant-intrinsics -strip-nondebug -ee-instrument -aggressive-instcombine -lower-guard-intrinsic -loop-reroll -attributor -add-discriminators -instcombine input.bc -o output.bc +benchmark://cbench-v1/ispell,0.9601688951442646,16.670270681381226,opt -globalopt -newgvn -loop-interchange -lower-constant-intrinsics -lower-widenable-condition -strip-nondebug -cross-dso-cfi -slp-vectorizer -canonicalize-aliases -consthoist -gvn -mem2reg -coro-split -sroa -instsimplify -mergefunc -loop-predication -ee-instrument -ee-instrument -gvn-hoist -mem2reg -loop-predication -rewrite-statepoints-for-gc -callsite-splitting -elim-avail-extern -loop-predication -infer-address-spaces -elim-avail-extern -lower-guard-intrinsic -loop-reroll -mem2reg -loop-versioning-licm -mergefunc -loop-fusion -loop-vectorize -licm -always-inline -simplifycfg -loop-versioning -sancov -loop-idiom -lower-guard-intrinsic -loop-distribute -loop-unroll -coro-cleanup -break-crit-edges -coro-early -instcombine -attributor -float2int -sancov -inject-tli-mappings -loop-guard-widening -strip-nondebug -simple-loop-unswitch -loop-distribute -gvn -always-inline -coro-elide -adce -loop-interchange -slsr -libcalls-shrinkwrap -strip-dead-prototypes -partially-inline-libcalls -prune-eh -lower-expect -globalsplit -loop-instsimplify -strip-debug-declare -div-rem-pairs -load-store-vectorizer -ee-instrument -sroa -strip-dead-prototypes -sccp -instnamer -inferattrs -irce -sroa -loop-data-prefetch -lower-expect -redundant-dbg-inst-elim -div-rem-pairs -canonicalize-aliases -inject-tli-mappings -consthoist -loop-unroll -callsite-splitting -barrier -coro-split -cross-dso-cfi -jump-threading input.bc -o output.bc +benchmark://cbench-v1/ispell,0.9607318789584799,15.463008642196655,opt -speculative-execution -barrier -prune-eh -early-cse-memssa -inferattrs -coro-elide -loop-vectorize -ipsccp -rpo-functionattrs -globaldce -loop-versioning-licm -name-anon-globals -called-value-propagation -gvn -reassociate -mem2reg -early-cse-memssa -post-inline-ee-instrument -attributor -div-rem-pairs -irce -sccp -bdce -simplifycfg -gvn-hoist -instcombine input.bc -o output.bc +benchmark://cbench-v1/ispell,0.9653764954257565,16.424754858016968,opt -loop-unroll -speculative-execution -loop-load-elim -newgvn -lower-widenable-condition -insert-gcov-profiling -loop-versioning-licm -indvars -inject-tli-mappings -loop-simplify -die -infer-address-spaces -early-cse-memssa -barrier -loop-guard-widening -reassociate -rewrite-statepoints-for-gc -coro-early -globalopt -scalarizer -ee-instrument -forceattrs -loop-simplify -rpo-functionattrs -loop-load-elim -lower-matrix-intrinsics -constmerge -dce -loop-reduce -jump-threading -correlated-propagation -separate-const-offset-from-gep -loop-instsimplify -lowerinvoke -loop-unroll -rewrite-statepoints-for-gc -constmerge -functionattrs -insert-gcov-profiling -lower-expect -strip -lowerswitch -newgvn -globaldce -instcombine -instsimplify -lowerswitch -lower-matrix-intrinsics -strip-debug-declare -coro-early -mldst-motion -coro-cleanup -sroa -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/ispell,0.9655172413793099,16.854193210601807,opt -loop-distribute -redundant-dbg-inst-elim -elim-avail-extern -sancov -lowerinvoke -mldst-motion -elim-avail-extern -reg2mem -dce -lower-guard-intrinsic -canonicalize-aliases -slsr -lower-expect -always-inline -sink -bdce -dce -loop-deletion -redundant-dbg-inst-elim -called-value-propagation -bdce -globalsplit -lower-constant-intrinsics -ipsccp -inferattrs -speculative-execution -mergeicmps -slsr -nary-reassociate -prune-eh -rewrite-statepoints-for-gc -alignment-from-assumptions -strip -strip-nondebug -sink -sink -sroa -newgvn -rpo-functionattrs -name-anon-globals -loop-interchange -loop-versioning -licm -mldst-motion -functionattrs -add-discriminators -lower-expect -ipconstprop -libcalls-shrinkwrap -called-value-propagation -lowerinvoke -loop-distribute -loop-data-prefetch -loop-versioning-licm -gvn -globalopt -coro-early -instcombine -coro-split -coro-cleanup -loop-data-prefetch -speculative-execution -barrier -partially-inline-libcalls -speculative-execution -sancov -loop-simplify -loop-simplify -mergereturn -bdce -dse -constmerge -argpromotion -memcpyopt -mergefunc -cross-dso-cfi -loop-sink -speculative-execution -newgvn -insert-gcov-profiling -coro-cleanup -instcombine -loop-unroll-and-jam -coro-early -licm -canonicalize-aliases -strip-dead-prototypes -add-discriminators -scalarizer -dse -aggressive-instcombine -loop-fusion -ee-instrument -hotcoldsplit -rpo-functionattrs -lower-expect -globaldce -loop-load-elim -rpo-functionattrs -div-rem-pairs -sccp -loop-vectorize -loop-instsimplify -loop-vectorize -lower-guard-intrinsic -globalopt -coro-early -loop-reroll -partially-inline-libcalls -redundant-dbg-inst-elim -rewrite-statepoints-for-gc -elim-avail-extern -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/ispell,0.9809992962702324,16.816142797470093,opt -loop-idiom -scalarizer -lower-widenable-condition -lcssa -loop-reduce -lower-widenable-condition -coro-elide -lower-widenable-condition -lower-guard-intrinsic -coro-split -loop-reduce -cross-dso-cfi -pgo-memop-opt -newgvn -canonicalize-aliases -tailcallelim -inferattrs -reg2mem -loop-guard-widening -sccp -called-value-propagation -post-inline-ee-instrument -strip-dead-prototypes -called-value-propagation -sancov -strip-dead-prototypes -mergereturn -globalsplit -strip-dead-prototypes -sccp -reg2mem -loop-instsimplify -prune-eh -functionattrs -mergeicmps -tailcallelim -alignment-from-assumptions -simple-loop-unswitch -coro-elide -loop-deletion -ipsccp -loop-unroll-and-jam -mldst-motion -div-rem-pairs -strip-dead-prototypes -reassociate -always-inline -float2int -alignment-from-assumptions -loop-versioning-licm -slsr -deadargelim -sccp -redundant-dbg-inst-elim -reassociate -load-store-vectorizer -consthoist -early-cse-memssa -loop-predication -indvars -jump-threading -consthoist -load-store-vectorizer -argpromotion -mergereturn -coro-early -correlated-propagation -adce -mem2reg -loop-deletion -infer-address-spaces -lowerinvoke -gvn -coro-split -loop-instsimplify -coro-early -canonicalize-aliases -instnamer -barrier -callsite-splitting -simplifycfg -cross-dso-cfi -inject-tli-mappings -instcombine input.bc -o output.bc +benchmark://cbench-v1/ispell,0.9884588318085854,17.402209043502808,opt -bdce -speculative-execution -post-inline-ee-instrument -globalopt -separate-const-offset-from-gep -canonicalize-aliases -coro-early -gvn -loop-unroll-and-jam -load-store-vectorizer -float2int -cross-dso-cfi -newgvn -mem2reg -loop-unroll -elim-avail-extern -coro-elide -cross-dso-cfi -scalarizer -early-cse-memssa -instnamer -insert-gcov-profiling -ee-instrument -simplifycfg -loop-load-elim -div-rem-pairs -lower-guard-intrinsic -attributor -guard-widening -add-discriminators -coro-elide -loop-versioning -loop-vectorize -strip -correlated-propagation -dse -prune-eh -loop-predication -float2int -loop-versioning-licm -div-rem-pairs -loop-unroll-and-jam -lower-guard-intrinsic -loop-simplifycfg -strip-debug-declare -instcombine -coro-cleanup -coro-split -tailcallelim -correlated-propagation -instnamer -early-cse-memssa -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/ispell,1.0002814919071077,16.02399444580078,opt -mem2reg -early-cse-memssa -sancov -always-inline -strip-debug-declare -forceattrs -forceattrs -nary-reassociate -early-cse-memssa -loop-vectorize -newgvn -ipconstprop -div-rem-pairs -dse -strip-dead-prototypes -barrier -dce -simple-loop-unswitch -barrier -inject-tli-mappings -nary-reassociate -callsite-splitting -simplifycfg -instsimplify -loop-guard-widening -break-crit-edges -strip-debug-declare -mergefunc -loop-fusion -loop-interchange -dse -post-inline-ee-instrument -loop-load-elim -globalopt -simplifycfg -loop-deletion -guard-widening -lower-expect -newgvn -instcombine -strip-dead-prototypes -hotcoldsplit -strip-dead-prototypes -tailcallelim -forceattrs -strip-debug-declare -ipsccp -nary-reassociate -loop-predication -flattencfg -called-value-propagation -attributor -loop-simplify -scalarizer -mergeicmps -add-discriminators -coro-early -libcalls-shrinkwrap -mem2reg -deadargelim -loop-idiom -mergefunc -sroa -speculative-execution -globalopt -early-cse-memssa -lower-constant-intrinsics -argpromotion -instcombine -sink -die -lower-expect -lowerinvoke -lowerinvoke -div-rem-pairs -loop-simplify -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,0.9791053104752456,49.419673442840576,opt -break-crit-edges -add-discriminators -lcssa -loop-unroll-and-jam -nary-reassociate -mldst-motion -licm -inferattrs -mem2reg -rpo-functionattrs -callsite-splitting -cross-dso-cfi -loop-distribute -reg2mem -barrier -lowerswitch -separate-const-offset-from-gep -coro-early -newgvn -simple-loop-unswitch -lowerswitch -cross-dso-cfi -dce -infer-address-spaces -canonicalize-aliases -inferattrs -instcombine -sroa -called-value-propagation -strip-dead-prototypes -inferattrs -callsite-splitting -tailcallelim -slp-vectorizer -functionattrs -simplifycfg -ipconstprop -name-anon-globals -coro-cleanup -constprop -loweratomic -globaldce -hotcoldsplit -div-rem-pairs -div-rem-pairs -mergeicmps -constmerge -functionattrs -mldst-motion -memcpyopt -argpromotion -strip -simplifycfg -strip-dead-prototypes -speculative-execution -bdce input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,0.9851815109898626,40.56418228149414,opt -lowerinvoke -mem2reg -gvn-hoist -functionattrs -irce -instsimplify -insert-gcov-profiling -loweratomic -aggressive-instcombine -lcssa -infer-address-spaces -barrier -insert-gcov-profiling -nary-reassociate -adce -loop-guard-widening -libcalls-shrinkwrap -irce -coro-early -licm -rewrite-statepoints-for-gc -die -hotcoldsplit -lowerinvoke -consthoist -globalsplit -div-rem-pairs -globalsplit -loop-deletion -loop-idiom -loop-unroll-and-jam -loop-predication -coro-cleanup -sroa -lower-widenable-condition -coro-early -globalopt -jump-threading -lower-matrix-intrinsics -loop-interchange -licm -die -functionattrs -loop-versioning-licm -post-inline-ee-instrument -simple-loop-unswitch -strip-nondebug -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,0.9937377933471805,39.32756042480469,opt -dse -indvars -sccp -lowerinvoke -loop-unswitch -functionattrs -constmerge -coro-early -lower-expect -loop-unroll-and-jam -called-value-propagation -rpo-functionattrs -aggressive-instcombine -attributor -cross-dso-cfi -lower-widenable-condition -dce -rewrite-statepoints-for-gc -sroa -constmerge -partially-inline-libcalls -loop-unroll -elim-avail-extern -loop-idiom -barrier -libcalls-shrinkwrap -loop-sink -redundant-dbg-inst-elim -coro-elide -loop-unswitch -argpromotion -simple-loop-unswitch -nary-reassociate -loop-reroll -loop-predication -insert-gcov-profiling -strip-debug-declare -cross-dso-cfi -loop-sink -forceattrs -strip-nondebug -sccp -tailcallelim -irce -loop-predication -loop-unroll -loop-reroll -simplifycfg -loop-simplifycfg -early-cse-memssa -add-discriminators -loop-deletion -load-store-vectorizer -strip-dead-prototypes -div-rem-pairs -callsite-splitting -loop-deletion -cross-dso-cfi -float2int -loop-sink -lcssa -indvars -consthoist -infer-address-spaces -slp-vectorizer -loop-sink -redundant-dbg-inst-elim -loop-unswitch -attributor -add-discriminators -libcalls-shrinkwrap -simplifycfg -globalopt -nary-reassociate -globalopt -mergereturn -instcombine -early-cse-memssa -deadargelim -jump-threading input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,0.9965588864432526,37.86662936210632,opt -irce -dse -rewrite-statepoints-for-gc -mldst-motion -ee-instrument -strip-debug-declare -inject-tli-mappings -coro-split -prune-eh -strip-dead-prototypes -gvn -lower-matrix-intrinsics -coro-split -loop-fusion -lower-expect -mem2reg -loop-load-elim -redundant-dbg-inst-elim -memcpyopt -loop-simplify -loop-deletion -instcombine -constmerge -inferattrs -sancov -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,0.9974889171342651,37.16405701637268,opt -always-inline -loop-idiom -post-inline-ee-instrument -simple-loop-unswitch -prune-eh -aggressive-instcombine -licm -lower-guard-intrinsic -licm -mem2reg -coro-split -name-anon-globals -correlated-propagation -infer-address-spaces -instcombine -instcombine -inject-tli-mappings -elim-avail-extern -loweratomic -scalarizer -loop-simplify -correlated-propagation -coro-elide -rewrite-statepoints-for-gc -mergefunc -strip-dead-prototypes -rpo-functionattrs -hotcoldsplit -lowerinvoke -functionattrs -lower-guard-intrinsic -loop-load-elim -newgvn -separate-const-offset-from-gep -float2int -sroa -loop-guard-widening -sroa -slp-vectorizer -coro-cleanup -coro-cleanup -rewrite-statepoints-for-gc -loop-interchange -irce -lower-widenable-condition -jump-threading -tailcallelim -strip -aggressive-instcombine -lowerswitch -prune-eh -mem2reg -constmerge -sink -loop-reroll -loop-predication -reassociate -post-inline-ee-instrument -ipsccp -speculative-execution -correlated-propagation -float2int -strip-debug-declare -post-inline-ee-instrument -partially-inline-libcalls -lower-constant-intrinsics -adce -canonicalize-aliases -irce -dce -simple-loop-unswitch -bdce -mergereturn -speculative-execution -post-inline-ee-instrument -loop-fusion -dce -gvn -die -mem2reg -loop-interchange -indvars -instsimplify input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.004588151408996,41.63024926185608,opt -strip-nondebug -loop-predication -elim-avail-extern -loop-versioning-licm -newgvn -loop-distribute -always-inline -deadargelim -loop-load-elim -loop-guard-widening -mem2reg -loop-instsimplify -strip-dead-prototypes -indvars -lcssa -tailcallelim -strip -sancov -strip-debug-declare -separate-const-offset-from-gep -mergefunc -deadargelim -cross-dso-cfi -irce -coro-split -loop-versioning-licm -inject-tli-mappings -instsimplify -loop-reroll -mergefunc -correlated-propagation -sccp -lower-matrix-intrinsics -sink -load-store-vectorizer -ipconstprop -correlated-propagation -loop-guard-widening -callsite-splitting -lower-widenable-condition -strip-nondebug -callsite-splitting -coro-cleanup -constmerge -div-rem-pairs -simplifycfg -constprop -loop-unroll -ipconstprop -early-cse-memssa -cross-dso-cfi -lower-guard-intrinsic -consthoist -loop-load-elim -consthoist -globalopt -lower-guard-intrinsic -break-crit-edges -nary-reassociate -loop-idiom -sccp -loweratomic -flattencfg -aggressive-instcombine -speculative-execution -loop-instsimplify -mergereturn -attributor -loop-simplifycfg -aggressive-instcombine -correlated-propagation -instnamer -newgvn -sink -globalopt -coro-elide -speculative-execution -ipconstprop -loop-distribute -loop-unroll -loop-deletion -loop-interchange -globalopt -libcalls-shrinkwrap -gvn -jump-threading -alignment-from-assumptions -lower-matrix-intrinsics -separate-const-offset-from-gep -div-rem-pairs -consthoist -instcombine -simple-loop-unswitch -always-inline -loop-idiom -bdce -ee-instrument -infer-address-spaces -sancov -simple-loop-unswitch -ipconstprop -always-inline -barrier -guard-widening -cross-dso-cfi -libcalls-shrinkwrap -loop-unroll -redundant-dbg-inst-elim -inferattrs -guard-widening -strip -div-rem-pairs -alignment-from-assumptions -instsimplify -separate-const-offset-from-gep -div-rem-pairs -instcombine -loop-sink -loop-reroll -pgo-memop-opt -reg2mem -lowerinvoke -dse -loop-simplifycfg -partial-inliner -mem2reg -post-inline-ee-instrument -sink -bdce -post-inline-ee-instrument -sink -loop-versioning-licm -coro-early -strip -partially-inline-libcalls -mem2reg -rewrite-statepoints-for-gc -coro-split -instcombine -early-cse-memssa -partial-inliner -gvn-hoist -loop-idiom -partially-inline-libcalls -strip-nondebug -globaldce -loop-unroll -loop-versioning-licm -break-crit-edges -loop-interchange -irce -mergeicmps -strip -reassociate -constmerge -early-cse-memssa -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0055181821000094,42.71349883079529,opt -lower-matrix-intrinsics -aggressive-instcombine -rpo-functionattrs -deadargelim -inferattrs -reassociate -mergeicmps -functionattrs -mergefunc -loop-distribute -slsr -adce -name-anon-globals -mergereturn -strip-debug-declare -slsr -gvn-hoist -correlated-propagation -simple-loop-unswitch -irce -loop-versioning-licm -sroa -lower-widenable-condition -adce -loop-predication -jump-threading -coro-early -loop-reroll -load-store-vectorizer -always-inline -barrier -instcombine -lower-widenable-condition -aggressive-instcombine -jump-threading -callsite-splitting -die -canonicalize-aliases -globalsplit -ee-instrument -speculative-execution -argpromotion -newgvn -forceattrs -called-value-propagation -coro-cleanup -jump-threading input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.00750224757417,40.76293182373047,opt -loop-instsimplify -lower-constant-intrinsics -simple-loop-unswitch -loop-interchange -indvars -add-discriminators -newgvn -lower-matrix-intrinsics -break-crit-edges -mergeicmps -loop-unroll-and-jam -lowerinvoke -instnamer -reg2mem -inferattrs -loop-unswitch -flattencfg -called-value-propagation -lowerinvoke -alignment-from-assumptions -correlated-propagation -ipsccp -add-discriminators -loop-reduce -loop-idiom -jump-threading -forceattrs -loop-load-elim -called-value-propagation -globaldce -ipsccp -loop-simplifycfg -loop-deletion -always-inline -loop-simplifycfg -correlated-propagation -loop-reduce -attributor -globalopt -loweratomic -loop-versioning-licm -deadargelim -irce -loop-reduce -canonicalize-aliases -infer-address-spaces -indvars -simple-loop-unswitch -reg2mem -rpo-functionattrs -ipsccp -instsimplify -infer-address-spaces -redundant-dbg-inst-elim -rewrite-statepoints-for-gc -mem2reg -speculative-execution -instcombine -lower-widenable-condition -slp-vectorizer -simplifycfg -deadargelim -sroa -instcombine -bdce -slp-vectorizer -aggressive-instcombine -lowerinvoke -lowerinvoke -mergereturn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0162135350466563,37.60094594955444,opt -post-inline-ee-instrument -inject-tli-mappings -die -hotcoldsplit -loop-interchange -loop-versioning -sroa -forceattrs -strip -gvn-hoist -argpromotion -loop-reroll -argpromotion -canonicalize-aliases -globalsplit -instcombine -inferattrs -post-inline-ee-instrument -strip-dead-prototypes -mldst-motion -loop-sink -die -loweratomic -flattencfg -speculative-execution -early-cse-memssa -pgo-memop-opt -lower-guard-intrinsic -add-discriminators -mergefunc -loop-data-prefetch -elim-avail-extern -indvars -attributor -simple-loop-unswitch -loop-fusion -ipsccp -attributor -strip-nondebug -simplifycfg -slp-vectorizer input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0305050066652195,43.867016553878784,opt -bdce -attributor -guard-widening -instsimplify -mem2reg -loop-instsimplify -flattencfg -rewrite-statepoints-for-gc -globalsplit -loop-idiom -lower-constant-intrinsics -die -loop-guard-widening -gvn-hoist -loop-distribute -licm -lower-widenable-condition -functionattrs -jump-threading -rpo-functionattrs -bdce -div-rem-pairs -gvn -sccp -lcssa -sccp -libcalls-shrinkwrap -coro-split -instnamer -newgvn -inferattrs -forceattrs -correlated-propagation -mem2reg -dse -dse -licm -partially-inline-libcalls -ipsccp -loop-unroll-and-jam -lower-guard-intrinsic -lower-matrix-intrinsics -gvn -indvars -attributor -licm -libcalls-shrinkwrap -mldst-motion -sccp -rpo-functionattrs -flattencfg -nary-reassociate -strip-nondebug -loop-simplifycfg -loop-versioning-licm -lcssa -lower-expect -mergefunc -name-anon-globals -strip-debug-declare -ipconstprop -licm -strip-dead-prototypes -loop-deletion -separate-const-offset-from-gep -partially-inline-libcalls -correlated-propagation -mergereturn -deadargelim -newgvn -loop-deletion -instcombine -lower-widenable-condition -dse -jump-threading -mem2reg -always-inline -pgo-memop-opt -mergereturn -loop-data-prefetch -loop-versioning-licm -simplifycfg -speculative-execution -licm -functionattrs -die -prune-eh -functionattrs -libcalls-shrinkwrap -globalopt -rpo-functionattrs -irce -loweratomic -loop-simplify -lower-matrix-intrinsics -loop-unroll-and-jam -flattencfg -reassociate -loop-simplify -slsr -partially-inline-libcalls -loop-data-prefetch -div-rem-pairs -loop-instsimplify -called-value-propagation -loop-distribute -ipsccp -memcpyopt -dce -guard-widening -ee-instrument -cross-dso-cfi -instsimplify input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,0.9849319037960012,44.77920889854431,opt -always-inline -simple-loop-unswitch -scalarizer -coro-elide -coro-early -constmerge -sccp -lower-matrix-intrinsics -dce -scalarizer -ipconstprop -loop-sink -instnamer -sccp -mergeicmps -newgvn -simplifycfg -ipconstprop -lower-expect -strip-debug-declare -sink -constprop -sroa -flattencfg -strip -strip -lcssa -consthoist -coro-early -attributor -slp-vectorizer -cross-dso-cfi -lower-widenable-condition -coro-split -constprop -mldst-motion -constmerge -functionattrs -forceattrs -mergefunc -aggressive-instcombine -slsr -lower-expect -loop-load-elim -forceattrs -rpo-functionattrs -sancov -loweratomic -licm -lower-expect -loop-simplify -loop-guard-widening -strip-dead-prototypes -ipconstprop -inferattrs -sancov -sccp -always-inline -rewrite-statepoints-for-gc -loop-vectorize -loop-versioning -mldst-motion -speculative-execution -loop-vectorize -loop-predication -ee-instrument -coro-elide -gvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,0.9866383334943173,41.430155515670776,opt -coro-early -callsite-splitting -float2int -libcalls-shrinkwrap -sccp -forceattrs -lower-guard-intrinsic -gvn-hoist -called-value-propagation -loop-idiom -gvn -prune-eh -indvars -post-inline-ee-instrument -loweratomic -sroa -sroa -lower-constant-intrinsics -lowerswitch -canonicalize-aliases -newgvn -argpromotion -float2int -insert-gcov-profiling -loop-reroll -nary-reassociate -gvn-hoist -lower-constant-intrinsics -loop-simplify -separate-const-offset-from-gep -ipsccp -simplifycfg -libcalls-shrinkwrap -newgvn -bdce input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,0.9939148073022314,41.397254943847656,opt -attributor -speculative-execution -sink -called-value-propagation -canonicalize-aliases -irce -lower-constant-intrinsics -dse -lowerswitch -functionattrs -globalopt -separate-const-offset-from-gep -instnamer -elim-avail-extern -hotcoldsplit -lower-constant-intrinsics -jump-threading -lowerswitch -inferattrs -jump-threading -lower-expect -instsimplify -gvn -dse -called-value-propagation -lcssa -memcpyopt -correlated-propagation -newgvn -reg2mem -elim-avail-extern -called-value-propagation -div-rem-pairs -loop-unswitch -redundant-dbg-inst-elim -ipconstprop -speculative-execution -loop-unroll-and-jam -loop-guard-widening -loop-fusion -mergeicmps -globaldce -lowerinvoke -ee-instrument -mem2reg -loop-load-elim -constmerge -lowerswitch -loop-deletion -attributor -lower-expect -newgvn -ee-instrument -forceattrs -strip -loop-versioning-licm -deadargelim -loop-distribute -early-cse-memssa -break-crit-edges -constmerge -lowerswitch -globalsplit -globaldce -always-inline -loop-simplifycfg -mergereturn -loop-interchange -bdce -aggressive-instcombine -guard-widening -irce -gvn-hoist -always-inline -reg2mem -gvn -globalopt -loop-fusion -lower-guard-intrinsic -flattencfg -sccp -div-rem-pairs -mergereturn -separate-const-offset-from-gep -loop-fusion -div-rem-pairs -rewrite-statepoints-for-gc -loweratomic -callsite-splitting -float2int -functionattrs -loop-data-prefetch -infer-address-spaces -instcombine -infer-address-spaces -loop-fusion -ipconstprop -lower-constant-intrinsics -sink -lower-constant-intrinsics -coro-early -loop-distribute -ipsccp -sink -instnamer -mem2reg -loop-idiom -loop-idiom -coro-cleanup -coro-split -jump-threading -globalsplit -instnamer -instcombine input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,0.994140184809556,38.051066637039185,opt -loop-load-elim -loop-data-prefetch -coro-split -redundant-dbg-inst-elim -loop-distribute -mem2reg -speculative-execution -loop-predication -jump-threading -mem2reg -gvn -sccp -forceattrs -cross-dso-cfi -loop-data-prefetch -loweratomic -elim-avail-extern -bdce -flattencfg -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,0.9964261566695642,48.110989570617676,opt -argpromotion -strip -gvn -lowerswitch -post-inline-ee-instrument -loop-vectorize -strip-debug-declare -libcalls-shrinkwrap -float2int -tailcallelim -adce -instsimplify -prune-eh -dse -add-discriminators -mergereturn -prune-eh -cross-dso-cfi -loop-vectorize -instsimplify -loop-vectorize -deadargelim -reassociate -loweratomic -indvars -globalopt -lcssa -bdce -licm -memcpyopt -newgvn -jump-threading -ipsccp -pgo-memop-opt -loop-sink -instcombine -called-value-propagation -nary-reassociate -loop-fusion -loop-reroll -mergereturn -alignment-from-assumptions -lower-guard-intrinsic -dce -loweratomic -flattencfg -inject-tli-mappings -jump-threading -separate-const-offset-from-gep -instcombine -flattencfg -memcpyopt -mldst-motion -loop-unroll-and-jam -loweratomic -sccp -reassociate -loop-rotate -inject-tli-mappings -loop-guard-widening -alignment-from-assumptions -called-value-propagation -strip-nondebug -slsr -instsimplify -strip-debug-declare -lowerinvoke -functionattrs -elim-avail-extern -gvn -mergereturn -strip -deadargelim -prune-eh -barrier -instsimplify -strip-nondebug -separate-const-offset-from-gep -tailcallelim -jump-threading -redundant-dbg-inst-elim -instnamer -reassociate -partially-inline-libcalls -instcombine -ee-instrument -instnamer -globalopt -inferattrs -adce -rpo-functionattrs -called-value-propagation -constmerge -add-discriminators -add-discriminators -globaldce -ipsccp -sroa -coro-early -elim-avail-extern -guard-widening -argpromotion -instnamer -loop-instsimplify -attributor -ipconstprop -alignment-from-assumptions -name-anon-globals -globalsplit -mldst-motion -lowerswitch -loop-deletion -slsr -dse -redundant-dbg-inst-elim -simplifycfg -mldst-motion -rewrite-statepoints-for-gc -loop-data-prefetch -lower-expect -licm -simple-loop-unswitch -loop-fusion -loop-data-prefetch -post-inline-ee-instrument -mergefunc -loop-reroll -ipsccp -functionattrs -lower-matrix-intrinsics -strip-nondebug -guard-widening -partially-inline-libcalls -infer-address-spaces -called-value-propagation -mergefunc -sccp -cross-dso-cfi -indvars -argpromotion -loop-reroll -elim-avail-extern -inferattrs -partially-inline-libcalls -slp-vectorizer -deadargelim -loop-versioning-licm -post-inline-ee-instrument -ee-instrument -deadargelim -loop-data-prefetch -bdce -loop-predication -loop-distribute -slsr -hotcoldsplit -instnamer -instsimplify -loop-deletion -globaldce -name-anon-globals -ee-instrument -coro-split -die -consthoist -pgo-memop-opt -lower-widenable-condition -strip-nondebug -jump-threading -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0002575742940853,327.2070269584656,opt -insert-gcov-profiling -lcssa -gvn -called-value-propagation -mergefunc -loop-load-elim -strip-debug-declare -indvars -loop-versioning -loop-unroll-and-jam -strip-debug-declare -loop-deletion -constprop -ipconstprop -argpromotion -lower-constant-intrinsics -globalsplit -sroa -rpo-functionattrs -sink -adce -float2int -name-anon-globals -loop-sink -loop-sink -guard-widening -barrier -loop-sink -forceattrs -mergeicmps -mergeicmps -load-store-vectorizer -bdce -float2int -loop-data-prefetch -mergeicmps -partially-inline-libcalls -alignment-from-assumptions -loop-idiom -scalarizer -instsimplify -ipconstprop -loop-interchange -ipsccp -memcpyopt -instcombine -loweratomic -instsimplify -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0043787629994525,40.50717830657959,opt -sccp -coro-split -mem2reg -lower-matrix-intrinsics -loop-sink -instcombine -rpo-functionattrs -redundant-dbg-inst-elim -coro-early -strip-debug-declare -inferattrs -elim-avail-extern -rewrite-statepoints-for-gc -indvars -lowerinvoke -consthoist -ee-instrument -elim-avail-extern -mem2reg -add-discriminators -globalsplit -argpromotion -mergereturn -partially-inline-libcalls -sroa -mergereturn -reassociate -scalarizer -inferattrs -pgo-memop-opt -loop-unroll-and-jam -loop-instsimplify -functionattrs -inject-tli-mappings -lowerinvoke -slsr -consthoist -libcalls-shrinkwrap -lowerswitch -correlated-propagation -lower-constant-intrinsics -break-crit-edges -called-value-propagation -coro-split -loop-distribute -div-rem-pairs -guard-widening -nary-reassociate -indvars -aggressive-instcombine -dse -sccp -loop-guard-widening -constmerge -globalsplit -loop-sink -constprop -barrier -ipsccp -loop-reroll -ipsccp -strip-nondebug -called-value-propagation -sink -load-store-vectorizer -lower-constant-intrinsics -flattencfg -speculative-execution -early-cse-memssa -lower-expect -reassociate -ipconstprop -instsimplify -loop-instsimplify -reassociate -partial-inliner -slsr -mem2reg -infer-address-spaces -loop-instsimplify -irce -always-inline -cross-dso-cfi -lower-matrix-intrinsics -loop-simplify -loop-load-elim -ipconstprop -elim-avail-extern -ipsccp -loop-vectorize -die -hotcoldsplit -hotcoldsplit -sancov -scalarizer -loop-guard-widening -called-value-propagation -break-crit-edges -loop-guard-widening -loop-guard-widening -loop-versioning-licm -instcombine -loop-deletion -canonicalize-aliases -loop-interchange -consthoist -aggressive-instcombine -attributor -adce -mergeicmps -coro-cleanup -redundant-dbg-inst-elim -mergefunc -dce -elim-avail-extern -load-store-vectorizer -loop-guard-widening -elim-avail-extern -simplifycfg -lcssa -strip -called-value-propagation -lowerswitch -rpo-functionattrs -strip-nondebug -ipconstprop -mergefunc -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0189317106152807,39.96248817443848,opt -mem2reg -adce -post-inline-ee-instrument -mergereturn -mergereturn -loop-vectorize -float2int -float2int -globalopt -simplifycfg -sccp -redundant-dbg-inst-elim -forceattrs -slsr -insert-gcov-profiling -bdce -lower-expect -functionattrs -instcombine -rpo-functionattrs -float2int -tailcallelim -loop-data-prefetch -lcssa -forceattrs -speculative-execution -always-inline -scalarizer -instsimplify -barrier -instcombine -globaldce -guard-widening -loweratomic -strip-dead-prototypes -forceattrs -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0236002446955792,40.084962129592896,opt -ipconstprop -simple-loop-unswitch -loop-fusion -sroa -jump-threading -loop-idiom -loop-distribute -functionattrs -loop-distribute -lowerswitch -strip-debug-declare -indvars -barrier -mergefunc -redundant-dbg-inst-elim -add-discriminators -simple-loop-unswitch -licm -consthoist -instsimplify -inject-tli-mappings -loop-data-prefetch -redundant-dbg-inst-elim -rewrite-statepoints-for-gc -slp-vectorizer -inferattrs -callsite-splitting -correlated-propagation -alignment-from-assumptions -early-cse-memssa -mergefunc -sroa -scalarizer -loop-data-prefetch -prune-eh -inject-tli-mappings -rewrite-statepoints-for-gc -indvars -tailcallelim -instnamer -name-anon-globals -argpromotion -loop-instsimplify -argpromotion -ee-instrument -forceattrs -lcssa -loop-simplifycfg -indvars -inferattrs -loop-load-elim -gvn -reassociate -partially-inline-libcalls -sancov -instcombine -bdce -loop-data-prefetch -lower-guard-intrinsic -strip-dead-prototypes -strip-nondebug -simplifycfg -prune-eh -sccp -functionattrs -consthoist -libcalls-shrinkwrap -strip-dead-prototypes -coro-cleanup -die -prune-eh -gvn -lower-constant-intrinsics input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0255964454747417,36.70538592338562,opt -bdce -dse -memcpyopt -inject-tli-mappings -die -globaldce -strip-debug-declare -prune-eh -reg2mem -coro-early -die -lower-widenable-condition -lower-constant-intrinsics -instnamer -loweratomic -attributor -rewrite-statepoints-for-gc -coro-split -lower-guard-intrinsic -separate-const-offset-from-gep -sroa -loop-distribute -mergefunc -early-cse-memssa -instsimplify -simplifycfg -instcombine -scalarizer -separate-const-offset-from-gep -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/lame,1.0058073331815074,34.02283263206482,opt -gvn-hoist -instcombine -loop-load-elim -strip-nondebug -instsimplify -sroa -sancov -inferattrs -add-discriminators -loop-vectorize -loop-load-elim -lower-expect -newgvn -early-cse-memssa -instcombine -lower-constant-intrinsics -slsr -jump-threading input.bc -o output.bc +benchmark://cbench-v1/lame,1.0103241478782359,66.14738416671753,opt -loop-distribute -early-cse-memssa -loop-load-elim -jump-threading -break-crit-edges -jump-threading -gvn -rpo-functionattrs -ee-instrument -loop-fusion -loop-unswitch -loop-reroll -mergereturn -correlated-propagation -deadargelim -float2int -guard-widening -reassociate -loop-interchange -name-anon-globals -div-rem-pairs -barrier -tailcallelim -pgo-memop-opt -lower-widenable-condition -coro-split -loop-interchange -constprop -dse -reassociate -add-discriminators -elim-avail-extern -loop-distribute -lower-constant-intrinsics -lower-matrix-intrinsics -dse -hotcoldsplit -loop-distribute -redundant-dbg-inst-elim -indvars -constmerge -mergefunc -break-crit-edges -loop-simplifycfg -jump-threading -lowerswitch -flattencfg -instcombine -memcpyopt -sccp -ipsccp -loop-sink -separate-const-offset-from-gep -strip -pgo-memop-opt -adce -constprop -lcssa -lowerinvoke -simple-loop-unswitch -simple-loop-unswitch -called-value-propagation -loop-versioning -loop-fusion -memcpyopt -simplifycfg -lowerinvoke -ipsccp -consthoist -loop-deletion -licm -scalarizer -consthoist -insert-gcov-profiling -loop-interchange -loop-versioning -inferattrs -inject-tli-mappings -cross-dso-cfi -adce -tailcallelim -tailcallelim -dse -simple-loop-unswitch -ipsccp -load-store-vectorizer -loop-deletion -elim-avail-extern -break-crit-edges -loop-idiom -simplifycfg -inject-tli-mappings -loop-instsimplify -callsite-splitting -infer-address-spaces -dce -slp-vectorizer -pgo-memop-opt -loop-fusion -loop-fusion -aggressive-instcombine -rpo-functionattrs -instcombine -loop-unswitch -break-crit-edges -name-anon-globals -loop-guard-widening -bdce -deadargelim -licm -break-crit-edges -newgvn -globaldce -instsimplify -scalarizer -ipconstprop -strip-dead-prototypes -bdce -mem2reg -globalsplit -div-rem-pairs -flattencfg -die -dce -pgo-memop-opt -tailcallelim -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/lame,1.012373794883474,38.40332770347595,opt -loop-guard-widening -separate-const-offset-from-gep -slsr -loop-data-prefetch -loop-load-elim -load-store-vectorizer -mem2reg -instcombine -globaldce -globalopt -break-crit-edges -ipsccp -dse -loop-load-elim -loop-reroll -loop-rotate -loop-idiom -redundant-dbg-inst-elim -mergeicmps -bdce -load-store-vectorizer -load-store-vectorizer -inject-tli-mappings -die -loop-vectorize -barrier -div-rem-pairs -deadargelim -libcalls-shrinkwrap -mergefunc -early-cse-memssa -nary-reassociate -rpo-functionattrs -loop-predication -early-cse-memssa -instnamer -called-value-propagation -loweratomic -loop-reroll -ee-instrument -loop-deletion -functionattrs -loop-fusion -break-crit-edges -mergefunc -lower-widenable-condition -slp-vectorizer -globaldce -bdce -globaldce -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/lame,1.0212176421468158,64.10320901870728,opt -indvars -loop-data-prefetch -float2int -attributor -sancov -reassociate -lcssa -ee-instrument -deadargelim -simplifycfg -lowerinvoke -loop-simplify -always-inline -loop-simplify -mergefunc -die -gvn-hoist -speculative-execution -early-cse-memssa -attributor -loop-simplifycfg -lowerinvoke -loop-interchange -irce -gvn-hoist -instsimplify -forceattrs -loop-predication -loop-rotate -loop-distribute -prune-eh -correlated-propagation -rewrite-statepoints-for-gc -globalsplit -die -ipconstprop -loop-unswitch -lower-constant-intrinsics -hotcoldsplit -lower-widenable-condition -redundant-dbg-inst-elim -loop-vectorize -add-discriminators -newgvn -constmerge -instcombine -globaldce -dse -mem2reg -irce -bdce -consthoist -strip-nondebug -coro-split -mergeicmps -strip -loop-simplifycfg -functionattrs -mergereturn -coro-cleanup -licm -simplifycfg -loop-distribute -loweratomic -coro-elide -ipsccp -loop-deletion -lower-guard-intrinsic -newgvn -sink -newgvn -loop-deletion -lowerinvoke -gvn-hoist -globalopt -loop-distribute -insert-gcov-profiling -loop-unroll-and-jam -sroa -always-inline -loop-deletion -loop-simplify -callsite-splitting -flattencfg -lower-expect -post-inline-ee-instrument -coro-cleanup -speculative-execution -float2int -instcombine -newgvn input.bc -o output.bc +benchmark://cbench-v1/lame,1.0235709405602367,43.15250539779663,opt -instcombine -simple-loop-unswitch -functionattrs -simple-loop-unswitch -post-inline-ee-instrument -loop-simplify -instsimplify -bdce -always-inline -lcssa -float2int -functionattrs -ipsccp -globalsplit -nary-reassociate -coro-early -lowerinvoke -coro-early -loop-simplifycfg -lower-guard-intrinsic -mem2reg -bdce -loweratomic -always-inline -instnamer -elim-avail-extern -post-inline-ee-instrument -simple-loop-unswitch -die -strip-dead-prototypes -slsr -barrier -strip-debug-declare -loop-versioning -slsr -gvn -mem2reg -irce -load-store-vectorizer -speculative-execution -loop-idiom -licm -loop-guard-widening -licm -callsite-splitting -div-rem-pairs -ipsccp -loop-instsimplify -always-inline -licm -add-discriminators -div-rem-pairs -libcalls-shrinkwrap -indvars -mldst-motion -dse -sroa -loop-versioning-licm -loop-deletion -gvn-hoist -loop-versioning -lower-guard-intrinsic -die -float2int -correlated-propagation -loop-versioning -strip-nondebug -hotcoldsplit -functionattrs -slsr -inferattrs -constprop -loop-unroll-and-jam -lower-widenable-condition -loop-unswitch -mergereturn -early-cse-memssa -mldst-motion -prune-eh -loop-predication -loop-versioning-licm -loop-data-prefetch -consthoist -inferattrs -indvars -forceattrs -guard-widening -tailcallelim -sccp -load-store-vectorizer -coro-cleanup -strip-debug-declare -jump-threading -callsite-splitting -prune-eh -globaldce -instcombine -mem2reg -nary-reassociate -mergeicmps -insert-gcov-profiling -partially-inline-libcalls -globalopt -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/lame,1.0259621953996811,53.347551345825195,opt -mldst-motion -coro-elide -loop-vectorize -loop-versioning -libcalls-shrinkwrap -ipconstprop -early-cse-memssa -simple-loop-unswitch -sink -bdce -forceattrs -elim-avail-extern -loop-guard-widening -hotcoldsplit -instcombine -lowerinvoke -aggressive-instcombine -aggressive-instcombine -instcombine -lower-constant-intrinsics -dse -argpromotion -libcalls-shrinkwrap -slp-vectorizer -loop-deletion -coro-cleanup -aggressive-instcombine -separate-const-offset-from-gep -nary-reassociate -libcalls-shrinkwrap -alignment-from-assumptions -constprop -loop-reroll -separate-const-offset-from-gep -jump-threading -coro-cleanup -consthoist -load-store-vectorizer -licm -slp-vectorizer -loop-deletion -adce -correlated-propagation -newgvn -loop-reroll -slp-vectorizer -loop-simplifycfg -inject-tli-mappings -sroa -load-store-vectorizer -strip-debug-declare -lower-guard-intrinsic -aggressive-instcombine -simple-loop-unswitch -lcssa -loop-interchange -slsr -ipsccp -die -loop-reroll -called-value-propagation -globalsplit -consthoist -prune-eh -simple-loop-unswitch -loop-reroll -mergefunc -guard-widening -loop-distribute -float2int -loop-simplify -loop-predication -loweratomic -loop-versioning -inject-tli-mappings -coro-split -lcssa -loop-distribute -forceattrs -flattencfg -instcombine -callsite-splitting -post-inline-ee-instrument -constprop -mldst-motion -jump-threading -consthoist -rewrite-statepoints-for-gc -coro-elide -irce -ipsccp -float2int -globaldce -loop-simplify -cross-dso-cfi -guard-widening -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/lame,1.0276322781446898,78.09253025054932,opt -coro-elide -coro-elide -cross-dso-cfi -nary-reassociate -alignment-from-assumptions -called-value-propagation -div-rem-pairs -nary-reassociate -lower-matrix-intrinsics -canonicalize-aliases -loop-unswitch -pgo-memop-opt -mldst-motion -strip-dead-prototypes -alignment-from-assumptions -simplifycfg -speculative-execution -called-value-propagation -loop-interchange -infer-address-spaces -attributor -prune-eh -deadargelim -indvars -strip-dead-prototypes -instnamer -loop-load-elim -ipsccp -strip-dead-prototypes -nary-reassociate -constmerge -dce -cross-dso-cfi -loop-vectorize -lower-guard-intrinsic -loop-predication -always-inline -coro-cleanup -gvn -correlated-propagation -cross-dso-cfi -aggressive-instcombine -newgvn -mem2reg -mergefunc -reassociate -simple-loop-unswitch -slp-vectorizer -scalarizer -instcombine -sancov -globaldce -simplifycfg -lower-expect -memcpyopt -argpromotion -add-discriminators -loop-distribute -dse input.bc -o output.bc +benchmark://cbench-v1/lame,1.0294541865937905,36.18445158004761,opt -mldst-motion -redundant-dbg-inst-elim -loop-unroll-and-jam -sroa -loweratomic -loop-reroll -loweratomic -nary-reassociate -partially-inline-libcalls -sccp -instsimplify -mergefunc -globalsplit -attributor -forceattrs -lowerinvoke -redundant-dbg-inst-elim -die -dse -inferattrs -loop-unswitch -licm -functionattrs -irce -memcpyopt -redundant-dbg-inst-elim -name-anon-globals -speculative-execution -sancov -ipconstprop -canonicalize-aliases -jump-threading -sink -loop-simplifycfg -float2int -loop-idiom -callsite-splitting -lower-guard-intrinsic -loop-idiom -libcalls-shrinkwrap -gvn -instcombine -mem2reg -ipconstprop -attributor -argpromotion -bdce -speculative-execution -prune-eh -cross-dso-cfi -dce -mldst-motion -mldst-motion -reassociate -mergeicmps -mergefunc -loop-versioning-licm -insert-gcov-profiling -lowerswitch -div-rem-pairs -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/lame,1.0310863129127756,42.606950998306274,opt -loop-vectorize -loop-predication -loop-predication -lower-expect -rpo-functionattrs -loop-deletion -loop-reroll -lowerswitch -strip-dead-prototypes -elim-avail-extern -constmerge -partial-inliner -sancov -loop-versioning-licm -nary-reassociate -add-discriminators -gvn -break-crit-edges -guard-widening -coro-cleanup -correlated-propagation -instcombine -forceattrs -constprop -instcombine -globaldce -memcpyopt -alignment-from-assumptions -irce -nary-reassociate -functionattrs -loop-idiom -coro-split -newgvn -lower-widenable-condition -loop-idiom -instsimplify -instnamer -reg2mem -instnamer -memcpyopt -loop-simplifycfg -loop-unroll -loop-vectorize -globaldce -reassociate -inferattrs -coro-split -alignment-from-assumptions -deadargelim -lower-matrix-intrinsics -loop-unroll-and-jam -load-store-vectorizer -deadargelim -slsr -globaldce -globaldce -bdce -die -slsr -sroa -loop-idiom -newgvn -insert-gcov-profiling -name-anon-globals -loop-unswitch -functionattrs -coro-early -loop-fusion -simplifycfg -callsite-splitting -instcombine -newgvn -lower-widenable-condition -licm -ipconstprop -nary-reassociate -dce -slsr -argpromotion -alignment-from-assumptions -sccp -argpromotion -irce -called-value-propagation -globalsplit -loop-fusion -globaldce -called-value-propagation -lower-expect -coro-elide -loop-deletion -licm -loop-simplifycfg -ipsccp -reassociate -canonicalize-aliases -consthoist -ee-instrument -ipconstprop -newgvn -die -globaldce -elim-avail-extern -loop-guard-widening -redundant-dbg-inst-elim -simple-loop-unswitch -prune-eh -lower-guard-intrinsic -inject-tli-mappings -tailcallelim -functionattrs -memcpyopt -div-rem-pairs -mldst-motion -name-anon-globals -forceattrs -callsite-splitting -name-anon-globals -aggressive-instcombine -alignment-from-assumptions -slp-vectorizer -speculative-execution -licm -forceattrs -loop-deletion -div-rem-pairs -callsite-splitting -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/lame,1.0456615805055796,35.40720820426941,opt -strip-debug-declare -consthoist -sroa -loop-interchange -loop-fusion -speculative-execution -lower-matrix-intrinsics -strip -instcombine -gvn -name-anon-globals -gvn -loop-vectorize -slp-vectorizer -mergereturn -break-crit-edges -instsimplify -lcssa -deadargelim -loop-predication -licm -irce -lower-expect -loop-versioning -instcombine -gvn -coro-split -rpo-functionattrs -simplifycfg -lower-guard-intrinsic -bdce input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9866518353726363,11.925774574279785,opt -gvn-hoist -loop-unroll -loop-simplifycfg -consthoist -lower-constant-intrinsics -cross-dso-cfi -irce -bdce -strip-nondebug -mergefunc -rewrite-statepoints-for-gc -forceattrs -lowerinvoke -coro-elide -ipsccp -loop-versioning-licm -strip-dead-prototypes -libcalls-shrinkwrap -sink -loweratomic -early-cse-memssa -loop-vectorize -alignment-from-assumptions -break-crit-edges -loop-interchange -loop-distribute -strip -break-crit-edges -infer-address-spaces -canonicalize-aliases -always-inline -loop-unroll-and-jam -called-value-propagation -loweratomic -infer-address-spaces -memcpyopt -globalopt -mergereturn -licm -bdce -coro-early -simplifycfg -rpo-functionattrs -strip-dead-prototypes -pgo-memop-opt -barrier -mldst-motion -consthoist -insert-gcov-profiling -mergereturn -flattencfg -pgo-memop-opt -functionattrs -loop-sink -loop-reduce -redundant-dbg-inst-elim -post-inline-ee-instrument -insert-gcov-profiling -barrier -sancov -mem2reg -functionattrs -correlated-propagation -lower-expect -gvn-hoist -gvn -strip-dead-prototypes -instsimplify -strip -add-discriminators -lower-guard-intrinsic -ipsccp -inferattrs -reassociate -dce -prune-eh -jump-threading -adce input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9866518353726363,12.079885959625244,opt -loop-reduce -lower-guard-intrinsic -reg2mem -coro-split -loop-instsimplify -lower-constant-intrinsics -loop-reduce -coro-cleanup -canonicalize-aliases -elim-avail-extern -ee-instrument -jump-threading -correlated-propagation -lower-expect -loop-instsimplify -mldst-motion -functionattrs -div-rem-pairs -infer-address-spaces -loop-unswitch -instnamer -libcalls-shrinkwrap -loop-distribute -functionattrs -globalopt -loop-distribute -strip-dead-prototypes -libcalls-shrinkwrap -nary-reassociate -loop-simplify -lower-expect -coro-split -ipsccp -inferattrs -gvn -argpromotion -add-discriminators -lower-matrix-intrinsics -irce -globaldce -instnamer -simplifycfg -early-cse-memssa -functionattrs -instcombine -loop-unroll-and-jam -loop-deletion -gvn-hoist -jump-threading -coro-elide -tailcallelim -lower-guard-intrinsic -div-rem-pairs -attributor -adce -coro-elide -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9877641824249167,12.29286503791809,opt -slp-vectorizer -globalopt -load-store-vectorizer -dse -loop-vectorize -mem2reg -deadargelim -rewrite-statepoints-for-gc -loop-idiom -prune-eh -lower-constant-intrinsics -alignment-from-assumptions -loop-guard-widening -float2int -functionattrs -functionattrs -slp-vectorizer -mergereturn -ipsccp -consthoist -mldst-motion -instsimplify -speculative-execution -mldst-motion -simplifycfg -memcpyopt -loop-versioning -sink -loop-reroll -early-cse-memssa -coro-cleanup -loop-versioning-licm -loop-unroll -dce -guard-widening -dce -functionattrs -loop-guard-widening -speculative-execution -coro-early -div-rem-pairs -correlated-propagation -jump-threading -pgo-memop-opt -scalarizer -coro-cleanup -newgvn input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9877641824249169,12.073808193206787,opt -functionattrs -libcalls-shrinkwrap -loop-interchange -ipsccp -gvn -lower-widenable-condition -sroa -lower-guard-intrinsic -adce -loop-versioning-licm -licm -coro-cleanup -sccp -sancov -dse -barrier -infer-address-spaces -loop-interchange -licm -loop-unroll-and-jam -lower-expect -ipsccp -rewrite-statepoints-for-gc -mergefunc -loop-versioning-licm -coro-split -loop-instsimplify -rpo-functionattrs -early-cse-memssa -flattencfg -called-value-propagation -instcombine -infer-address-spaces -loop-versioning -guard-widening -gvn -globaldce -partially-inline-libcalls -nary-reassociate -indvars -inject-tli-mappings -loop-vectorize -lowerswitch -coro-early -ipconstprop -alignment-from-assumptions -bdce -aggressive-instcombine -loop-simplifycfg -globalopt -speculative-execution -lower-guard-intrinsic -memcpyopt -gvn -sancov -coro-early -loop-guard-widening -slp-vectorizer -mergefunc -loop-reduce -load-store-vectorizer -loop-fusion -lower-expect -callsite-splitting -inject-tli-mappings -scalarizer -die -coro-cleanup -simplifycfg -loop-sink -lower-widenable-condition -inject-tli-mappings -dse -libcalls-shrinkwrap -strip -ipsccp -gvn -constprop -die -ee-instrument -gvn -tailcallelim input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9888765294771972,13.508204936981201,opt -globalopt -mldst-motion -scalarizer -float2int -barrier -loop-simplify -elim-avail-extern -loop-reduce -die -newgvn -loop-fusion -cross-dso-cfi -loop-versioning-licm -infer-address-spaces -loop-distribute -slp-vectorizer -deadargelim -loop-simplifycfg -coro-elide -partial-inliner -hotcoldsplit -gvn -simplifycfg -correlated-propagation -sancov -mergereturn -lowerswitch -attributor -nary-reassociate -die -barrier -loop-reroll -loop-load-elim -libcalls-shrinkwrap -break-crit-edges -separate-const-offset-from-gep -adce -gvn -licm -die -globalsplit -post-inline-ee-instrument -float2int -bdce -loop-guard-widening -post-inline-ee-instrument -strip-nondebug -mergefunc -bdce -break-crit-edges -inject-tli-mappings -strip -sccp -jump-threading -loop-versioning-licm -constprop -functionattrs -indvars -mergereturn -flattencfg -instcombine -loop-distribute -mem2reg -loop-deletion -loop-unroll-and-jam -strip-dead-prototypes -coro-early -lcssa -rewrite-statepoints-for-gc -partially-inline-libcalls -loop-fusion -bdce -strip-nondebug -loop-reroll -functionattrs -lowerswitch -mldst-motion -jump-threading -newgvn -bdce -reg2mem -div-rem-pairs -name-anon-globals -lower-guard-intrinsic -sancov -instnamer -add-discriminators -always-inline -mergefunc -loop-load-elim -loop-reroll -loop-unroll -load-store-vectorizer -slp-vectorizer -loop-sink -elim-avail-extern -strip-nondebug -constprop -pgo-memop-opt -ee-instrument -loop-rotate -sink -coro-split -lcssa -dse -early-cse-memssa -pgo-memop-opt -lower-matrix-intrinsics -globalopt -newgvn -mergefunc -loop-distribute -loop-interchange -partial-inliner -loop-versioning -coro-elide -globalsplit -rewrite-statepoints-for-gc -irce -libcalls-shrinkwrap -sink -simplifycfg -constmerge -loop-unroll-and-jam -lowerinvoke -gvn -newgvn -loop-reroll -lower-constant-intrinsics -aggressive-instcombine -called-value-propagation -strip-dead-prototypes -globalsplit -rpo-functionattrs -gvn -div-rem-pairs -bdce -simplifycfg -forceattrs -callsite-splitting -insert-gcov-profiling -sroa -strip -simplifycfg -sccp -instnamer -globalopt -reassociate input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9911012235817576,12.252049684524536,opt -functionattrs -instsimplify -callsite-splitting -lowerswitch -aggressive-instcombine -licm -always-inline -nary-reassociate -cross-dso-cfi -add-discriminators -bdce -loop-interchange -redundant-dbg-inst-elim -slp-vectorizer -alignment-from-assumptions -ipsccp -coro-cleanup -lower-widenable-condition -div-rem-pairs -div-rem-pairs -correlated-propagation -loop-deletion -ee-instrument -mem2reg -mem2reg -gvn-hoist -memcpyopt -loop-fusion -inject-tli-mappings -consthoist -loop-instsimplify -strip-debug-declare -loop-instsimplify -slsr -adce -constmerge -loop-guard-widening -loop-fusion -loop-instsimplify -redundant-dbg-inst-elim -lowerinvoke -sccp -speculative-execution -strip-debug-declare -sancov -gvn-hoist -pgo-memop-opt -instcombine -aggressive-instcombine -speculative-execution -instsimplify -reassociate -irce -guard-widening -gvn -inferattrs -elim-avail-extern -alignment-from-assumptions -instnamer -guard-widening -loop-instsimplify -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9933259176863184,11.92369031906128,opt -loop-predication -insert-gcov-profiling -forceattrs -speculative-execution -globalsplit -mldst-motion -pgo-memop-opt -functionattrs -called-value-propagation -loop-guard-widening -aggressive-instcombine -infer-address-spaces -indvars -partially-inline-libcalls -simplifycfg -functionattrs -partially-inline-libcalls -break-crit-edges -loop-vectorize -loop-simplify -adce -loop-interchange -mergefunc -hotcoldsplit -globalopt -partial-inliner -adce -loop-idiom -partial-inliner -coro-early -loop-unswitch -name-anon-globals -add-discriminators -scalarizer -sroa -argpromotion -separate-const-offset-from-gep -mergereturn -loop-instsimplify -pgo-memop-opt -lower-widenable-condition -instsimplify -globaldce -loop-vectorize -coro-split -newgvn -coro-elide -attributor -strip-dead-prototypes -pgo-memop-opt -ipconstprop -dce -dse -loop-distribute -alignment-from-assumptions -lower-guard-intrinsic -correlated-propagation -gvn -loop-vectorize -ipsccp -mergefunc -simplifycfg -ipconstprop -cross-dso-cfi -flattencfg -loop-sink -flattencfg -elim-avail-extern -mldst-motion -loop-guard-widening -simplifycfg -loop-reduce -deadargelim -slp-vectorizer -simplifycfg -loop-sink -loop-fusion -rpo-functionattrs -callsite-splitting -loop-instsimplify -loop-simplifycfg -break-crit-edges -nary-reassociate -constmerge -die -simplifycfg -strip -functionattrs -loop-distribute -loop-reduce -ipconstprop -load-store-vectorizer -loop-interchange -licm -barrier -prune-eh -tailcallelim -scalarizer -loop-guard-widening -float2int -slsr -licm -mldst-motion -called-value-propagation -strip -coro-cleanup -div-rem-pairs -loop-distribute -sroa -loop-unroll -strip-nondebug -lower-constant-intrinsics -constmerge -callsite-splitting -break-crit-edges -rewrite-statepoints-for-gc -forceattrs -flattencfg -instcombine -consthoist -post-inline-ee-instrument -globaldce -float2int -partial-inliner -mergeicmps -aggressive-instcombine -memcpyopt -simplifycfg -gvn input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9966629588431589,14.353923320770264,opt -deadargelim -loweratomic -loop-reduce -div-rem-pairs -jump-threading -loop-interchange -slp-vectorizer -lower-constant-intrinsics -loop-distribute -lower-constant-intrinsics -inferattrs -strip -gvn -simplifycfg -loweratomic -loop-predication -bdce -lower-guard-intrinsic -loop-distribute -ee-instrument -globalsplit -loop-fusion -partial-inliner -loop-simplifycfg -loop-reroll -dse -loop-guard-widening -correlated-propagation -dse -insert-gcov-profiling -called-value-propagation -loop-deletion -loop-vectorize -strip-debug-declare -name-anon-globals -argpromotion -loop-data-prefetch -strip-dead-prototypes -lower-matrix-intrinsics -called-value-propagation -argpromotion -mem2reg -alignment-from-assumptions -dse -flattencfg -partially-inline-libcalls -ee-instrument -flattencfg -loop-load-elim -sroa -ipconstprop -indvars -deadargelim -flattencfg -loop-unroll -post-inline-ee-instrument -loweratomic -early-cse-memssa -globaldce -nary-reassociate -globaldce -break-crit-edges -globalopt -loop-instsimplify -coro-cleanup -indvars -mergereturn -loop-simplifycfg -sccp -reassociate -jump-threading -mergereturn -tailcallelim -break-crit-edges -loop-distribute -coro-early -prune-eh -partially-inline-libcalls -alignment-from-assumptions -loop-versioning-licm -prune-eh -reassociate -loop-versioning -callsite-splitting -nary-reassociate -gvn-hoist -loop-idiom -strip-nondebug -loop-predication -sroa -loop-unroll-and-jam -lower-expect -loop-data-prefetch -prune-eh -inferattrs -licm -mem2reg -memcpyopt -jump-threading -mergefunc -aggressive-instcombine -always-inline -dse -inject-tli-mappings -correlated-propagation -inject-tli-mappings -loop-simplifycfg -break-crit-edges -sroa -div-rem-pairs -globaldce -memcpyopt -rpo-functionattrs -sroa -speculative-execution -loop-predication -mergefunc -hotcoldsplit -strip-nondebug -instcombine -rpo-functionattrs -break-crit-edges -loop-predication -load-store-vectorizer -loop-guard-widening -loop-reduce -strip-debug-declare -loop-vectorize -ee-instrument -constmerge -indvars -mldst-motion -post-inline-ee-instrument -loop-simplifycfg -gvn-hoist -functionattrs -simple-loop-unswitch -mergeicmps -libcalls-shrinkwrap -loop-distribute -ipconstprop -loop-deletion -mldst-motion -deadargelim -simple-loop-unswitch -loweratomic -partial-inliner -strip -elim-avail-extern -coro-cleanup -coro-elide -loop-simplify -elim-avail-extern -scalarizer -loop-unroll -add-discriminators -speculative-execution -strip-debug-declare -instcombine -loop-simplifycfg -post-inline-ee-instrument -break-crit-edges -nary-reassociate -die -div-rem-pairs -simplifycfg -licm -mergeicmps -strip-nondebug -gvn input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9977753058954394,12.289266586303711,opt -correlated-propagation -die -mergefunc -functionattrs -loop-sink -coro-early -strip -loop-unroll -sccp -licm -scalarizer -loop-simplifycfg -coro-early -rpo-functionattrs -strip-dead-prototypes -simplifycfg -argpromotion -speculative-execution -aggressive-instcombine -load-store-vectorizer -name-anon-globals -canonicalize-aliases -callsite-splitting -lower-widenable-condition -loop-load-elim -functionattrs -canonicalize-aliases -deadargelim -tailcallelim -lower-widenable-condition -inject-tli-mappings -loop-versioning -lower-expect -reassociate -early-cse-memssa -elim-avail-extern -break-crit-edges -lower-guard-intrinsic -sink -partially-inline-libcalls -speculative-execution -mergefunc -loop-reroll -loop-distribute -globalopt -separate-const-offset-from-gep -lowerswitch -licm -lower-expect -partially-inline-libcalls -loop-deletion -loop-reduce -globalsplit -hotcoldsplit -redundant-dbg-inst-elim -loop-idiom -sroa -infer-address-spaces -hotcoldsplit -functionattrs -argpromotion -post-inline-ee-instrument -functionattrs -lower-widenable-condition -separate-const-offset-from-gep -always-inline -separate-const-offset-from-gep -constmerge -adce -slp-vectorizer -lower-constant-intrinsics -loop-simplifycfg -constprop -strip-dead-prototypes -loop-unroll -rewrite-statepoints-for-gc -ipsccp -bdce -loop-versioning-licm -jump-threading -reg2mem -licm -rpo-functionattrs -instnamer -newgvn -loop-simplifycfg -loop-vectorize -barrier -scalarizer -loop-guard-widening -post-inline-ee-instrument -loop-interchange -gvn -lower-widenable-condition -loop-versioning -always-inline -instcombine -ipsccp -deadargelim -flattencfg -sccp -loop-deletion -loop-idiom -inferattrs -globalsplit -licm -jump-threading -cross-dso-cfi -irce -always-inline -dce -ipconstprop -dce -jump-threading -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/patricia,1.0022246941045605,12.50986385345459,opt -redundant-dbg-inst-elim -strip-nondebug -flattencfg -loop-unroll-and-jam -correlated-propagation -loop-versioning -loop-vectorize -die -coro-early -hotcoldsplit -ipsccp -functionattrs -lower-constant-intrinsics -gvn -mergeicmps -globaldce -canonicalize-aliases -instsimplify -lowerinvoke -flattencfg -loop-fusion -lower-expect -constmerge -scalarizer -ee-instrument -strip-nondebug -dse -gvn -deadargelim -consthoist -nary-reassociate -slsr -instnamer -reassociate -indvars -memcpyopt -tailcallelim -callsite-splitting -partially-inline-libcalls -instsimplify -correlated-propagation -lower-guard-intrinsic -coro-early -coro-split -canonicalize-aliases -mergefunc -ee-instrument -speculative-execution -loop-fusion -callsite-splitting -partially-inline-libcalls -barrier -libcalls-shrinkwrap -lowerswitch -sccp -add-discriminators -sccp -inject-tli-mappings -div-rem-pairs -reassociate -canonicalize-aliases -loop-versioning-licm -coro-cleanup -instsimplify -coro-cleanup -mergefunc -forceattrs -insert-gcov-profiling -barrier -coro-elide -die -loop-distribute -strip-dead-prototypes -adce -irce -nary-reassociate -instsimplify -loop-load-elim -load-store-vectorizer -rewrite-statepoints-for-gc -speculative-execution -libcalls-shrinkwrap -inferattrs -post-inline-ee-instrument -loop-unroll -mergeicmps -loop-distribute -float2int -speculative-execution -coro-cleanup -nary-reassociate -forceattrs -loop-unroll -mergereturn -post-inline-ee-instrument -post-inline-ee-instrument -loop-unroll-and-jam -mergereturn -lcssa -slsr -simple-loop-unswitch -strip-dead-prototypes -mergeicmps -coro-cleanup -globalsplit -inject-tli-mappings -nary-reassociate -loop-fusion -guard-widening -gvn -sink -always-inline -bdce -separate-const-offset-from-gep -functionattrs -instcombine -loop-distribute -loop-guard-widening -pgo-memop-opt -mergeicmps -mergereturn -canonicalize-aliases -coro-elide -coro-split -coro-elide -gvn-hoist -float2int -flattencfg -loop-simplify -aggressive-instcombine -loop-versioning-licm -loop-predication -mergefunc -ipconstprop -simple-loop-unswitch -libcalls-shrinkwrap -coro-split -loop-data-prefetch -always-inline -bdce -speculative-execution -alignment-from-assumptions -lower-constant-intrinsics -attributor -globalopt -lowerswitch -coro-elide -name-anon-globals -instnamer -elim-avail-extern -dse -ee-instrument -loop-versioning -float2int -loop-simplify -coro-split -always-inline -barrier -tailcallelim -loop-versioning-licm -loop-simplifycfg -called-value-propagation -tailcallelim -always-inline -pgo-memop-opt -globaldce -scalarizer -lower-expect -called-value-propagation -newgvn -separate-const-offset-from-gep -called-value-propagation -sink -name-anon-globals -adce -instcombine -name-anon-globals -guard-widening -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/qsort,1.0959752321981424,12.017142057418823,opt -lowerinvoke -loop-unroll -globalsplit -loop-vectorize -loop-fusion -loop-predication -loop-deletion -lowerswitch -loop-reroll -lowerswitch -lowerswitch -always-inline -loop-interchange -strip -loop-fusion -deadargelim -newgvn -partially-inline-libcalls -lowerswitch -ee-instrument -loop-reroll -loop-unswitch -constmerge -loop-instsimplify -sancov -loop-reroll -mergeicmps -constprop -ipsccp -loop-instsimplify -memcpyopt -strip -nary-reassociate -strip -mem2reg -sink -redundant-dbg-inst-elim -lower-constant-intrinsics -lowerinvoke -coro-early -prune-eh -guard-widening -loop-versioning-licm -loop-simplify -loop-deletion -sroa -canonicalize-aliases -load-store-vectorizer -inferattrs -dce -barrier -loop-deletion -sroa -barrier -loop-unroll-and-jam -lower-expect -bdce -strip-dead-prototypes -dse -elim-avail-extern -bdce -inject-tli-mappings -inject-tli-mappings -gvn-hoist -tailcallelim -loop-predication -irce -dce -coro-elide -deadargelim -load-store-vectorizer -correlated-propagation -aggressive-instcombine -loop-unroll -redundant-dbg-inst-elim -sccp -simplifycfg -loop-versioning -loop-unroll-and-jam -loop-interchange -mem2reg -div-rem-pairs -inject-tli-mappings -flattencfg -barrier -lowerinvoke -memcpyopt -speculative-execution -lowerinvoke -loop-sink -called-value-propagation -slsr -separate-const-offset-from-gep -bdce -bdce -simplifycfg -lower-matrix-intrinsics -libcalls-shrinkwrap -loop-unroll-and-jam -irce -instcombine input.bc -o output.bc +benchmark://cbench-v1/qsort,1.0990712074303406,11.887055158615112,opt -lower-constant-intrinsics -coro-cleanup -loop-instsimplify -mergereturn -pgo-memop-opt -coro-elide -gvn -sink -consthoist -callsite-splitting -dce -partial-inliner -mem2reg -loop-simplify -instnamer -nary-reassociate -simple-loop-unswitch -memcpyopt -flattencfg -alignment-from-assumptions -loop-instsimplify -pgo-memop-opt -insert-gcov-profiling -constprop -loop-versioning -coro-elide -speculative-execution -globalsplit -infer-address-spaces -jump-threading -guard-widening -partially-inline-libcalls -consthoist -break-crit-edges -strip-nondebug -loop-data-prefetch -reassociate -newgvn -coro-split -newgvn -simplifycfg -strip-debug-declare -simplifycfg -lcssa -loop-idiom -coro-elide -loop-predication -loop-load-elim -ee-instrument -reassociate -always-inline -simplifycfg -nary-reassociate -functionattrs -elim-avail-extern -load-store-vectorizer -jump-threading -flattencfg -lower-widenable-condition -instcombine input.bc -o output.bc +benchmark://cbench-v1/qsort,1.1021671826625385,11.789689779281616,opt -early-cse-memssa -attributor -loop-simplify -libcalls-shrinkwrap -reassociate -instnamer -strip-dead-prototypes -functionattrs -mergeicmps -prune-eh -globalsplit -dce -loop-predication -globalsplit -mergereturn -scalarizer -mem2reg -loop-distribute -div-rem-pairs -mergeicmps -partially-inline-libcalls -elim-avail-extern -insert-gcov-profiling -loop-guard-widening -loop-data-prefetch -irce -separate-const-offset-from-gep -barrier -lower-expect -lower-guard-intrinsic -sancov -mergeicmps -partially-inline-libcalls -slsr -sancov -separate-const-offset-from-gep -gvn-hoist -loop-vectorize -load-store-vectorizer -constprop -loop-unroll -aggressive-instcombine -sink -loop-sink -loop-interchange -mergefunc -loop-data-prefetch -simplifycfg -instsimplify -lower-guard-intrinsic -forceattrs -loop-interchange -globaldce -pgo-memop-opt -ipsccp -alignment-from-assumptions -licm -mergefunc -sccp -constprop -infer-address-spaces -insert-gcov-profiling -loop-simplifycfg -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/qsort,1.105263157894737,11.881323337554932,opt -loop-predication -insert-gcov-profiling -strip-nondebug -loop-distribute -licm -instnamer -ipconstprop -coro-elide -loop-guard-widening -loop-versioning-licm -coro-elide -globalopt -mergereturn -mergeicmps -infer-address-spaces -sink -speculative-execution -cross-dso-cfi -slp-vectorizer -argpromotion -gvn-hoist -ipconstprop -constprop -sroa -loop-instsimplify -simplifycfg -instcombine -instcombine -lower-constant-intrinsics -lowerswitch -loop-sink -irce -early-cse-memssa -instnamer -loop-instsimplify -sancov -consthoist -pgo-memop-opt -coro-cleanup -loop-unswitch -loop-instsimplify -lower-expect -load-store-vectorizer -newgvn input.bc -o output.bc +benchmark://cbench-v1/qsort,1.108359133126935,11.847872734069824,opt -correlated-propagation -lower-expect -sink -lowerinvoke -newgvn -sink -break-crit-edges -break-crit-edges -loop-idiom -gvn -called-value-propagation -flattencfg -scalarizer -loop-load-elim -slp-vectorizer -correlated-propagation -sancov -argpromotion -alignment-from-assumptions -strip-nondebug -newgvn -lower-matrix-intrinsics -div-rem-pairs -ee-instrument -ee-instrument -infer-address-spaces -mergereturn -lowerinvoke -simplifycfg -instcombine -licm -rpo-functionattrs -constmerge -loop-deletion -newgvn -cross-dso-cfi -jump-threading input.bc -o output.bc +benchmark://cbench-v1/qsort,1.108359133126935,11.972721815109253,opt -separate-const-offset-from-gep -coro-elide -loop-interchange -indvars -loop-predication -guard-widening -irce -called-value-propagation -globalsplit -redundant-dbg-inst-elim -partially-inline-libcalls -rewrite-statepoints-for-gc -mergereturn -add-discriminators -dce -jump-threading -loop-data-prefetch -redundant-dbg-inst-elim -inject-tli-mappings -mem2reg -loop-versioning-licm -redundant-dbg-inst-elim -insert-gcov-profiling -lowerinvoke -gvn -mldst-motion -simple-loop-unswitch -loop-fusion -constmerge -alignment-from-assumptions -indvars -bdce -tailcallelim -elim-avail-extern -strip-dead-prototypes -die -simple-loop-unswitch -instcombine -partially-inline-libcalls -loweratomic -mergefunc -lowerinvoke -ee-instrument -rpo-functionattrs -lower-constant-intrinsics -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/qsort,1.108359133126935,12.017470836639404,opt -loop-deletion -indvars -loop-reroll -slp-vectorizer -loop-deletion -rewrite-statepoints-for-gc -coro-early -lcssa -loop-versioning -loop-reduce -strip-debug-declare -dce -guard-widening -mem2reg -infer-address-spaces -lower-constant-intrinsics -indvars -constmerge -attributor -lowerswitch -loop-simplifycfg -break-crit-edges -lcssa -dse -die -coro-elide -ipconstprop -alignment-from-assumptions -mergereturn -gvn -sancov -simplifycfg -loop-sink -hotcoldsplit -loop-deletion -lower-guard-intrinsic -float2int -loop-fusion -add-discriminators -instcombine -gvn-hoist -loop-idiom -gvn input.bc -o output.bc +benchmark://cbench-v1/qsort,1.108359133126935,12.212085723876953,opt -loop-vectorize -strip -globalsplit -loop-reroll -guard-widening -gvn -post-inline-ee-instrument -globalopt -bdce -mergeicmps -sancov -loop-guard-widening -sancov -break-crit-edges -tailcallelim -canonicalize-aliases -strip -add-discriminators -globalopt -globalsplit -flattencfg -loweratomic -globalsplit -attributor -mergeicmps -cross-dso-cfi -loop-simplify -sancov -partial-inliner -strip-debug-declare -prune-eh -argpromotion -gvn -reg2mem -attributor -mem2reg -forceattrs -newgvn -coro-early -strip-nondebug -loop-reroll -strip-debug-declare -loop-unswitch -loop-unroll -lower-widenable-condition -licm -loop-distribute -loop-distribute -loop-reroll -sancov -lower-constant-intrinsics -loop-deletion -coro-split -bdce -mem2reg -loop-simplify -canonicalize-aliases -mldst-motion -loop-sink -gvn-hoist -inject-tli-mappings -loop-instsimplify -mergereturn -coro-early -constmerge -constprop -instnamer -lower-matrix-intrinsics -partial-inliner -float2int -flattencfg -die -lower-constant-intrinsics -add-discriminators -lcssa -add-discriminators -mldst-motion -coro-elide -instsimplify -div-rem-pairs -instcombine -loop-predication -strip -insert-gcov-profiling -indvars -lowerswitch -nary-reassociate -dce -loweratomic -insert-gcov-profiling -libcalls-shrinkwrap -mldst-motion -instcombine -lower-widenable-condition -inject-tli-mappings -globalopt -lowerinvoke -gvn-hoist -strip-nondebug -loop-simplifycfg -elim-avail-extern -loop-distribute -rpo-functionattrs -memcpyopt -globalopt -barrier -consthoist -simple-loop-unswitch -load-store-vectorizer -sancov -partially-inline-libcalls -lower-constant-intrinsics -pgo-memop-opt -canonicalize-aliases -deadargelim -load-store-vectorizer -loop-interchange -mem2reg -memcpyopt -strip-nondebug -infer-address-spaces -simple-loop-unswitch -jump-threading -name-anon-globals -pgo-memop-opt -mergeicmps -instcombine -ipconstprop -sink -argpromotion -adce -cross-dso-cfi -partially-inline-libcalls -tailcallelim -sccp -infer-address-spaces -inject-tli-mappings -mergefunc -strip-debug-declare -loop-data-prefetch -flattencfg -dce -nary-reassociate -coro-cleanup -die -strip-dead-prototypes -newgvn -attributor -instnamer -early-cse-memssa -mergeicmps -ee-instrument -forceattrs -loop-simplify -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/qsort,1.1145510835913313,11.989583253860474,opt -coro-cleanup -reg2mem -rewrite-statepoints-for-gc -dse -partially-inline-libcalls -jump-threading -gvn-hoist -consthoist -pgo-memop-opt -loweratomic -guard-widening -globalopt -deadargelim -scalarizer -strip-debug-declare -tailcallelim -loop-reduce -coro-split -mem2reg -add-discriminators -loweratomic -loop-sink -globaldce -sancov -sink -load-store-vectorizer -loop-unroll -hotcoldsplit -add-discriminators -strip-dead-prototypes -gvn-hoist -div-rem-pairs -jump-threading -coro-cleanup -constmerge -slsr -gvn -lower-constant-intrinsics -lower-expect -rewrite-statepoints-for-gc -div-rem-pairs -cross-dso-cfi -infer-address-spaces -ee-instrument -nary-reassociate -loop-unswitch -sancov -loop-reroll -rpo-functionattrs -slp-vectorizer -insert-gcov-profiling -simple-loop-unswitch -lowerswitch -consthoist -argpromotion -instcombine -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/qsort,1.1207430340557278,11.769915342330933,opt -separate-const-offset-from-gep -loop-fusion -forceattrs -always-inline -slsr -loop-interchange -argpromotion -loop-load-elim -float2int -flattencfg -speculative-execution -sroa -div-rem-pairs -always-inline -float2int -mergefunc -dce -newgvn -lower-constant-intrinsics -strip-dead-prototypes -coro-split -constmerge -lower-matrix-intrinsics -lower-widenable-condition -lcssa -always-inline -instcombine -name-anon-globals -float2int -attributor -loop-interchange -post-inline-ee-instrument -coro-elide -loweratomic -newgvn -instcombine -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.093522422384055,12.692811965942383,opt -mergefunc -rpo-functionattrs -newgvn -strip-dead-prototypes -separate-const-offset-from-gep -loop-data-prefetch -loop-versioning -canonicalize-aliases -lower-matrix-intrinsics -mem2reg -instcombine -post-inline-ee-instrument -globaldce -reassociate -mergereturn -instcombine -gvn-hoist -instcombine -deadargelim -strip-nondebug -float2int -dce -memcpyopt -separate-const-offset-from-gep -hotcoldsplit -loop-data-prefetch -loop-simplify -attributor -partially-inline-libcalls -loop-interchange -die -bdce -break-crit-edges -bdce -mergeicmps -infer-address-spaces -strip-debug-declare -strip -speculative-execution -coro-cleanup -coro-early -canonicalize-aliases -loop-guard-widening -slp-vectorizer -mem2reg -loop-simplify -name-anon-globals -callsite-splitting -functionattrs -libcalls-shrinkwrap -globalopt -loop-rotate -slsr -speculative-execution -strip-nondebug -lowerinvoke -loop-guard-widening -mergeicmps -called-value-propagation -flattencfg -strip-nondebug -gvn -cross-dso-cfi -insert-gcov-profiling -loop-data-prefetch -simplifycfg -deadargelim -slsr -inferattrs -globaldce -rewrite-statepoints-for-gc -post-inline-ee-instrument -memcpyopt -constmerge -consthoist -speculative-execution -lower-matrix-intrinsics -coro-cleanup -gvn-hoist -adce -loop-instsimplify -loweratomic -early-cse-memssa -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.0946722882330395,12.9319007396698,opt -loop-data-prefetch -sink -mldst-motion -consthoist -loop-versioning -consthoist -reassociate -guard-widening -div-rem-pairs -rewrite-statepoints-for-gc -ipconstprop -instnamer -add-discriminators -slp-vectorizer -flattencfg -functionattrs -loop-unroll -loop-data-prefetch -separate-const-offset-from-gep -ee-instrument -callsite-splitting -strip-nondebug -irce -name-anon-globals -loop-distribute -ipconstprop -loop-instsimplify -constmerge -attributor -gvn-hoist -loop-unswitch -loop-distribute -aggressive-instcombine -loop-interchange -dse -instsimplify -consthoist -mem2reg -lower-expect -loop-unroll-and-jam -gvn-hoist -newgvn -argpromotion -float2int -coro-early -called-value-propagation -loop-fusion -mldst-motion -elim-avail-extern -loop-simplifycfg -loop-load-elim -strip-nondebug -simplifycfg -coro-elide -loop-idiom -barrier -lowerinvoke -die -constprop -callsite-splitting -barrier -guard-widening -loweratomic -mem2reg -name-anon-globals -loop-predication -ipsccp -lower-matrix-intrinsics -prune-eh -gvn -always-inline -cross-dso-cfi -loop-interchange -dse -argpromotion -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.0965887313146796,12.338773727416992,opt -loop-predication -loop-predication -infer-address-spaces -loop-unroll-and-jam -prune-eh -loop-reduce -constmerge -mergeicmps -loop-distribute -attributor -lowerinvoke -loop-deletion -loop-sink -coro-elide -reg2mem -licm -constmerge -instsimplify -mergefunc -reg2mem -sancov -bdce -strip -forceattrs -div-rem-pairs -loop-distribute -loop-data-prefetch -functionattrs -loop-idiom -loop-versioning -correlated-propagation -inject-tli-mappings -partial-inliner -licm -loweratomic -strip-nondebug -coro-cleanup -reg2mem -ipconstprop -loop-deletion -loop-deletion -lower-expect -constprop -coro-split -strip-nondebug -name-anon-globals -name-anon-globals -break-crit-edges -simple-loop-unswitch -sink -globaldce -sccp -reg2mem -loop-load-elim -speculative-execution -sroa -inferattrs -strip-dead-prototypes -early-cse-memssa -deadargelim -name-anon-globals -prune-eh -gvn-hoist -loop-data-prefetch -coro-elide -strip-debug-declare -constmerge -slp-vectorizer -partially-inline-libcalls -callsite-splitting -loop-deletion -simplifycfg -loop-guard-widening -early-cse-memssa -ipconstprop -break-crit-edges -rpo-functionattrs -loop-versioning-licm -coro-early -mem2reg -strip-debug-declare -instsimplify -callsite-splitting -forceattrs -simplifycfg -deadargelim -jump-threading -lower-guard-intrinsic -loop-distribute -dse -tailcallelim -constmerge -rewrite-statepoints-for-gc -elim-avail-extern -lower-matrix-intrinsics -dce -partially-inline-libcalls -insert-gcov-profiling -name-anon-globals -partially-inline-libcalls -infer-address-spaces -coro-split -loop-sink -gvn -lower-expect -simple-loop-unswitch -loop-versioning -loop-deletion -constprop -rpo-functionattrs -jump-threading -speculative-execution -lcssa -lcssa -hotcoldsplit -insert-gcov-profiling -elim-avail-extern -lower-matrix-intrinsics -loop-unroll-and-jam -elim-avail-extern -reassociate -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.0969720199310082,13.111221075057983,opt -functionattrs -loop-simplify -early-cse-memssa -sccp -dce -loweratomic -tailcallelim -bdce -cross-dso-cfi -inject-tli-mappings -loop-unswitch -instsimplify -loop-versioning -aggressive-instcombine -bdce -gvn-hoist -lower-widenable-condition -argpromotion -elim-avail-extern -coro-cleanup -elim-avail-extern -instnamer -lower-widenable-condition -loop-versioning -loop-interchange -forceattrs -lowerinvoke -lcssa -bdce -nary-reassociate -add-discriminators -correlated-propagation -sancov -name-anon-globals -globalsplit -loop-instsimplify -tailcallelim -sroa -loop-unroll-and-jam -partially-inline-libcalls -mergefunc -deadargelim -ipsccp -early-cse-memssa -lower-matrix-intrinsics -scalarizer -redundant-dbg-inst-elim -lower-matrix-intrinsics -newgvn -globalsplit -loop-rotate -infer-address-spaces -correlated-propagation -infer-address-spaces -sccp -sroa -instcombine -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.097355308547336,12.750953435897827,opt -sroa -elim-avail-extern -coro-split -canonicalize-aliases -float2int -simple-loop-unswitch -correlated-propagation -pgo-memop-opt -rewrite-statepoints-for-gc -alignment-from-assumptions -die -cross-dso-cfi -newgvn -simplifycfg -loweratomic -insert-gcov-profiling -deadargelim -separate-const-offset-from-gep -float2int -loop-load-elim -barrier -separate-const-offset-from-gep -bdce -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.0992717516289765,12.554092168807983,opt -tailcallelim -globalopt -post-inline-ee-instrument -dse -correlated-propagation -lowerinvoke -mergefunc -mldst-motion -irce -lower-widenable-condition -callsite-splitting -coro-early -rpo-functionattrs -strip-dead-prototypes -coro-cleanup -flattencfg -alignment-from-assumptions -lower-matrix-intrinsics -globaldce -coro-early -loop-instsimplify -lowerinvoke -mldst-motion -canonicalize-aliases -globalopt -lower-constant-intrinsics -simplifycfg -hotcoldsplit -gvn-hoist -flattencfg -memcpyopt -tailcallelim -sroa -partially-inline-libcalls -strip -hotcoldsplit -newgvn -loop-idiom -dse -dse -instcombine -slp-vectorizer -slp-vectorizer -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.099271751628977,12.885164499282837,opt -coro-early -loop-instsimplify -argpromotion -strip-dead-prototypes -loop-simplify -sccp -bdce -constprop -mergereturn -separate-const-offset-from-gep -libcalls-shrinkwrap -jump-threading -loop-reduce -indvars -functionattrs -lowerinvoke -alignment-from-assumptions -constprop -functionattrs -strip-dead-prototypes -loop-data-prefetch -inject-tli-mappings -bdce -coro-cleanup -dse -lowerinvoke -tailcallelim -sroa -instsimplify -consthoist -loop-simplifycfg -sancov -libcalls-shrinkwrap -gvn -loop-data-prefetch -partially-inline-libcalls -coro-early -dce -instcombine -mergeicmps -attributor -partial-inliner -mldst-motion -instnamer -loop-load-elim -lower-expect -correlated-propagation -speculative-execution -coro-split -cross-dso-cfi -indvars -early-cse-memssa -canonicalize-aliases -gvn-hoist -redundant-dbg-inst-elim -lcssa -simple-loop-unswitch -lower-widenable-condition -coro-early -loop-distribute -constprop -coro-split -pgo-memop-opt -lower-constant-intrinsics -infer-address-spaces -loop-fusion -constmerge -nary-reassociate -inject-tli-mappings -cross-dso-cfi -mergereturn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1004216174779609,15.460011005401611,opt -die -infer-address-spaces -loop-unroll -sroa -elim-avail-extern -cross-dso-cfi -mldst-motion -barrier -mergefunc -loop-sink -aggressive-instcombine -correlated-propagation -scalarizer -scalarizer -break-crit-edges -add-discriminators -lower-guard-intrinsic -instcombine -barrier -pgo-memop-opt -float2int -called-value-propagation -sccp -lower-guard-intrinsic -speculative-execution -elim-avail-extern -mergefunc -loop-simplify -coro-split -globalopt -infer-address-spaces -adce -loop-idiom -ipconstprop -loop-guard-widening -indvars -lower-expect -aggressive-instcombine -loop-idiom -deadargelim -cross-dso-cfi -insert-gcov-profiling -lower-widenable-condition -loop-reroll -ipsccp -break-crit-edges -early-cse-memssa -loop-reroll -div-rem-pairs -canonicalize-aliases -functionattrs -die -forceattrs -coro-early -tailcallelim -adce -prune-eh -inject-tli-mappings -guard-widening -slsr -gvn -sroa -loop-load-elim -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1004216174779613,12.831381559371948,opt -instcombine -float2int -globalopt -redundant-dbg-inst-elim -lower-matrix-intrinsics -loop-versioning -argpromotion -rpo-functionattrs -loop-interchange -loop-data-prefetch -barrier -aggressive-instcombine -loop-simplifycfg -aggressive-instcombine -rewrite-statepoints-for-gc -canonicalize-aliases -mergeicmps -barrier -partially-inline-libcalls -always-inline -aggressive-instcombine -gvn-hoist -insert-gcov-profiling -ipsccp -sink -loop-instsimplify -loop-guard-widening -argpromotion -lower-guard-intrinsic -hotcoldsplit -mergefunc -ipconstprop -redundant-dbg-inst-elim -sroa -lowerinvoke -slsr -newgvn -dce -break-crit-edges -simplifycfg -infer-address-spaces -instnamer -functionattrs -die -die -scalarizer -infer-address-spaces -strip -lowerinvoke -jump-threading -correlated-propagation -libcalls-shrinkwrap -constmerge -loweratomic -lower-expect -loop-reroll -scalarizer -ipsccp -ee-instrument -lower-widenable-condition -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1023380605596014,14.866809129714966,opt -mergeicmps -mergereturn -strip-debug-declare -globaldce -mergereturn -loop-instsimplify -alignment-from-assumptions -float2int -slp-vectorizer -sccp -flattencfg -callsite-splitting -infer-address-spaces -always-inline -loop-simplifycfg -flattencfg -newgvn -mem2reg -cross-dso-cfi -lower-matrix-intrinsics -instcombine -early-cse-memssa -reassociate -infer-address-spaces -rewrite-statepoints-for-gc -loop-simplifycfg -instnamer -coro-cleanup -loop-data-prefetch -loop-versioning-licm -correlated-propagation -loop-reroll -strip-nondebug -irce -loop-versioning-licm -ipconstprop -functionattrs -simplifycfg -argpromotion -sroa -memcpyopt -name-anon-globals -lcssa -sink -die -loop-simplify -forceattrs -strip -reg2mem -irce -loop-deletion -slsr -elim-avail-extern -mem2reg -lower-expect -lowerinvoke -coro-split -coro-split -dce -strip-dead-prototypes -float2int -loop-instsimplify -ipsccp -loweratomic -loop-predication -newgvn -ipconstprop -mergeicmps -float2int -simple-loop-unswitch -licm -ipsccp -loop-distribute -mergefunc -slsr -inject-tli-mappings -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/sha,1.4682274247491636,11.895204067230225,opt -lowerswitch -loop-reduce -mergefunc -reg2mem -infer-address-spaces -licm -pgo-memop-opt -lowerinvoke -insert-gcov-profiling -early-cse-memssa -aggressive-instcombine -inferattrs -canonicalize-aliases -div-rem-pairs -slsr -instnamer -load-store-vectorizer -loop-instsimplify -aggressive-instcombine -mem2reg -loop-distribute -attributor -argpromotion -loweratomic -instsimplify -loop-guard-widening -ee-instrument -lowerswitch -indvars -cross-dso-cfi -irce -break-crit-edges -loop-simplify -always-inline -constprop -dse -ipsccp -correlated-propagation -mergeicmps -loop-vectorize -mem2reg -ee-instrument -guard-widening -sink -instsimplify -loop-guard-widening -loop-predication -strip-nondebug -irce -simplifycfg -scalarizer -slp-vectorizer -forceattrs -float2int -newgvn input.bc -o output.bc +benchmark://cbench-v1/sha,1.4715719063545152,11.981029510498047,opt -mem2reg -div-rem-pairs -inject-tli-mappings -forceattrs -mergeicmps -dce -loop-unroll-and-jam -loop-fusion -loop-versioning -aggressive-instcombine -break-crit-edges -simplifycfg -irce -loop-sink -guard-widening -loop-sink -break-crit-edges -div-rem-pairs -separate-const-offset-from-gep -scalarizer -inferattrs -flattencfg -loweratomic -bdce -instcombine -post-inline-ee-instrument -lcssa -add-discriminators -flattencfg -instcombine -loop-reroll -inject-tli-mappings -elim-avail-extern -loop-versioning-licm -coro-elide -partial-inliner -loop-reroll -loop-data-prefetch -lower-matrix-intrinsics -correlated-propagation -consthoist -instnamer -partially-inline-libcalls -lower-matrix-intrinsics -lowerswitch -loop-versioning-licm -canonicalize-aliases -prune-eh -globalsplit -rewrite-statepoints-for-gc -ipsccp -jump-threading -coro-split -newgvn -memcpyopt -loop-versioning-licm -slp-vectorizer -reassociate -simplifycfg -newgvn -lcssa -simplifycfg -lower-matrix-intrinsics -dce -aggressive-instcombine -loop-distribute -loop-data-prefetch -infer-address-spaces -irce -instsimplify -lower-expect -correlated-propagation -sancov -alignment-from-assumptions -adce -tailcallelim -functionattrs -partial-inliner -bdce -strip-nondebug -ipconstprop -globalsplit -cross-dso-cfi -coro-early -instcombine -coro-early -bdce -loop-unroll-and-jam -sroa -aggressive-instcombine -loweratomic -indvars -loop-data-prefetch -cross-dso-cfi -coro-early -globalopt -canonicalize-aliases -break-crit-edges -insert-gcov-profiling -redundant-dbg-inst-elim -loop-deletion -reassociate -loop-distribute -simplifycfg -div-rem-pairs -loop-fusion -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/sha,1.474916387959866,11.905332565307617,opt -coro-cleanup -gvn -inferattrs -loop-versioning -name-anon-globals -simplifycfg -loop-interchange -div-rem-pairs -loop-deletion -mergefunc -ee-instrument -dce -flattencfg -mldst-motion -callsite-splitting -sccp -consthoist -functionattrs -attributor -aggressive-instcombine -loop-instsimplify -loop-deletion -mem2reg -mergefunc -flattencfg -rewrite-statepoints-for-gc -name-anon-globals -strip -bdce -prune-eh -lower-widenable-condition -loop-vectorize -sccp -instsimplify -mldst-motion -instnamer -div-rem-pairs -mldst-motion -canonicalize-aliases -newgvn -lower-constant-intrinsics -sink -indvars -alignment-from-assumptions -argpromotion -rewrite-statepoints-for-gc -early-cse-memssa -attributor -post-inline-ee-instrument -early-cse-memssa -loop-guard-widening -constmerge -lower-constant-intrinsics -prune-eh -strip -rpo-functionattrs -instcombine input.bc -o output.bc +benchmark://cbench-v1/sha,1.4749163879598663,11.936026334762573,opt -strip -always-inline -lower-expect -partially-inline-libcalls -gvn-hoist -loop-guard-widening -instnamer -reg2mem -slsr -loop-unroll -instnamer -slp-vectorizer -cross-dso-cfi -loop-distribute -called-value-propagation -ee-instrument -jump-threading -rewrite-statepoints-for-gc -loop-data-prefetch -globalsplit -partial-inliner -rpo-functionattrs -strip -strip-debug-declare -lower-guard-intrinsic -loop-distribute -ipconstprop -partially-inline-libcalls -irce -speculative-execution -flattencfg -redundant-dbg-inst-elim -loop-instsimplify -functionattrs -loop-reroll -hotcoldsplit -insert-gcov-profiling -loop-reroll -lower-expect -consthoist -lower-matrix-intrinsics -early-cse-memssa -prune-eh -loop-distribute -globalsplit -inject-tli-mappings -irce -mergefunc -hotcoldsplit -argpromotion -name-anon-globals -loop-simplifycfg -partially-inline-libcalls -slsr -barrier -flattencfg -post-inline-ee-instrument -sink -loop-vectorize -loop-vectorize -coro-cleanup -lowerinvoke -inject-tli-mappings -canonicalize-aliases -float2int -lowerswitch -indvars -lower-matrix-intrinsics -lowerinvoke -redundant-dbg-inst-elim -prune-eh -aggressive-instcombine -hotcoldsplit -strip-debug-declare -early-cse-memssa -licm -load-store-vectorizer -insert-gcov-profiling -sancov -pgo-memop-opt -sink -barrier -mem2reg -strip-debug-declare -cross-dso-cfi -callsite-splitting -gvn -simplifycfg -licm -memcpyopt -ipconstprop -lowerswitch -loop-guard-widening -functionattrs -loop-interchange -coro-elide -simple-loop-unswitch -separate-const-offset-from-gep -instcombine -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/sha,1.4782608695652173,11.766895771026611,opt -alignment-from-assumptions -sroa -indvars -adce -jump-threading -add-discriminators -ipconstprop -div-rem-pairs -bdce -instnamer -indvars -simplifycfg -mem2reg -lower-widenable-condition -loop-interchange -sancov -argpromotion -inject-tli-mappings -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/sha,1.4782608695652173,12.040958642959595,opt -instcombine -loop-sink -functionattrs -strip -jump-threading -insert-gcov-profiling -lower-guard-intrinsic -simple-loop-unswitch -mldst-motion -loop-reduce -strip-dead-prototypes -slsr -partial-inliner -loop-data-prefetch -argpromotion -mldst-motion -always-inline -pgo-memop-opt -mergeicmps -mergeicmps -attributor -lower-expect -called-value-propagation -coro-cleanup -barrier -loop-unswitch -lowerinvoke -ipconstprop -inject-tli-mappings -lower-widenable-condition -loop-unroll -loop-predication -loop-simplify -mergefunc -loop-unroll -elim-avail-extern -rpo-functionattrs -licm -loop-distribute -simplifycfg -loop-load-elim -scalarizer -bdce -coro-cleanup -gvn -licm -strip-debug-declare -early-cse-memssa -loop-unroll-and-jam -add-discriminators -reg2mem -gvn -instsimplify -rewrite-statepoints-for-gc -strip -canonicalize-aliases -sccp -simplifycfg -simplifycfg -lower-widenable-condition -bdce -sroa -loop-distribute -loop-versioning -redundant-dbg-inst-elim -guard-widening -adce -constprop -insert-gcov-profiling -load-store-vectorizer -pgo-memop-opt -attributor -ee-instrument -loop-fusion -prune-eh -slsr -inferattrs -loop-deletion -loop-load-elim -loweratomic -strip-debug-declare -functionattrs -insert-gcov-profiling -libcalls-shrinkwrap -loop-unroll-and-jam -barrier -functionattrs -scalarizer -loop-instsimplify -loop-guard-widening -die -aggressive-instcombine -nary-reassociate -indvars -simple-loop-unswitch -scalarizer -strip -loop-guard-widening -scalarizer -load-store-vectorizer -lowerinvoke -lowerinvoke -coro-cleanup -instcombine input.bc -o output.bc +benchmark://cbench-v1/sha,1.4849498327759196,12.055265426635742,opt -simplifycfg -ipsccp -aggressive-instcombine -loweratomic -licm -loop-interchange -deadargelim -canonicalize-aliases -break-crit-edges -alignment-from-assumptions -loop-simplifycfg -barrier -strip-nondebug -gvn -flattencfg -coro-split -load-store-vectorizer -strip -ipsccp -instcombine -redundant-dbg-inst-elim -libcalls-shrinkwrap -correlated-propagation -forceattrs -partially-inline-libcalls -ipconstprop -constprop -mergereturn -newgvn -lower-guard-intrinsic -load-store-vectorizer -sroa -lowerswitch -strip-debug-declare -adce -separate-const-offset-from-gep -inject-tli-mappings -load-store-vectorizer -always-inline -libcalls-shrinkwrap -correlated-propagation -ipconstprop -loop-fusion -globalopt -slp-vectorizer -partially-inline-libcalls -forceattrs -newgvn -elim-avail-extern -early-cse-memssa -globaldce -inject-tli-mappings -aggressive-instcombine -separate-const-offset-from-gep -alignment-from-assumptions -name-anon-globals -attributor -globalopt -loop-reroll -lower-matrix-intrinsics -called-value-propagation -indvars -elim-avail-extern -loop-interchange -mem2reg -loop-load-elim -instcombine input.bc -o output.bc +benchmark://cbench-v1/sha,1.4949832775919731,11.823912382125854,opt -pgo-memop-opt -aggressive-instcombine -lower-widenable-condition -dce -strip-debug-declare -globaldce -partial-inliner -simplifycfg -div-rem-pairs -slsr -infer-address-spaces -separate-const-offset-from-gep -newgvn -loop-unroll-and-jam -inferattrs -barrier -coro-cleanup -loop-predication -instcombine -early-cse-memssa -reg2mem -lower-widenable-condition -infer-address-spaces -sancov -alignment-from-assumptions -early-cse-memssa -name-anon-globals -lower-widenable-condition -dce -tailcallelim -loop-data-prefetch -loop-instsimplify -loop-simplifycfg -instnamer -cross-dso-cfi -mem2reg -coro-elide -loop-distribute -called-value-propagation -always-inline -alignment-from-assumptions -strip-dead-prototypes -irce -lower-guard-intrinsic -load-store-vectorizer -insert-gcov-profiling -loop-instsimplify -die -loop-rotate -nary-reassociate -post-inline-ee-instrument -separate-const-offset-from-gep -div-rem-pairs -coro-split -loop-sink -redundant-dbg-inst-elim -partially-inline-libcalls -die -loop-unroll-and-jam -loweratomic -hotcoldsplit -coro-cleanup -libcalls-shrinkwrap -mergefunc -simple-loop-unswitch -ee-instrument -simplifycfg -coro-cleanup -lcssa -simple-loop-unswitch -deadargelim -instcombine -loweratomic -nary-reassociate -guard-widening -separate-const-offset-from-gep -constmerge -redundant-dbg-inst-elim -instsimplify -dse -functionattrs -newgvn -licm -flattencfg -callsite-splitting -loop-fusion -strip-dead-prototypes -instsimplify -callsite-splitting -simplifycfg -dse -lower-constant-intrinsics -gvn-hoist -mergereturn -memcpyopt -dce -loop-idiom -loop-instsimplify -rewrite-statepoints-for-gc -hotcoldsplit -speculative-execution -licm -speculative-execution -argpromotion -newgvn -adce -sancov -rpo-functionattrs -instnamer -redundant-dbg-inst-elim -coro-cleanup -name-anon-globals -sroa -always-inline -partially-inline-libcalls -guard-widening -loop-idiom -strip-dead-prototypes -constprop -mergereturn -loop-interchange -separate-const-offset-from-gep -barrier -alignment-from-assumptions -bdce -loop-unroll-and-jam -gvn-hoist -attributor -reassociate -loop-data-prefetch -simplifycfg -div-rem-pairs -mergeicmps -mem2reg -elim-avail-extern -simplifycfg -adce -loop-idiom -nary-reassociate -loop-data-prefetch -indvars -sccp -gvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/sha,1.5050167224080264,11.817471742630005,opt -simplifycfg -partially-inline-libcalls -partial-inliner -loweratomic -lower-widenable-condition -separate-const-offset-from-gep -float2int -partial-inliner -lower-expect -sccp -hotcoldsplit -infer-address-spaces -loop-unswitch -gvn -barrier -separate-const-offset-from-gep -mergefunc -lower-constant-intrinsics -lower-matrix-intrinsics -indvars -functionattrs -called-value-propagation -mergeicmps -gvn-hoist -globalsplit -memcpyopt -loweratomic -partially-inline-libcalls -lowerinvoke -hotcoldsplit -die -loop-distribute -strip-dead-prototypes -coro-split -loop-distribute -loop-vectorize -loop-vectorize -die -coro-split -argpromotion -loop-deletion -early-cse-memssa -lower-guard-intrinsic -loop-simplify -lower-expect -loop-data-prefetch -attributor -ee-instrument -reassociate -coro-elide -correlated-propagation -div-rem-pairs -break-crit-edges -coro-cleanup -lower-widenable-condition -name-anon-globals -instcombine -reg2mem -jump-threading -callsite-splitting -loop-fusion -instnamer -early-cse-memssa -post-inline-ee-instrument -alignment-from-assumptions -speculative-execution -dce -bdce -libcalls-shrinkwrap -sroa -partial-inliner -reg2mem -mergefunc -sccp -break-crit-edges -loop-unroll-and-jam -lower-constant-intrinsics -flattencfg -pgo-memop-opt -tailcallelim -coro-split -indvars -sroa -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/sha,1.5050167224080266,11.961605548858643,opt -coro-elide -barrier -ipconstprop -loop-data-prefetch -rpo-functionattrs -loop-reduce -rpo-functionattrs -speculative-execution -constmerge -strip-debug-declare -break-crit-edges -reg2mem -mldst-motion -lower-guard-intrinsic -argpromotion -always-inline -loop-distribute -sancov -always-inline -mergeicmps -globalsplit -strip-debug-declare -div-rem-pairs -add-discriminators -irce -loop-distribute -cross-dso-cfi -functionattrs -load-store-vectorizer -aggressive-instcombine -simplifycfg -elim-avail-extern -separate-const-offset-from-gep -loop-guard-widening -tailcallelim -newgvn -always-inline -mergefunc -coro-early -loweratomic -loop-predication -strip-debug-declare -lowerswitch -consthoist -gvn -jump-threading -break-crit-edges -sccp -loop-fusion -deadargelim -tailcallelim -rewrite-statepoints-for-gc -lcssa -sancov -inject-tli-mappings -early-cse-memssa -instcombine -ee-instrument -mergefunc -loop-distribute -sancov -loop-guard-widening -barrier -div-rem-pairs -consthoist -aggressive-instcombine -deadargelim -loop-simplify -called-value-propagation -always-inline -inject-tli-mappings -simplifycfg -strip -insert-gcov-profiling -redundant-dbg-inst-elim -constprop -canonicalize-aliases -memcpyopt -tailcallelim -jump-threading -coro-elide -name-anon-globals -dse -loop-versioning -insert-gcov-profiling -loop-unroll-and-jam -slp-vectorizer -indvars -inferattrs -argpromotion -sccp -lower-expect -loop-idiom -dce -flattencfg -coro-split -scalarizer -functionattrs -callsite-splitting -canonicalize-aliases -barrier -elim-avail-extern -tailcallelim -loop-guard-widening -loop-fusion -lcssa -lowerswitch -instcombine -simplifycfg -slsr -ipconstprop -correlated-propagation -indvars -flattencfg -name-anon-globals -lowerinvoke -canonicalize-aliases -consthoist -attributor -coro-elide -scalarizer -ipsccp -partially-inline-libcalls -instsimplify -coro-elide -rewrite-statepoints-for-gc -strip-dead-prototypes -scalarizer -canonicalize-aliases -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/stringsearch,0.9767759562841531,12.063631057739258,opt -globalopt -loop-deletion -float2int -reassociate -lower-matrix-intrinsics -loop-guard-widening -strip -ee-instrument -deadargelim -lower-widenable-condition -post-inline-ee-instrument -coro-cleanup -elim-avail-extern -die -mem2reg -early-cse-memssa -guard-widening -loop-vectorize -constmerge -rewrite-statepoints-for-gc -rewrite-statepoints-for-gc -dse -loop-unroll -instcombine -loop-distribute -prune-eh -functionattrs -globalopt -flattencfg -ee-instrument -partially-inline-libcalls -adce -argpromotion -consthoist -consthoist -instcombine -called-value-propagation -simplifycfg -gvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch,0.9795081967213116,11.88592791557312,opt -loop-rotate -loop-reroll -loop-unroll-and-jam -consthoist -loop-rotate -adce -loop-sink -ipsccp -loop-instsimplify -mem2reg -mergeicmps -reassociate -loop-load-elim -mergereturn -sroa -loop-simplifycfg -loop-data-prefetch -mergefunc -flattencfg -newgvn -loop-idiom -loop-vectorize -coro-split -deadargelim -globalsplit -die -loop-fusion -loop-instsimplify -dce -loop-predication -mergeicmps -sink -simple-loop-unswitch -globalsplit -guard-widening -mem2reg -jump-threading -loop-simplifycfg -lower-expect -post-inline-ee-instrument -lower-constant-intrinsics -always-inline -constprop -inject-tli-mappings -gvn-hoist -mergefunc -strip -lower-widenable-condition -simplifycfg -barrier -adce -instcombine input.bc -o output.bc +benchmark://cbench-v1/stringsearch,0.9808743169398909,12.13899278640747,opt -newgvn -slsr -lowerinvoke -lowerinvoke -loop-distribute -lower-guard-intrinsic -globaldce -memcpyopt -sancov -callsite-splitting -callsite-splitting -inject-tli-mappings -licm -early-cse-memssa -loop-simplify -loop-deletion -lowerinvoke -ipsccp -speculative-execution -scalarizer -loop-guard-widening -jump-threading -attributor -flattencfg -licm -insert-gcov-profiling -slsr -jump-threading -mergereturn -alignment-from-assumptions -reassociate -indvars -loop-simplifycfg -constprop -sancov -loop-unroll -loop-reroll -jump-threading -guard-widening -simplifycfg -partially-inline-libcalls -constprop -hotcoldsplit -loop-instsimplify -partially-inline-libcalls -pgo-memop-opt -name-anon-globals -coro-early -mergeicmps -indvars -sccp -simplifycfg -reassociate -bdce -loop-vectorize -jump-threading -lowerswitch -correlated-propagation -ipsccp -loop-unroll-and-jam -loop-unroll -strip -inline -inject-tli-mappings -gvn-hoist -loop-data-prefetch -alignment-from-assumptions -sccp -bdce -loop-interchange -functionattrs -infer-address-spaces -forceattrs -strip-debug-declare -lcssa -break-crit-edges -lower-guard-intrinsic -slsr -strip-dead-prototypes -loop-distribute -lower-guard-intrinsic -break-crit-edges -partially-inline-libcalls -nary-reassociate -reassociate -dce -loop-unroll-and-jam -argpromotion -lower-expect -loop-data-prefetch -lower-expect -always-inline -loop-simplify -add-discriminators -irce -slp-vectorizer -name-anon-globals -ee-instrument -newgvn -gvn-hoist -inject-tli-mappings -lower-guard-intrinsic -licm -simplifycfg -loop-instsimplify -partial-inliner -lower-widenable-condition -flattencfg -rewrite-statepoints-for-gc -loop-instsimplify -lowerswitch -gvn -lowerinvoke -loop-instsimplify -lowerswitch -guard-widening -lower-widenable-condition -mergeicmps -lower-guard-intrinsic -lower-matrix-intrinsics -correlated-propagation -globalsplit -loop-interchange -infer-address-spaces -loop-versioning -deadargelim -lower-guard-intrinsic -mem2reg -post-inline-ee-instrument -instcombine -globalsplit -simple-loop-unswitch -loop-vectorize -attributor -lowerinvoke -loop-deletion -rpo-functionattrs -loop-load-elim -adce -attributor -coro-cleanup -argpromotion -newgvn -barrier -loop-reroll -mergeicmps -bdce -strip-debug-declare -adce -separate-const-offset-from-gep -lower-matrix-intrinsics -bdce -loop-deletion -loop-unswitch -sink -coro-elide -instcombine -loop-data-prefetch -loop-versioning -die -slsr -jump-threading -adce -die -lower-expect -rewrite-statepoints-for-gc -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/stringsearch,0.9836065573770493,12.070388317108154,opt -consthoist -lower-constant-intrinsics -always-inline -globaldce -memcpyopt -loop-instsimplify -guard-widening -globalsplit -consthoist -loop-data-prefetch -canonicalize-aliases -simple-loop-unswitch -slp-vectorizer -lowerinvoke -flattencfg -simplifycfg -infer-address-spaces -gvn -float2int -mergeicmps -partially-inline-libcalls -add-discriminators -coro-split -correlated-propagation -lower-matrix-intrinsics -loop-vectorize -strip-nondebug -rewrite-statepoints-for-gc -partial-inliner -loop-guard-widening -coro-elide -coro-split -strip -rewrite-statepoints-for-gc -loop-fusion -float2int -attributor -elim-avail-extern -functionattrs -correlated-propagation -mergeicmps -loop-data-prefetch -flattencfg -hotcoldsplit -loop-idiom -consthoist -loweratomic -loop-idiom -reg2mem -mem2reg -mergeicmps -add-discriminators -loop-guard-widening -ee-instrument -scalarizer -memcpyopt -speculative-execution -aggressive-instcombine -post-inline-ee-instrument -tailcallelim -sancov -redundant-dbg-inst-elim -loop-predication -loop-predication -called-value-propagation -name-anon-globals -consthoist -separate-const-offset-from-gep -lowerswitch -redundant-dbg-inst-elim -rewrite-statepoints-for-gc -loop-guard-widening -argpromotion -hotcoldsplit -libcalls-shrinkwrap -mergefunc -dse -dse -sccp -loop-guard-widening -pgo-memop-opt -lowerswitch -simple-loop-unswitch -nary-reassociate -indvars -slsr -slsr -memcpyopt -functionattrs -loop-unswitch -prune-eh -mergereturn -mergereturn -globalsplit -loop-idiom -mergefunc -redundant-dbg-inst-elim -mergeicmps -forceattrs -globalopt -dse -licm -mergereturn -dse -constprop -cross-dso-cfi -rewrite-statepoints-for-gc -adce -simplifycfg -rpo-functionattrs -sroa -ipconstprop -strip -load-store-vectorizer -insert-gcov-profiling -instcombine -jump-threading -canonicalize-aliases -mem2reg -tailcallelim -globalopt -loop-simplify -loop-instsimplify -correlated-propagation -loop-unroll-and-jam -gvn -loop-sink -sancov -memcpyopt -loop-vectorize -strip-nondebug -adce -ipconstprop -loop-versioning-licm -loop-simplifycfg -loop-versioning-licm -simplifycfg -irce -strip -loop-data-prefetch -strip-dead-prototypes -loop-versioning-licm -mergeicmps -lcssa -lowerswitch -div-rem-pairs -gvn -loop-sink -globalsplit -aggressive-instcombine -loop-distribute -insert-gcov-profiling -newgvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch,0.9904371584699454,14.024319648742676,opt -dse -instsimplify -strip-nondebug -lcssa -instsimplify -instnamer -strip-dead-prototypes -loop-deletion -loop-instsimplify -deadargelim -dce -instsimplify -strip -instnamer -sink -lower-constant-intrinsics -loop-data-prefetch -simplifycfg -correlated-propagation -ipsccp -speculative-execution -alignment-from-assumptions -float2int -loop-unroll -partially-inline-libcalls -functionattrs -redundant-dbg-inst-elim -loop-unroll-and-jam -reassociate -loop-simplifycfg -mldst-motion -loop-predication -mldst-motion -called-value-propagation -div-rem-pairs -elim-avail-extern -lower-matrix-intrinsics -flattencfg -barrier -float2int -functionattrs -elim-avail-extern -loop-instsimplify -inject-tli-mappings -loop-instsimplify -loop-reroll -consthoist -lcssa -globalopt -strip -nary-reassociate -loop-vectorize -newgvn -rpo-functionattrs -loop-load-elim -loop-deletion -infer-address-spaces -guard-widening -strip-dead-prototypes -separate-const-offset-from-gep -sancov -forceattrs -partial-inliner -gvn -sroa -load-store-vectorizer -loop-data-prefetch -globaldce -speculative-execution -lcssa -strip -lower-matrix-intrinsics -speculative-execution -loop-instsimplify -nary-reassociate -loop-instsimplify -div-rem-pairs -speculative-execution -slp-vectorizer -slp-vectorizer -coro-cleanup -mergefunc -cross-dso-cfi -guard-widening -slp-vectorizer -rewrite-statepoints-for-gc -ee-instrument -correlated-propagation -loop-data-prefetch -loop-instsimplify -strip-dead-prototypes -mergefunc -slp-vectorizer -loop-vectorize -forceattrs -consthoist -insert-gcov-profiling -barrier -name-anon-globals -licm -strip-dead-prototypes -irce -infer-address-spaces -die -mem2reg -post-inline-ee-instrument -rewrite-statepoints-for-gc -div-rem-pairs -globalsplit -aggressive-instcombine -loop-unroll-and-jam -loop-versioning -loop-instsimplify -mem2reg -bdce -loop-interchange -bdce -lower-widenable-condition -ipsccp -add-discriminators -sccp -attributor -reassociate -constmerge -scalarizer -strip-debug-declare -strip-dead-prototypes -infer-address-spaces -rpo-functionattrs -deadargelim -mergereturn -inferattrs -inferattrs -separate-const-offset-from-gep -loop-fusion -scalarizer -loop-deletion -inferattrs -lower-expect -partial-inliner -simplifycfg -mergereturn -lcssa -sccp -separate-const-offset-from-gep -irce -insert-gcov-profiling -globaldce -barrier -ee-instrument -always-inline -flattencfg -tailcallelim -alignment-from-assumptions -name-anon-globals -loop-simplifycfg -coro-early -ipsccp -early-cse-memssa -simplifycfg -deadargelim -loop-sink -globaldce -flattencfg -coro-elide -licm -instcombine -name-anon-globals -mldst-motion -infer-address-spaces -loweratomic -pgo-memop-opt -globaldce -always-inline -sccp -indvars -strip-nondebug -loop-unroll-and-jam -correlated-propagation -post-inline-ee-instrument -sancov -loop-reduce -memcpyopt -loop-simplify -instnamer -separate-const-offset-from-gep -separate-const-offset-from-gep -strip -coro-early -mem2reg -lower-guard-intrinsic -jump-threading -strip-debug-declare -simplifycfg -nary-reassociate -newgvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch,0.9918032786885245,11.971539974212646,opt -loop-reduce -simplifycfg -die -inferattrs -constmerge -tailcallelim -loop-guard-widening -memcpyopt -partially-inline-libcalls -adce -float2int -sancov -newgvn -prune-eh -sink -alignment-from-assumptions -constmerge -sroa -die -instcombine -attributor -globaldce -coro-early -loop-versioning -mldst-motion -strip-debug-declare -attributor -loop-unroll-and-jam -dce -lower-constant-intrinsics -break-crit-edges -mldst-motion -rewrite-statepoints-for-gc -load-store-vectorizer -argpromotion -separate-const-offset-from-gep -break-crit-edges -slsr -functionattrs -lowerswitch -canonicalize-aliases -loop-data-prefetch -loop-unroll -loop-unswitch -mem2reg -loop-unswitch -deadargelim -dse -loweratomic -newgvn -globalsplit -loop-reroll -adce -functionattrs -flattencfg -sink -dse -loop-fusion -inject-tli-mappings -simplifycfg -early-cse-memssa -functionattrs -elim-avail-extern input.bc -o output.bc +benchmark://cbench-v1/stringsearch,0.9918032786885245,12.370582818984985,opt -coro-cleanup -flattencfg -indvars -strip-nondebug -rewrite-statepoints-for-gc -globalsplit -libcalls-shrinkwrap -lowerswitch -coro-elide -deadargelim -simplifycfg -partial-inliner -loop-reduce -elim-avail-extern -reg2mem -lcssa -globalsplit -loop-data-prefetch -libcalls-shrinkwrap -scalarizer -lcssa -ipconstprop -attributor -die -dse -insert-gcov-profiling -partial-inliner -mem2reg -lowerinvoke -loop-simplify -loop-sink -die -mergeicmps -memcpyopt -aggressive-instcombine -callsite-splitting -globalopt -lower-guard-intrinsic -hotcoldsplit -globalopt -lcssa -float2int -lowerinvoke -speculative-execution -loop-reroll -jump-threading -loop-simplify -coro-elide -strip -lower-guard-intrinsic -tailcallelim -speculative-execution -alignment-from-assumptions -elim-avail-extern -loop-idiom -loop-simplify -loop-simplify -partial-inliner -attributor -globalsplit -early-cse-memssa -loop-vectorize -lower-constant-intrinsics -constmerge -loop-interchange -flattencfg -globalopt -libcalls-shrinkwrap -lower-constant-intrinsics -infer-address-spaces -lowerswitch -mergeicmps -reassociate -break-crit-edges -loop-vectorize -lower-constant-intrinsics -strip-nondebug -pgo-memop-opt -loop-simplify -loop-reroll -insert-gcov-profiling -guard-widening -memcpyopt -loop-unroll -deadargelim -loop-simplifycfg -inject-tli-mappings -instnamer -loop-reroll -loop-deletion -early-cse-memssa -reg2mem -slp-vectorizer -div-rem-pairs -constprop -called-value-propagation -gvn -aggressive-instcombine -flattencfg -pgo-memop-opt -gvn-hoist -globalsplit -elim-avail-extern -reassociate -licm -coro-elide -irce -prune-eh -loop-unroll-and-jam -partially-inline-libcalls -globaldce -loop-distribute -break-crit-edges -loop-reroll -sancov -float2int -loweratomic -insert-gcov-profiling -redundant-dbg-inst-elim -deadargelim -speculative-execution -loop-unroll-and-jam -infer-address-spaces -mem2reg -name-anon-globals -pgo-memop-opt -correlated-propagation -rpo-functionattrs -infer-address-spaces -speculative-execution -aggressive-instcombine -post-inline-ee-instrument -lcssa -elim-avail-extern -loop-unroll -dse -break-crit-edges -mem2reg -dse -partial-inliner -licm -slsr -memcpyopt -indvars -loop-load-elim -div-rem-pairs -lower-guard-intrinsic -flattencfg -loop-vectorize -insert-gcov-profiling -reg2mem -loop-deletion -die -rewrite-statepoints-for-gc -div-rem-pairs -prune-eh -coro-early -loop-distribute -scalarizer -mldst-motion -loop-simplifycfg -loop-instsimplify -lower-widenable-condition -slp-vectorizer -ee-instrument -cross-dso-cfi -sink -constprop -tailcallelim -simple-loop-unswitch -lower-widenable-condition -float2int -mergereturn -mem2reg -lower-matrix-intrinsics -loop-reroll -constmerge -loop-versioning-licm -scalarizer -loop-reroll -memcpyopt -gvn -forceattrs -cross-dso-cfi -alignment-from-assumptions -break-crit-edges -bdce -sink -loop-predication -infer-address-spaces -loop-simplify -adce -loop-reroll -adce -mldst-motion -jump-threading -sancov -argpromotion -correlated-propagation -argpromotion -ee-instrument -barrier -dse -consthoist -loop-guard-widening -die -loop-load-elim -loop-unswitch -loop-guard-widening -coro-split -strip -barrier -loop-deletion -loop-predication -instcombine -called-value-propagation -tailcallelim -always-inline -consthoist -loop-fusion -slp-vectorizer -loop-sink -loop-versioning-licm -post-inline-ee-instrument -lowerinvoke -loop-versioning -load-store-vectorizer -loop-simplifycfg -barrier -functionattrs -loop-unroll-and-jam -slp-vectorizer -gvn -globalopt input.bc -o output.bc +benchmark://cbench-v1/stringsearch,0.9931693989071037,12.058562278747559,opt -correlated-propagation -coro-early -ee-instrument -loweratomic -strip-debug-declare -post-inline-ee-instrument -cross-dso-cfi -partially-inline-libcalls -gvn-hoist -globaldce -sccp -coro-cleanup -consthoist -constprop -barrier -loop-distribute -rpo-functionattrs -partially-inline-libcalls -simple-loop-unswitch -partial-inliner -globalsplit -loop-reduce -coro-split -ipsccp -loop-sink -irce -indvars -mldst-motion -coro-elide -hotcoldsplit -ipsccp -lower-matrix-intrinsics -ipsccp -sroa -reg2mem -newgvn -constprop -sancov -reassociate -globalopt -slp-vectorizer -loop-reduce -tailcallelim -loop-instsimplify -sink -globaldce -functionattrs -cross-dso-cfi -loop-vectorize -loop-vectorize -loop-vectorize -loop-interchange -loop-instsimplify -strip-nondebug -partially-inline-libcalls -alignment-from-assumptions -lower-guard-intrinsic -globaldce -lower-constant-intrinsics -coro-early -sroa -lowerswitch -loop-distribute -lowerswitch -strip-nondebug -globalopt -pgo-memop-opt -globaldce -load-store-vectorizer -div-rem-pairs -called-value-propagation -lower-matrix-intrinsics -loop-predication -strip-debug-declare -dse -partially-inline-libcalls -simplifycfg -instnamer -canonicalize-aliases -partially-inline-libcalls -loop-deletion -always-inline -loop-simplify -gvn -div-rem-pairs -adce -dce -strip-nondebug -slp-vectorizer -strip-nondebug -loop-sink -loweratomic -hotcoldsplit -functionattrs -loop-versioning-licm -ee-instrument -loop-data-prefetch -strip-debug-declare -tailcallelim -redundant-dbg-inst-elim -gvn-hoist -newgvn -dse -loop-versioning -memcpyopt -mldst-motion -hotcoldsplit -always-inline -newgvn -loop-data-prefetch -loop-data-prefetch -tailcallelim -loop-fusion -gvn -inferattrs -load-store-vectorizer -dce -lowerinvoke -elim-avail-extern -guard-widening -loop-reduce -simple-loop-unswitch -cross-dso-cfi -coro-split -always-inline -globaldce -loop-unroll-and-jam -called-value-propagation -lcssa -instcombine -sccp -mergefunc -rewrite-statepoints-for-gc -instcombine -globalsplit -jump-threading -guard-widening -insert-gcov-profiling -callsite-splitting -barrier -rpo-functionattrs -argpromotion -inferattrs -guard-widening -coro-cleanup -strip -slsr -loop-versioning-licm -loop-instsimplify -simplifycfg -dse -sccp -coro-elide -early-cse-memssa -lower-guard-intrinsic -loop-vectorize -instcombine -slp-vectorizer -instsimplify -mldst-motion -libcalls-shrinkwrap -barrier -insert-gcov-profiling -early-cse-memssa -loop-versioning-licm -redundant-dbg-inst-elim -lower-constant-intrinsics -loop-instsimplify -rpo-functionattrs -lower-widenable-condition -lower-expect -libcalls-shrinkwrap -sroa -rpo-functionattrs -lower-widenable-condition -cross-dso-cfi -correlated-propagation -strip-nondebug -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0013661202185793,12.024682760238647,opt -newgvn -loop-versioning-licm -loop-instsimplify -coro-early -instcombine -strip-nondebug -name-anon-globals -loop-vectorize -loop-deletion -lowerswitch -instcombine -forceattrs -load-store-vectorizer -lowerswitch -separate-const-offset-from-gep -aggressive-instcombine -globalsplit -globalopt -loop-simplifycfg -sccp -loop-versioning -mergereturn -break-crit-edges -ipsccp -sink -loop-versioning -separate-const-offset-from-gep -loop-unroll -inferattrs -elim-avail-extern -break-crit-edges -loop-instsimplify -strip-dead-prototypes -slsr -mem2reg -loop-data-prefetch -jump-threading -instcombine -coro-early -loop-simplify -simplifycfg -dce -lower-constant-intrinsics input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0040983606557372,11.870396137237549,opt -instnamer -barrier -simple-loop-unswitch -lower-matrix-intrinsics -licm -loop-idiom -scalarizer -post-inline-ee-instrument -loop-unswitch -name-anon-globals -ipconstprop -cross-dso-cfi -ipconstprop -lower-widenable-condition -cross-dso-cfi -slp-vectorizer -constprop -cross-dso-cfi -early-cse-memssa -deadargelim -insert-gcov-profiling -lcssa -dse -lowerswitch -rpo-functionattrs -separate-const-offset-from-gep -simplifycfg -sink -loop-fusion -mem2reg -callsite-splitting -libcalls-shrinkwrap -reassociate -gvn -deadargelim -flattencfg -strip-dead-prototypes -rpo-functionattrs -consthoist -pgo-memop-opt -libcalls-shrinkwrap -lower-expect -lower-constant-intrinsics -loop-idiom -memcpyopt -lower-constant-intrinsics -flattencfg -mldst-motion -cross-dso-cfi -load-store-vectorizer -functionattrs -gvn -mergeicmps -strip-dead-prototypes -instcombine -cross-dso-cfi -die -loop-load-elim -lowerswitch -dse -loop-simplify -lowerinvoke -loop-simplifycfg -loop-reroll -loop-fusion -always-inline -lcssa -rpo-functionattrs -rewrite-statepoints-for-gc -partial-inliner -aggressive-instcombine -licm -bdce -scalarizer -load-store-vectorizer -memcpyopt -reg2mem -load-store-vectorizer -lower-matrix-intrinsics -mem2reg -libcalls-shrinkwrap -scalarizer -rewrite-statepoints-for-gc -speculative-execution -sccp -jump-threading -speculative-execution -speculative-execution -inject-tli-mappings -mergefunc -irce -ee-instrument -constprop -rpo-functionattrs -elim-avail-extern -coro-cleanup -strip -deadargelim -loop-vectorize -lower-expect -jump-threading -instcombine -lower-constant-intrinsics -loop-versioning-licm -alignment-from-assumptions -loop-fusion -globaldce -loop-vectorize -dce -name-anon-globals -deadargelim -die -loop-guard-widening -argpromotion -bdce -loop-deletion -loop-versioning -slp-vectorizer -loop-simplifycfg -strip-debug-declare -loop-simplify -loop-unroll-and-jam -inferattrs -speculative-execution -gvn -load-store-vectorizer -alignment-from-assumptions -gvn-hoist -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9664179104477612,11.904651880264282,opt -guard-widening -ee-instrument -correlated-propagation -lcssa -ee-instrument -loop-idiom -jump-threading -guard-widening -elim-avail-extern -reassociate -slp-vectorizer -newgvn -mem2reg -loop-idiom -loop-fusion -alignment-from-assumptions -libcalls-shrinkwrap -strip -redundant-dbg-inst-elim -loop-distribute -simplifycfg -ipsccp -pgo-memop-opt -infer-address-spaces -post-inline-ee-instrument -redundant-dbg-inst-elim -bdce -lower-widenable-condition -functionattrs -float2int -newgvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9738805970149257,12.163768291473389,opt -bdce -coro-split -lower-widenable-condition -canonicalize-aliases -partially-inline-libcalls -loop-simplify -newgvn -lowerswitch -mergefunc -sink -dse -insert-gcov-profiling -dse -strip-dead-prototypes -loop-versioning -instsimplify -constprop -partial-inliner -prune-eh -strip -rpo-functionattrs -loop-simplifycfg -mem2reg -alignment-from-assumptions -slp-vectorizer -lower-guard-intrinsic -strip-debug-declare -lower-guard-intrinsic -loop-vectorize -mergefunc -gvn-hoist -strip-dead-prototypes -loop-guard-widening -lcssa -loop-idiom -loop-fusion -rpo-functionattrs -instsimplify -coro-split -forceattrs -callsite-splitting -coro-elide -callsite-splitting -cross-dso-cfi -early-cse-memssa -called-value-propagation -partial-inliner -canonicalize-aliases -jump-threading -mergefunc -div-rem-pairs -infer-address-spaces -lowerinvoke -forceattrs -newgvn -loop-reduce -inferattrs -loop-simplify -consthoist -float2int -redundant-dbg-inst-elim -licm -elim-avail-extern -newgvn -sancov -add-discriminators -name-anon-globals -loop-reroll -scalarizer -barrier -instcombine -strip-dead-prototypes -reassociate -dse -loop-reduce -instsimplify -forceattrs -coro-split -lower-constant-intrinsics -speculative-execution -ipconstprop -constprop -loop-reduce -aggressive-instcombine -functionattrs -loop-vectorize -jump-threading -sccp -tailcallelim -irce -add-discriminators -strip -slp-vectorizer -jump-threading -ee-instrument -indvars -reg2mem -strip -argpromotion -irce -rpo-functionattrs -callsite-splitting -loop-sink -post-inline-ee-instrument -globalsplit -memcpyopt -separate-const-offset-from-gep -loop-simplifycfg -nary-reassociate -loop-reduce -gvn-hoist -inferattrs -coro-cleanup -reg2mem -bdce -sink -float2int -sroa -constmerge -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9776119402985074,14.341261625289917,opt -loop-interchange -loop-deletion -loop-distribute -loop-versioning -insert-gcov-profiling -float2int -newgvn -loop-simplify -functionattrs -loop-idiom -slsr -functionattrs -sink -elim-avail-extern -mergefunc -loop-distribute -lcssa -lcssa -float2int -loop-sink -sink -die -canonicalize-aliases -infer-address-spaces -name-anon-globals -lower-matrix-intrinsics -mergereturn -simple-loop-unswitch -licm -loop-simplifycfg -globaldce -constmerge -lower-guard-intrinsic -simple-loop-unswitch -loop-fusion -lcssa -loop-unroll-and-jam -tailcallelim -break-crit-edges -strip-debug-declare -forceattrs -inferattrs -constmerge -sink -loop-unswitch -early-cse-memssa -rewrite-statepoints-for-gc -coro-split -irce -sroa -globalopt -mergefunc -strip-debug-declare -called-value-propagation -called-value-propagation -redundant-dbg-inst-elim -ipsccp -break-crit-edges -ee-instrument -always-inline -redundant-dbg-inst-elim -gvn-hoist -die -attributor -lower-guard-intrinsic -loop-guard-widening -simplifycfg -pgo-memop-opt -indvars -float2int -ipsccp -simplifycfg -hotcoldsplit -sink -loop-simplify -partially-inline-libcalls -pgo-memop-opt -gvn -ee-instrument -sink -slp-vectorizer -constprop -coro-elide -loop-interchange -mergeicmps -loweratomic -inject-tli-mappings -loop-idiom -aggressive-instcombine -mldst-motion -functionattrs -sccp -always-inline -newgvn -loop-distribute -instcombine input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9813432835820894,13.230485677719116,opt -called-value-propagation -licm -strip-nondebug -alignment-from-assumptions -jump-threading -libcalls-shrinkwrap -loop-vectorize -alignment-from-assumptions -lower-widenable-condition -correlated-propagation -scalarizer -coro-early -sancov -lowerinvoke -ee-instrument -coro-split -dse -pgo-memop-opt -constmerge -lower-constant-intrinsics -libcalls-shrinkwrap -coro-elide -lower-guard-intrinsic -float2int -loop-reroll -elim-avail-extern -partial-inliner -instnamer -coro-cleanup -loop-versioning -alignment-from-assumptions -globaldce -ipsccp -ipconstprop -loop-reroll -sink -mem2reg -lowerswitch -mergereturn -instnamer -mem2reg -die -lowerinvoke -tailcallelim -strip-debug-declare -sink -gvn-hoist -coro-split -die -float2int -dse -loop-versioning -float2int -strip-nondebug -functionattrs -coro-split -die -lcssa -loop-interchange -float2int -loop-vectorize -mergeicmps -instcombine -gvn-hoist -early-cse-memssa -separate-const-offset-from-gep -partially-inline-libcalls -load-store-vectorizer -loop-instsimplify -loop-deletion -gvn -tailcallelim -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9813432835820896,12.88115906715393,opt -break-crit-edges -mldst-motion -ipsccp -loop-predication -loop-load-elim -sroa -redundant-dbg-inst-elim -loop-load-elim -globaldce -nary-reassociate -instsimplify -sroa -irce -instnamer -barrier -consthoist -adce -forceattrs -newgvn -instcombine -loop-unswitch -lower-expect -called-value-propagation -constmerge -strip-debug-declare -simplifycfg -elim-avail-extern -gvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9813432835820897,15.134238719940186,opt -loop-fusion -ipconstprop -prune-eh -early-cse-memssa -inferattrs -newgvn -sink -load-store-vectorizer -coro-early -instnamer -reassociate -coro-cleanup -coro-cleanup -barrier -coro-split -argpromotion -guard-widening -insert-gcov-profiling -loop-idiom -sccp -loop-guard-widening -lower-matrix-intrinsics -globalopt -tailcallelim -name-anon-globals -consthoist -name-anon-globals -dse -loop-data-prefetch -libcalls-shrinkwrap -loop-unroll-and-jam -jump-threading -barrier -instnamer -tailcallelim -mergeicmps -inject-tli-mappings -elim-avail-extern -always-inline -loop-unswitch -partial-inliner -always-inline -licm -lowerswitch -rewrite-statepoints-for-gc -loop-versioning -barrier -mem2reg -loop-reroll -lowerswitch -loop-data-prefetch -coro-elide -lowerswitch -simplifycfg -load-store-vectorizer -constprop -strip -strip -die -slsr -elim-avail-extern -lowerinvoke -instcombine input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9850746268656717,12.014153242111206,opt -pgo-memop-opt -early-cse-memssa -loop-unroll-and-jam -irce -loop-instsimplify -loop-guard-widening -rewrite-statepoints-for-gc -lower-guard-intrinsic -float2int -nary-reassociate -consthoist -hotcoldsplit -loop-distribute -bdce -nary-reassociate -libcalls-shrinkwrap -load-store-vectorizer -elim-avail-extern -slsr -simple-loop-unswitch -sroa -lcssa -early-cse-memssa -lower-constant-intrinsics -nary-reassociate -lcssa -loop-distribute -instnamer -cross-dso-cfi -coro-split -canonicalize-aliases -loop-unswitch -partially-inline-libcalls -name-anon-globals -constprop -coro-split -strip -separate-const-offset-from-gep -loop-load-elim -sancov -mldst-motion -ipconstprop -always-inline -load-store-vectorizer -loop-unroll-and-jam -slp-vectorizer -elim-avail-extern -adce -newgvn -mem2reg -loop-predication -indvars -rewrite-statepoints-for-gc -lowerinvoke -reg2mem -instsimplify -partially-inline-libcalls -loop-deletion -add-discriminators -loop-simplify -forceattrs -sroa -globalsplit -loweratomic -gvn -bdce -rewrite-statepoints-for-gc -reg2mem -mldst-motion -coro-split -mergefunc -sroa -post-inline-ee-instrument -float2int -loop-deletion -loop-unroll-and-jam -name-anon-globals -canonicalize-aliases -aggressive-instcombine -alignment-from-assumptions -early-cse-memssa -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9850746268656717,12.287578821182251,opt -inject-tli-mappings -strip-nondebug -die -constprop -loop-fusion -sancov -sroa -lcssa -instcombine -globaldce -inferattrs -load-store-vectorizer -aggressive-instcombine -partial-inliner -barrier -strip-nondebug -loop-idiom -mergeicmps -cross-dso-cfi -sancov -elim-avail-extern -sroa -simplifycfg -loop-sink -loop-instsimplify -mldst-motion -dse -newgvn -ipconstprop -instsimplify -dce -break-crit-edges -add-discriminators -dse -globalsplit -mem2reg -tailcallelim -loop-interchange -speculative-execution -simplifycfg -lower-expect -reassociate -speculative-execution -loop-unroll-and-jam -jump-threading -inject-tli-mappings -sink -loop-simplify -insert-gcov-profiling -loop-load-elim -cross-dso-cfi -loop-distribute -simplifycfg -die -mem2reg -callsite-splitting -lower-constant-intrinsics -constprop -instcombine input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9888059701492538,12.100034475326538,opt -inferattrs -mergeicmps -loop-sink -mem2reg -attributor -insert-gcov-profiling -add-discriminators -sink -loop-data-prefetch -loop-instsimplify -loop-fusion -div-rem-pairs -deadargelim -coro-early -speculative-execution -argpromotion -coro-cleanup -load-store-vectorizer -inferattrs -loop-simplifycfg -early-cse-memssa -indvars -mem2reg -constprop -adce -ipconstprop -strip-nondebug -die -insert-gcov-profiling -constprop -gvn -loop-sink -instsimplify -guard-widening -loop-unroll -prune-eh -constmerge -lower-widenable-condition -redundant-dbg-inst-elim -lowerinvoke -flattencfg -loop-simplify -mergereturn -tailcallelim -loop-unroll -prune-eh -sccp -separate-const-offset-from-gep -loop-versioning -lower-guard-intrinsic -early-cse-memssa -mergefunc -elim-avail-extern -correlated-propagation -ipconstprop -partially-inline-libcalls -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9888059701492539,12.108437776565552,opt -sancov -strip-nondebug -globaldce -add-discriminators -loop-reduce -strip-nondebug -rpo-functionattrs -partially-inline-libcalls -newgvn -sancov -cross-dso-cfi -simplifycfg -jump-threading -loop-instsimplify -aggressive-instcombine -reassociate -lowerswitch -instcombine -lcssa -loop-simplify -simple-loop-unswitch -memcpyopt -nary-reassociate -die -coro-split -loop-vectorize -indvars -lower-widenable-condition -globalsplit -partially-inline-libcalls -die -always-inline -sccp -dce -loop-unroll-and-jam -lower-expect -dse -lower-widenable-condition -early-cse-memssa -loop-instsimplify -always-inline -canonicalize-aliases -die -gvn-hoist -slp-vectorizer -memcpyopt -jump-threading -loop-instsimplify -globaldce -loop-fusion -loop-unroll -flattencfg -coro-elide -constprop -speculative-execution -loop-fusion -lower-widenable-condition -coro-split -lower-guard-intrinsic -rewrite-statepoints-for-gc -barrier -reassociate -loop-interchange -globaldce -coro-elide -float2int -sancov -lower-constant-intrinsics -mem2reg -lower-widenable-condition -instcombine -newgvn -simple-loop-unswitch -instcombine -partial-inliner -consthoist -sccp -tailcallelim -coro-cleanup -lower-expect -loop-interchange -functionattrs -inferattrs -coro-elide -mldst-motion -newgvn -post-inline-ee-instrument -post-inline-ee-instrument -adce -constprop -loop-predication -globalsplit -reassociate -post-inline-ee-instrument -lowerswitch -sroa -loop-deletion -simplifycfg -tailcallelim -constprop -gvn input.bc -o output.bc +benchmark://cbench-v1/susan,0.977476324545687,14.979936361312866,opt -canonicalize-aliases -loop-guard-widening -float2int -loop-versioning-licm -redundant-dbg-inst-elim -callsite-splitting -loop-load-elim -lowerswitch -loop-unroll-and-jam -lower-guard-intrinsic -forceattrs -instnamer -licm -memcpyopt -prune-eh -loop-unswitch -correlated-propagation -adce -called-value-propagation -loop-predication -loop-load-elim -lower-matrix-intrinsics -sccp -instcombine -globalopt -loop-simplifycfg -lcssa -guard-widening -die -alignment-from-assumptions -partially-inline-libcalls -loop-unroll-and-jam -inject-tli-mappings -sancov -redundant-dbg-inst-elim -cross-dso-cfi -float2int -lower-constant-intrinsics -argpromotion -elim-avail-extern -loop-unroll -argpromotion -loop-predication -lowerswitch -sccp -memcpyopt -dce -add-discriminators -flattencfg -guard-widening -instcombine -speculative-execution -coro-cleanup -ipsccp -early-cse-memssa -instcombine -mem2reg -lower-guard-intrinsic -insert-gcov-profiling -separate-const-offset-from-gep -alignment-from-assumptions -strip -lowerinvoke -elim-avail-extern -scalarizer -insert-gcov-profiling -lower-expect -strip-debug-declare -licm -bdce -hotcoldsplit -sccp -loop-guard-widening -simple-loop-unswitch -loop-versioning -prune-eh -strip-nondebug -gvn -simplifycfg -loop-load-elim -redundant-dbg-inst-elim -coro-elide -prune-eh -partial-inliner -instsimplify -loop-guard-widening -loop-vectorize -barrier -strip-dead-prototypes -inferattrs -adce -load-store-vectorizer -div-rem-pairs -mergeicmps -lower-constant-intrinsics -globalopt -coro-split -reassociate -nary-reassociate -indvars -memcpyopt -scalarizer -lower-guard-intrinsic -ipsccp -bdce -div-rem-pairs -separate-const-offset-from-gep -mldst-motion -alignment-from-assumptions -separate-const-offset-from-gep -ee-instrument -consthoist -post-inline-ee-instrument -correlated-propagation -globaldce -loop-guard-widening -loop-predication -gvn-hoist -guard-widening -always-inline -rewrite-statepoints-for-gc -callsite-splitting -rewrite-statepoints-for-gc -mem2reg -instsimplify -strip -lower-expect -lower-matrix-intrinsics -deadargelim -lcssa -loop-simplify -slp-vectorizer -strip-debug-declare -loop-simplify -forceattrs -early-cse-memssa -inject-tli-mappings -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/susan,0.9824673662656768,14.057718515396118,opt -bdce -partially-inline-libcalls -mem2reg -sccp -attributor -pgo-memop-opt -constmerge -ipconstprop -coro-elide -loop-interchange -insert-gcov-profiling -constmerge -strip-nondebug -loweratomic -insert-gcov-profiling -guard-widening -guard-widening -gvn -loop-load-elim -loop-idiom -instcombine -coro-elide -strip-dead-prototypes -sink -callsite-splitting -mem2reg -loop-interchange -always-inline -dce -elim-avail-extern -newgvn -called-value-propagation -lower-guard-intrinsic -lower-matrix-intrinsics -div-rem-pairs -globaldce -instnamer -sroa -nary-reassociate -prune-eh -separate-const-offset-from-gep -lower-guard-intrinsic -newgvn -sancov -sccp -infer-address-spaces -bdce -partial-inliner -mergeicmps -sccp -rewrite-statepoints-for-gc -early-cse-memssa -early-cse-memssa -dse -called-value-propagation -div-rem-pairs -globalopt -strip-dead-prototypes -slsr -functionattrs -flattencfg -callsite-splitting -loop-predication -forceattrs -indvars -die -loop-reroll -rpo-functionattrs -ipconstprop -gvn-hoist -post-inline-ee-instrument -redundant-dbg-inst-elim -post-inline-ee-instrument -loweratomic -loop-interchange -lower-guard-intrinsic -nary-reassociate -loop-instsimplify -sink -instsimplify -globaldce -loop-versioning-licm -inferattrs -attributor -jump-threading input.bc -o output.bc +benchmark://cbench-v1/susan,0.991041719989762,14.902771949768066,opt -argpromotion -loweratomic -loop-unroll -slsr -loop-versioning -consthoist -functionattrs -alignment-from-assumptions -alignment-from-assumptions -dse -strip-dead-prototypes -loop-data-prefetch -lower-guard-intrinsic -loop-fusion -irce -dse -float2int -loop-distribute -correlated-propagation -elim-avail-extern -rewrite-statepoints-for-gc -prune-eh -loop-fusion -prune-eh -loop-distribute -redundant-dbg-inst-elim -load-store-vectorizer -alignment-from-assumptions -prune-eh -loop-unroll -simplifycfg -argpromotion -lower-guard-intrinsic -mem2reg -strip-nondebug -gvn -elim-avail-extern -loop-deletion -loop-sink -functionattrs -simple-loop-unswitch -loop-unroll-and-jam -separate-const-offset-from-gep -sccp -strip -simple-loop-unswitch -mergeicmps -mergeicmps -licm -name-anon-globals -irce -correlated-propagation -coro-early -loop-load-elim -early-cse-memssa -strip -rewrite-statepoints-for-gc -barrier -loop-data-prefetch -ee-instrument -libcalls-shrinkwrap -tailcallelim -strip-nondebug -canonicalize-aliases -elim-avail-extern -loop-fusion -early-cse-memssa -strip-nondebug -loop-sink -lowerinvoke -ipconstprop -inferattrs -slsr -ee-instrument -loop-deletion -coro-early -dse -lowerswitch -loop-reroll -inject-tli-mappings -instnamer -sink -loop-simplifycfg -lowerinvoke -load-store-vectorizer -speculative-execution -canonicalize-aliases -loop-versioning -simple-loop-unswitch -loop-fusion -adce -dce -loop-interchange -loop-load-elim -always-inline -elim-avail-extern -loop-distribute -always-inline -scalarizer -instsimplify -mldst-motion -mergefunc -newgvn -constmerge -ipsccp -separate-const-offset-from-gep -flattencfg -lower-matrix-intrinsics -simplifycfg -indvars -loop-unswitch -speculative-execution -adce -simple-loop-unswitch -separate-const-offset-from-gep -loop-simplify -loop-interchange -prune-eh -licm -mem2reg -speculative-execution -globalopt -instcombine -loop-versioning-licm -sccp -deadargelim -correlated-propagation -ipsccp -slp-vectorizer -load-store-vectorizer -loop-unroll-and-jam -licm -slp-vectorizer -forceattrs -loop-vectorize -partially-inline-libcalls -indvars -scalarizer -redundant-dbg-inst-elim -newgvn -mergereturn -slsr -strip-debug-declare -consthoist -loop-interchange -constmerge -instsimplify -constprop -inferattrs -add-discriminators -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/susan,0.9928333759918095,15.974971294403076,opt -dse -add-discriminators -mem2reg -loop-predication -loop-reroll -prune-eh -guard-widening -irce -strip-nondebug -loop-distribute -separate-const-offset-from-gep -loop-versioning-licm -ipconstprop -memcpyopt -newgvn -newgvn -consthoist -name-anon-globals -correlated-propagation -mldst-motion -redundant-dbg-inst-elim -licm -callsite-splitting -constmerge -scalarizer -canonicalize-aliases -argpromotion -instcombine -loop-unroll -instsimplify -nary-reassociate -loop-simplify -early-cse-memssa -loop-unswitch -mergeicmps -canonicalize-aliases -ipsccp -globaldce -loop-fusion -lower-matrix-intrinsics -post-inline-ee-instrument -post-inline-ee-instrument -loop-versioning-licm -sink -strip -dse -libcalls-shrinkwrap -float2int -loop-instsimplify -break-crit-edges -sccp -constmerge -alignment-from-assumptions -add-discriminators -argpromotion -instcombine -loweratomic -constmerge -loop-instsimplify -prune-eh -loop-vectorize -float2int -lower-expect -lcssa -forceattrs -coro-cleanup -div-rem-pairs -loop-fusion -nary-reassociate -argpromotion -irce -separate-const-offset-from-gep -separate-const-offset-from-gep -globalopt -redundant-dbg-inst-elim -lower-matrix-intrinsics -loop-vectorize -loop-versioning -gvn-hoist -loop-data-prefetch -correlated-propagation -loop-unswitch -ipsccp -add-discriminators -loop-guard-widening -globaldce -ee-instrument -speculative-execution -loop-data-prefetch -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/susan,0.9929613514205275,15.52566409111023,opt -constprop -lowerswitch -float2int -barrier -loop-deletion -loop-predication -lower-constant-intrinsics -speculative-execution -early-cse-memssa -lower-guard-intrinsic -reassociate -globaldce -load-store-vectorizer -insert-gcov-profiling -loop-fusion -globaldce -prune-eh -prune-eh -div-rem-pairs -sroa -correlated-propagation -loop-guard-widening -coro-early -mergereturn -gvn -add-discriminators -sccp -speculative-execution -break-crit-edges -strip-dead-prototypes -rpo-functionattrs -lower-expect -loop-sink -rewrite-statepoints-for-gc -callsite-splitting -mergefunc -infer-address-spaces -rpo-functionattrs -coro-early -speculative-execution -aggressive-instcombine -globaldce -loop-guard-widening -strip-nondebug -indvars -loop-deletion -coro-early -reassociate -loop-idiom -loop-vectorize -strip -bdce -scalarizer -callsite-splitting -die -gvn -globalopt -mem2reg -loop-load-elim -loop-load-elim -mergefunc -instsimplify -loop-instsimplify -lower-matrix-intrinsics -attributor -callsite-splitting -lower-guard-intrinsic -scalarizer -hotcoldsplit -loop-unroll-and-jam -loop-versioning-licm -lower-widenable-condition -simple-loop-unswitch -mergereturn -globalsplit -canonicalize-aliases -lower-constant-intrinsics -consthoist -pgo-memop-opt -hotcoldsplit -insert-gcov-profiling -callsite-splitting -slp-vectorizer -alignment-from-assumptions -inject-tli-mappings -guard-widening -add-discriminators -early-cse-memssa -elim-avail-extern -licm -pgo-memop-opt -functionattrs -loop-sink -jump-threading -tailcallelim -name-anon-globals -loop-reroll -cross-dso-cfi -sccp -dce -loop-instsimplify -globalopt -always-inline -elim-avail-extern -globalopt -nary-reassociate -early-cse-memssa -partial-inliner -loop-distribute -indvars -simplifycfg -partially-inline-libcalls -div-rem-pairs -loop-load-elim -loop-fusion -inject-tli-mappings -sancov -loop-instsimplify -constprop -die -flattencfg -loop-predication -gvn-hoist -adce -loop-load-elim -scalarizer -reassociate -callsite-splitting -cross-dso-cfi -lower-matrix-intrinsics -name-anon-globals -lower-matrix-intrinsics -loop-guard-widening -canonicalize-aliases -loop-distribute -sancov -ipsccp -coro-cleanup -reg2mem -load-store-vectorizer -deadargelim -loop-data-prefetch -ipconstprop -load-store-vectorizer -canonicalize-aliases -loop-guard-widening -attributor -ipsccp -loop-unroll -mergereturn -loop-versioning -add-discriminators -load-store-vectorizer -barrier -loop-interchange -guard-widening -loop-reroll -simple-loop-unswitch -gvn-hoist -functionattrs -elim-avail-extern -partially-inline-libcalls -cross-dso-cfi -coro-early -ipconstprop -reassociate -strip-dead-prototypes -mergefunc -sroa -rpo-functionattrs -add-discriminators -scalarizer -float2int -lower-expect -hotcoldsplit -dce -coro-split -name-anon-globals -simplifycfg -rewrite-statepoints-for-gc -callsite-splitting -speculative-execution -adce -loop-unroll -constmerge -early-cse-memssa -sccp -constmerge -loop-instsimplify -adce -attributor -sccp -instsimplify -libcalls-shrinkwrap -loop-guard-widening -hotcoldsplit -prune-eh -canonicalize-aliases -constmerge -lowerinvoke -loop-unswitch -name-anon-globals -cross-dso-cfi -redundant-dbg-inst-elim -loop-simplifycfg -rewrite-statepoints-for-gc -strip-debug-declare -loop-data-prefetch -coro-early -mergereturn -scalarizer -simple-loop-unswitch -loweratomic -lower-constant-intrinsics -gvn-hoist -inferattrs -lower-matrix-intrinsics -slsr -libcalls-shrinkwrap -gvn -sink -mergefunc -lower-guard-intrinsic -flattencfg -instnamer -licm -guard-widening -always-inline -flattencfg -functionattrs -barrier -instcombine input.bc -o output.bc +benchmark://cbench-v1/susan,0.9946250319938573,311.2034537792206,opt -irce -dce -speculative-execution -rewrite-statepoints-for-gc -aggressive-instcombine -ipsccp -loop-distribute -slp-vectorizer -loop-simplify -loop-rotate -memcpyopt -reg2mem -inferattrs -inferattrs -hotcoldsplit -lower-constant-intrinsics -loop-guard-widening -consthoist -pgo-memop-opt -always-inline -loop-unroll-and-jam -cross-dso-cfi -loop-fusion -speculative-execution -name-anon-globals -lcssa -sink -strip-dead-prototypes -loop-versioning -barrier -loop-data-prefetch -loop-reduce -dce -sink -ipsccp -mem2reg -scalarizer -globalopt -bdce -newgvn -coro-elide -libcalls-shrinkwrap -loop-data-prefetch -coro-split -mem2reg -speculative-execution -speculative-execution -sancov -globalopt -infer-address-spaces -loop-simplify -globaldce -post-inline-ee-instrument -loop-data-prefetch -break-crit-edges -coro-elide -partial-inliner -forceattrs -constprop -break-crit-edges -ee-instrument -indvars -loop-unroll -mergefunc -coro-split -float2int -argpromotion -correlated-propagation -lowerswitch -simplifycfg -aggressive-instcombine -strip -infer-address-spaces -mem2reg -reassociate -hotcoldsplit -coro-early -lower-expect -alignment-from-assumptions -jump-threading -loop-guard-widening -instnamer -constprop -inferattrs -gvn -early-cse-memssa -instcombine -loop-versioning -gvn -loop-sink -gvn-hoist -slp-vectorizer -sancov -guard-widening -lower-widenable-condition -mergeicmps -constmerge -indvars -irce -pgo-memop-opt -lower-expect -lowerswitch -loop-load-elim -div-rem-pairs -ipconstprop -functionattrs -dse -lower-widenable-condition -loop-fusion -aggressive-instcombine -elim-avail-extern -sroa -sccp -flattencfg -loop-simplify -loop-versioning -simplifycfg -flattencfg -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/susan,0.9974404914256462,14.56405782699585,opt -mem2reg -scalarizer -instsimplify -sink -loop-instsimplify -inferattrs -loop-versioning-licm -sancov -early-cse-memssa -dse -mergeicmps -called-value-propagation -simple-loop-unswitch -die -simplifycfg -add-discriminators -loop-sink -flattencfg -sink -libcalls-shrinkwrap -always-inline -coro-cleanup -mldst-motion -loop-versioning -partial-inliner -aggressive-instcombine -reg2mem -loop-reroll -name-anon-globals -lcssa -sroa -slsr -loop-unswitch -hotcoldsplit -sccp -reassociate -strip-dead-prototypes -partially-inline-libcalls -partial-inliner -add-discriminators -lowerinvoke -globalopt -rewrite-statepoints-for-gc -strip -sccp -instsimplify -loop-instsimplify -sccp -loop-simplifycfg -div-rem-pairs -infer-address-spaces -mldst-motion -partial-inliner -early-cse-memssa -sccp -strip-debug-declare -indvars -correlated-propagation -deadargelim -strip -memcpyopt -sancov -simple-loop-unswitch -inferattrs -loop-data-prefetch -bdce -inject-tli-mappings -ipsccp -loop-predication -licm -inject-tli-mappings -flattencfg -elim-avail-extern -simplifycfg -sancov -argpromotion -ee-instrument -pgo-memop-opt -lower-widenable-condition -loop-predication -rewrite-statepoints-for-gc -loop-unswitch -loop-fusion -loop-load-elim -lcssa -loop-reroll -lower-expect -instsimplify -scalarizer -guard-widening -partially-inline-libcalls -instcombine -callsite-splitting -coro-cleanup -jump-threading -deadargelim -loop-vectorize -loop-reroll -bdce -lower-matrix-intrinsics -scalarizer -early-cse-memssa -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/susan,1.000767852572306,13.883830785751343,opt -speculative-execution -elim-avail-extern -newgvn -strip-dead-prototypes -hotcoldsplit -loop-vectorize -die -simplifycfg -mldst-motion -lower-guard-intrinsic -consthoist -loop-unroll-and-jam -loop-load-elim -loweratomic -strip-nondebug -post-inline-ee-instrument -guard-widening -always-inline -ee-instrument -loop-sink -loop-unroll -insert-gcov-profiling -loop-data-prefetch -dse -consthoist -loop-reroll -mergefunc -partially-inline-libcalls -strip-dead-prototypes -die -lower-constant-intrinsics -alignment-from-assumptions -attributor -attributor -correlated-propagation -simple-loop-unswitch -consthoist -loop-instsimplify -add-discriminators -coro-cleanup -nary-reassociate -loop-distribute -newgvn -break-crit-edges -lcssa -loop-versioning -post-inline-ee-instrument -pgo-memop-opt -loop-simplify -coro-split -loop-unroll -partially-inline-libcalls -rpo-functionattrs -guard-widening -lower-matrix-intrinsics -newgvn -sroa -newgvn -loweratomic -mergereturn -strip -reg2mem -coro-split -early-cse-memssa -globalsplit -coro-early -rewrite-statepoints-for-gc -loop-load-elim -loop-predication -strip-dead-prototypes -loop-unswitch -consthoist -slsr -inferattrs -newgvn -loop-unroll-and-jam -deadargelim -irce -lower-expect -loop-interchange -loop-unroll -constprop -loop-guard-widening -globalopt -rewrite-statepoints-for-gc -sroa -callsite-splitting -globalsplit -elim-avail-extern -globalsplit -indvars -reassociate -strip-nondebug -dce -mergeicmps -dce -guard-widening -name-anon-globals -constprop -irce -sancov -gvn -instcombine -loop-vectorize -constprop -speculative-execution -canonicalize-aliases -break-crit-edges -add-discriminators -irce -loop-load-elim -bdce -called-value-propagation -loop-unroll-and-jam -loop-distribute -loop-idiom -slsr -argpromotion -pgo-memop-opt -infer-address-spaces -dse -inferattrs -loop-reroll -correlated-propagation -lower-widenable-condition -loop-simplify -indvars -callsite-splitting -scalarizer -lowerinvoke -jump-threading -loop-predication -hotcoldsplit -lower-matrix-intrinsics -post-inline-ee-instrument -mergeicmps -infer-address-spaces -loop-interchange -loop-vectorize -instsimplify input.bc -o output.bc +benchmark://cbench-v1/susan,1.0015357051446123,13.91321086883545,opt -sroa -jump-threading -sccp -lower-constant-intrinsics -ee-instrument -rpo-functionattrs -jump-threading -simplifycfg -mem2reg -name-anon-globals -coro-split -alignment-from-assumptions -loop-interchange -loop-data-prefetch -reg2mem -loop-unroll-and-jam -infer-address-spaces -loop-fusion -sroa -globaldce -callsite-splitting -loweratomic -loop-deletion -post-inline-ee-instrument -loop-instsimplify -indvars -slsr -ipconstprop -consthoist -simplifycfg -mergefunc -aggressive-instcombine -instsimplify -canonicalize-aliases -strip-dead-prototypes -partially-inline-libcalls -loop-interchange -gvn-hoist -add-discriminators -correlated-propagation -constprop -loop-versioning-licm -loop-versioning -instcombine -globalopt -float2int -float2int -inject-tli-mappings -dse -constmerge -loop-unroll -forceattrs -strip-dead-prototypes -aggressive-instcombine -loop-fusion -coro-split -ee-instrument -loop-unroll -simplifycfg -mldst-motion -indvars -inferattrs -loop-instsimplify -sccp -rewrite-statepoints-for-gc -pgo-memop-opt -add-discriminators -insert-gcov-profiling -loweratomic -loop-simplifycfg -scalarizer -loop-guard-widening -strip-debug-declare -constprop -loop-instsimplify -globaldce -partial-inliner -simple-loop-unswitch -called-value-propagation -loop-guard-widening -prune-eh -alignment-from-assumptions -canonicalize-aliases -lower-widenable-condition -loop-guard-widening -licm -rewrite-statepoints-for-gc -float2int -infer-address-spaces -elim-avail-extern -slp-vectorizer -consthoist -newgvn input.bc -o output.bc +benchmark://cbench-v1/susan,1.0239314051702073,13.509535074234009,opt -canonicalize-aliases -lower-matrix-intrinsics -memcpyopt -scalarizer -mem2reg -insert-gcov-profiling -newgvn -reg2mem -argpromotion -strip -simplifycfg -constprop -jump-threading -reg2mem -consthoist -barrier -partial-inliner -flattencfg -slp-vectorizer -add-discriminators -loop-instsimplify -instnamer -functionattrs -barrier -loop-unroll -loop-unroll -loop-sink -simplifycfg -die -loop-interchange -simple-loop-unswitch -reg2mem -loweratomic -globalsplit -mldst-motion -instnamer -loop-data-prefetch -rpo-functionattrs -lower-guard-intrinsic -lowerswitch -reassociate -mergereturn -indvars -deadargelim -speculative-execution -newgvn -attributor -load-store-vectorizer -coro-elide -loop-unswitch -dse -sccp -infer-address-spaces -loop-unroll-and-jam -loop-unroll-and-jam -add-discriminators -loop-data-prefetch -loop-simplifycfg -ipconstprop -div-rem-pairs -elim-avail-extern -loop-versioning -gvn -dce -rewrite-statepoints-for-gc -argpromotion -loop-instsimplify -strip-dead-prototypes -coro-cleanup -loop-unroll-and-jam -instcombine -loop-data-prefetch -newgvn -lower-widenable-condition -strip-dead-prototypes -inferattrs -tailcallelim -dce -div-rem-pairs -loop-guard-widening -dse -partial-inliner -coro-elide -instcombine -simple-loop-unswitch -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,0.9724202156237686,42.7266845703125,opt -break-crit-edges -guard-widening -partially-inline-libcalls -correlated-propagation -argpromotion -loop-versioning -redundant-dbg-inst-elim -dce -indvars -loop-instsimplify -loop-simplifycfg -loop-deletion -hotcoldsplit -globalopt -loop-data-prefetch -inject-tli-mappings -rpo-functionattrs -loop-unroll -functionattrs -lowerinvoke -globalsplit -lowerswitch -mergereturn -loop-predication -functionattrs -lcssa -post-inline-ee-instrument -argpromotion -licm -loop-data-prefetch -scalarizer -deadargelim -slsr -slsr -loop-deletion -guard-widening -strip-nondebug -die -libcalls-shrinkwrap -called-value-propagation -always-inline -hotcoldsplit -separate-const-offset-from-gep -loop-deletion -ipconstprop -mem2reg -flattencfg -loop-simplifycfg -insert-gcov-profiling -simplifycfg -forceattrs -gvn-hoist -alignment-from-assumptions -inferattrs -jump-threading -infer-address-spaces -slsr -loop-deletion -jump-threading -lower-expect -loop-data-prefetch -speculative-execution -newgvn -break-crit-edges -globaldce -instcombine -loweratomic -callsite-splitting -dce -die -inject-tli-mappings -slp-vectorizer -lowerinvoke -barrier -ipsccp -sccp -post-inline-ee-instrument -loop-versioning -slsr -dce -coro-split -gvn -memcpyopt -memcpyopt -loop-vectorize -loop-deletion -loop-sink -constprop -loop-vectorize -loop-simplify -mergefunc -ipsccp -loop-distribute -gvn -insert-gcov-profiling -coro-cleanup -loop-unroll -jump-threading -gvn -cross-dso-cfi -prune-eh -constprop -loop-guard-widening -lower-widenable-condition -mergefunc -adce -loop-idiom -loop-versioning-licm -coro-split -sroa -reassociate -coro-split -loop-vectorize -early-cse-memssa -loop-interchange -flattencfg -loop-reroll -slsr -strip-dead-prototypes -nary-reassociate -strip-dead-prototypes -loweratomic -gvn-hoist -attributor -slsr -name-anon-globals -prune-eh -called-value-propagation -cross-dso-cfi -cross-dso-cfi -gvn -div-rem-pairs -loop-versioning -elim-avail-extern -lower-matrix-intrinsics -instnamer -nary-reassociate -load-store-vectorizer -constmerge -instcombine -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,0.9850997528564778,43.625590324401855,opt -reassociate -lower-widenable-condition -nary-reassociate -loop-idiom -always-inline -cross-dso-cfi -infer-address-spaces -sink -bdce -loop-unroll -load-store-vectorizer -separate-const-offset-from-gep -deadargelim -bdce -callsite-splitting -loop-distribute -barrier -deadargelim -loop-unswitch -loop-versioning-licm -rpo-functionattrs -loop-guard-widening -loop-deletion -loop-idiom -canonicalize-aliases -speculative-execution -dse -break-crit-edges -loweratomic -cross-dso-cfi -div-rem-pairs -correlated-propagation -libcalls-shrinkwrap -inferattrs -early-cse-memssa -mem2reg -partial-inliner -loop-simplifycfg -loop-simplify -argpromotion -barrier -loop-reduce -canonicalize-aliases -slsr -speculative-execution -sancov -mldst-motion -constmerge -flattencfg -div-rem-pairs -redundant-dbg-inst-elim -lower-expect -instcombine -dce -libcalls-shrinkwrap -argpromotion -break-crit-edges -ipsccp -simple-loop-unswitch -simplifycfg -nary-reassociate -canonicalize-aliases -hotcoldsplit -mergeicmps -lower-constant-intrinsics -instsimplify input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,0.9884308177226978,42.622666358947754,opt -strip -globaldce -insert-gcov-profiling -irce -sancov -redundant-dbg-inst-elim -consthoist -sroa -globaldce -loop-fusion -slsr -jump-threading -tailcallelim -indvars -globalsplit -die -newgvn -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,0.9915111572764067,39.32834792137146,opt -lower-expect -simplifycfg -loop-instsimplify -insert-gcov-profiling -barrier -consthoist -post-inline-ee-instrument -tailcallelim -strip-nondebug -loop-simplify -loop-simplify -coro-cleanup -loop-distribute -name-anon-globals -sroa -bdce -ipsccp -insert-gcov-profiling -dce -globaldce -mem2reg -rpo-functionattrs -prune-eh -mergereturn -loop-versioning-licm -loop-distribute -bdce -ipconstprop -strip-debug-declare -bdce -gvn-hoist -alignment-from-assumptions -loop-data-prefetch -lower-expect -early-cse-memssa -instnamer -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,0.9944124073211789,42.087604999542236,opt -load-store-vectorizer -ipconstprop -canonicalize-aliases -libcalls-shrinkwrap -loop-unswitch -loop-guard-widening -loop-sink -argpromotion -dce -loop-instsimplify -loop-unroll -sccp -barrier -mem2reg -dce -separate-const-offset-from-gep -loweratomic -pgo-memop-opt -globalopt -irce -irce -called-value-propagation -lower-matrix-intrinsics -irce -indvars -sancov -called-value-propagation -coro-elide -break-crit-edges -rewrite-statepoints-for-gc -loop-deletion -prune-eh -loop-data-prefetch -strip-debug-declare -lower-guard-intrinsic -canonicalize-aliases -elim-avail-extern -lower-widenable-condition -newgvn -strip -called-value-propagation -coro-early -strip -ipsccp -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,0.9955585801783728,44.708903789520264,opt -inject-tli-mappings -sroa -loop-predication -globalopt -rewrite-statepoints-for-gc -sink -loop-instsimplify -functionattrs -loop-idiom -canonicalize-aliases -separate-const-offset-from-gep -aggressive-instcombine -ipconstprop -loop-simplify -lower-expect -gvn -scalarizer -reassociate -die -loop-interchange -sroa -lower-widenable-condition -consthoist -redundant-dbg-inst-elim -hotcoldsplit -constprop -loop-reroll -consthoist -sroa -canonicalize-aliases -strip -mergeicmps -add-discriminators -rpo-functionattrs -slsr -irce -constprop -constprop -sancov -lower-guard-intrinsic -break-crit-edges -loop-simplify -indvars -loop-instsimplify -mergefunc -loweratomic -irce -gvn-hoist -add-discriminators -instsimplify -aggressive-instcombine -coro-cleanup -inferattrs -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,0.9997492746874888,38.4443724155426,opt -consthoist -bdce -sroa -simplifycfg -early-cse-memssa -jump-threading -dce -lower-expect -gvn -gvn-hoist -redundant-dbg-inst-elim -constmerge -mergefunc -lowerinvoke -speculative-execution -slp-vectorizer -irce -mergereturn -float2int -early-cse-memssa -lowerinvoke -prune-eh -prune-eh -loop-reroll -lower-guard-intrinsic -loop-guard-widening -lowerinvoke -newgvn -post-inline-ee-instrument -aggressive-instcombine input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0063039507145672,50.186365604400635,opt -globaldce -lower-constant-intrinsics -coro-early -loop-unroll-and-jam -mergeicmps -lower-guard-intrinsic -loop-reduce -lower-guard-intrinsic -irce -bdce -callsite-splitting -elim-avail-extern -newgvn -float2int -simplifycfg -break-crit-edges -inject-tli-mappings -mergeicmps -add-discriminators -hotcoldsplit -deadargelim -attributor -lower-constant-intrinsics -float2int -name-anon-globals -always-inline -correlated-propagation -sroa -consthoist -strip-dead-prototypes -ipsccp -memcpyopt -globaldce -loop-instsimplify -loop-interchange -strip -reassociate -gvn -loop-versioning -irce -instnamer -barrier -lower-expect -barrier -loop-simplifycfg -strip-debug-declare -lower-guard-intrinsic -cross-dso-cfi -loop-instsimplify -gvn-hoist -gvn-hoist -sancov -mergereturn -aggressive-instcombine -mergefunc -bdce -loop-idiom -licm -coro-cleanup -sccp -ee-instrument -gvn -canonicalize-aliases -lower-widenable-condition -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0131809878577311,40.80617117881775,opt -functionattrs -mem2reg -tailcallelim -loop-distribute -break-crit-edges -gvn-hoist -rewrite-statepoints-for-gc -coro-elide -float2int -globalsplit -ipconstprop -guard-widening -infer-address-spaces -scalarizer -lower-expect -add-discriminators -bdce -insert-gcov-profiling -loop-simplify -irce -lowerinvoke -loop-reroll -slp-vectorizer -slsr -rewrite-statepoints-for-gc -forceattrs -licm -sccp -simple-loop-unswitch -loop-versioning -coro-early -slsr -coro-early -instsimplify -loop-versioning-licm -coro-cleanup -irce -sancov -indvars -elim-avail-extern -div-rem-pairs -bdce -called-value-propagation -loop-load-elim -loop-idiom -mem2reg -speculative-execution -consthoist -strip -licm -loop-predication -rewrite-statepoints-for-gc -insert-gcov-profiling -gvn -post-inline-ee-instrument -dse -nary-reassociate -strip-debug-declare -lower-expect -loop-unroll-and-jam -lower-guard-intrinsic -scalarizer -early-cse-memssa -rpo-functionattrs -sancov -loop-load-elim -loop-reduce -speculative-execution -functionattrs -mergefunc -memcpyopt -irce -loop-predication -deadargelim -strip-nondebug -functionattrs -speculative-execution -gvn -instcombine -memcpyopt -sccp -prune-eh -loop-vectorize -dse -reassociate -lower-matrix-intrinsics -simplifycfg -coro-cleanup -lower-constant-intrinsics -alignment-from-assumptions -cross-dso-cfi -irce -loop-unroll -instcombine -hotcoldsplit -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0268276084386976,46.057499408721924,opt -coro-split -loop-instsimplify -post-inline-ee-instrument -insert-gcov-profiling -guard-widening -loop-unroll -strip -dce -guard-widening -indvars -sancov -simplifycfg -lcssa -flattencfg -called-value-propagation -loop-distribute -jump-threading -lower-matrix-intrinsics -simple-loop-unswitch -mergefunc -loop-unroll -insert-gcov-profiling -mem2reg -adce -consthoist -strip-debug-declare -lower-expect -loop-guard-widening -loop-load-elim -mergefunc -deadargelim -irce -strip-dead-prototypes -gvn-hoist -slsr -loop-versioning -loop-fusion -memcpyopt -functionattrs -loop-distribute -loop-interchange -reassociate -barrier -float2int -pgo-memop-opt -indvars -slp-vectorizer -prune-eh -lower-widenable-condition -argpromotion -alignment-from-assumptions -elim-avail-extern -forceattrs -coro-elide -instcombine -aggressive-instcombine -reassociate -mem2reg -loop-versioning-licm -gvn -speculative-execution -loop-versioning-licm -bdce -tailcallelim -reg2mem -lower-constant-intrinsics -loop-fusion -sancov -mem2reg -instsimplify -loop-vectorize -globalsplit -partial-inliner -strip-debug-declare -flattencfg -loop-guard-widening -newgvn -irce -loop-versioning-licm -prune-eh -functionattrs -load-store-vectorizer -newgvn -lcssa -inject-tli-mappings -globalsplit -loop-deletion -loop-sink -inferattrs -loop-load-elim -hotcoldsplit -simple-loop-unswitch -loop-interchange -rewrite-statepoints-for-gc -hotcoldsplit -loop-data-prefetch -hotcoldsplit -functionattrs -flattencfg -deadargelim -aggressive-instcombine -post-inline-ee-instrument -break-crit-edges -bdce -lower-widenable-condition -flattencfg -inferattrs -gvn -globaldce -indvars -strip-debug-declare -licm -mergefunc -constmerge -irce -coro-split -post-inline-ee-instrument -loop-load-elim -redundant-dbg-inst-elim -rpo-functionattrs -gvn-hoist -loop-distribute -guard-widening -tailcallelim -adce -sroa -coro-early -jump-threading -speculative-execution -rewrite-statepoints-for-gc -early-cse-memssa -instcombine input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,0.9719230216860548,43.69095706939697,opt -adce -barrier -guard-widening -sancov -name-anon-globals -speculative-execution -mem2reg -ipconstprop -simple-loop-unswitch -strip -separate-const-offset-from-gep -always-inline -loop-versioning -loop-predication -loop-distribute -guard-widening -coro-split -constprop -lower-constant-intrinsics -constmerge -instcombine -tailcallelim -slp-vectorizer -mldst-motion -ee-instrument -loop-unroll -constprop -sroa -loop-sink -sink -libcalls-shrinkwrap -lowerswitch -ipsccp -instcombine -constmerge -separate-const-offset-from-gep -lower-matrix-intrinsics -simplifycfg -canonicalize-aliases -tailcallelim -ipsccp -always-inline -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,0.9994614390348989,43.0509147644043,opt -loop-unroll-and-jam -coro-split -loop-vectorize -strip-debug-declare -lowerinvoke -adce -guard-widening -reassociate -correlated-propagation -infer-address-spaces -coro-early -instnamer -loop-simplify -separate-const-offset-from-gep -newgvn -loop-vectorize -argpromotion -sancov -loop-reroll -coro-cleanup -ee-instrument -coro-early -post-inline-ee-instrument -instsimplify -canonicalize-aliases -strip-dead-prototypes -name-anon-globals -mem2reg -loop-fusion -gvn-hoist -lowerinvoke -called-value-propagation -loop-rotate -jump-threading -loop-instsimplify -lcssa -lower-expect -float2int -infer-address-spaces -mergefunc -mergereturn -mldst-motion -separate-const-offset-from-gep -lower-matrix-intrinsics -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0002872325147207,40.322293758392334,opt -loop-fusion -strip-nondebug -strip-debug-declare -jump-threading -gvn-hoist -mergeicmps -sroa -adce -ee-instrument -globaldce -loop-guard-widening -loop-data-prefetch -constprop -tailcallelim -guard-widening -sccp -indvars -loop-unroll -loop-unswitch -jump-threading -gvn -add-discriminators -always-inline -instcombine input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0014002585092634,43.58587026596069,opt -break-crit-edges -coro-early -strip -loop-versioning -mergefunc -mem2reg -reassociate -nary-reassociate -flattencfg -insert-gcov-profiling -sroa -strip-dead-prototypes -loop-versioning -die -correlated-propagation -slsr -loop-vectorize -div-rem-pairs -barrier -barrier -loop-predication -elim-avail-extern -gvn -loop-unroll-and-jam -loop-interchange -coro-split -attributor -inject-tli-mappings -pgo-memop-opt -jump-threading -lower-constant-intrinsics -loop-instsimplify -instsimplify -memcpyopt -mem2reg -always-inline -nary-reassociate -loop-deletion -dce -mergereturn -lcssa -instcombine input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0040212552060892,110.09268641471863,opt -ipsccp -callsite-splitting -mldst-motion -libcalls-shrinkwrap -loop-unroll -mldst-motion -loop-unroll -loop-unswitch -sroa -constmerge -lcssa -sccp -div-rem-pairs -constmerge -argpromotion -early-cse-memssa -prune-eh -insert-gcov-profiling -rpo-functionattrs -rewrite-statepoints-for-gc -constprop -attributor -dse -strip-nondebug -gvn-hoist -deadargelim -lower-constant-intrinsics -sroa -early-cse-memssa -coro-cleanup -strip-debug-declare -strip-dead-prototypes -div-rem-pairs -alignment-from-assumptions -scalarizer -licm -ee-instrument -rewrite-statepoints-for-gc -functionattrs -correlated-propagation -always-inline -loop-instsimplify -insert-gcov-profiling -reassociate -die -dse -strip -canonicalize-aliases -ipconstprop -early-cse-memssa -rpo-functionattrs -coro-cleanup -simple-loop-unswitch -libcalls-shrinkwrap -lower-guard-intrinsic -globaldce -loop-deletion -loweratomic -mergeicmps -inject-tli-mappings -coro-split -loop-unroll -callsite-splitting -loop-unroll -scalarizer -sroa -loop-data-prefetch -strip-dead-prototypes -div-rem-pairs -dse -slsr -libcalls-shrinkwrap -loop-data-prefetch -add-discriminators -adce -gvn -bdce -loop-instsimplify -loop-fusion -die -instsimplify -correlated-propagation -constmerge -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0187060175211833,35.92176580429077,opt -coro-early -attributor -mem2reg -argpromotion -ipconstprop -coro-cleanup -strip-debug-declare -scalarizer -break-crit-edges -inject-tli-mappings -loop-distribute -inferattrs -coro-cleanup -loop-simplifycfg -gvn -bdce -libcalls-shrinkwrap -consthoist -consthoist -bdce -loop-distribute -simplifycfg -coro-split -inject-tli-mappings -alignment-from-assumptions -always-inline -name-anon-globals -dse -barrier -rewrite-statepoints-for-gc -lower-matrix-intrinsics -coro-elide -instcombine input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0204653166738475,47.219963788986206,opt -loop-load-elim -gvn-hoist -irce -argpromotion -consthoist -ipconstprop -loop-distribute -alignment-from-assumptions -redundant-dbg-inst-elim -sroa -jump-threading -inferattrs -loop-reroll -instnamer -callsite-splitting -jump-threading -instnamer -lower-matrix-intrinsics -indvars -sancov -always-inline -loop-sink -lower-expect -mergefunc -coro-elide -tailcallelim -gvn-hoist -float2int -globaldce -early-cse-memssa -indvars -bdce -mem2reg -simplifycfg -memcpyopt -jump-threading -ee-instrument -infer-address-spaces -indvars -add-discriminators -instcombine input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0306979750107712,42.30078458786011,opt -rpo-functionattrs -globalopt -inject-tli-mappings -rewrite-statepoints-for-gc -name-anon-globals -loop-versioning -add-discriminators -bdce -globaldce -dce -load-store-vectorizer -mem2reg -ee-instrument -loop-simplifycfg -loop-interchange -break-crit-edges -infer-address-spaces -loop-versioning-licm -pgo-memop-opt -dce -loop-predication -speculative-execution -slp-vectorizer -callsite-splitting -bdce -dce -cross-dso-cfi -adce -partially-inline-libcalls -canonicalize-aliases -lower-widenable-condition -instcombine -correlated-propagation -inferattrs -coro-early -loop-unroll-and-jam -loop-interchange -globaldce -newgvn -simplifycfg -strip-nondebug -scalarizer -instcombine input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0324213700990954,46.63143301010132,opt -scalarizer -sccp -loop-unroll -infer-address-spaces -irce -lower-constant-intrinsics -forceattrs -instsimplify -inferattrs -elim-avail-extern -loop-distribute -loop-unswitch -mergefunc -lower-matrix-intrinsics -globalopt -consthoist -loop-versioning-licm -correlated-propagation -inferattrs -loop-versioning-licm -reassociate -libcalls-shrinkwrap -coro-early -load-store-vectorizer -loop-data-prefetch -redundant-dbg-inst-elim -tailcallelim -sroa -simplifycfg -add-discriminators -instnamer -simplifycfg -licm -simple-loop-unswitch -prune-eh -newgvn -loop-simplify -loop-fusion -rpo-functionattrs -loop-simplifycfg -jump-threading -always-inline -post-inline-ee-instrument -functionattrs -argpromotion -inferattrs -constprop -insert-gcov-profiling -sccp -alignment-from-assumptions -tailcallelim -dce -jump-threading -instcombine -loop-distribute -globaldce -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0421872755995978,62.661231994628906,opt -lower-constant-intrinsics -libcalls-shrinkwrap -lcssa -loop-simplifycfg -loop-data-prefetch -deadargelim -load-store-vectorizer -lower-guard-intrinsic -libcalls-shrinkwrap -loop-instsimplify -reg2mem -strip-debug-declare -sccp -inferattrs -globalopt -jump-threading -memcpyopt -loop-instsimplify -loop-sink -loop-unroll-and-jam -coro-early -attributor -loop-simplify -lower-widenable-condition -coro-early -ee-instrument -called-value-propagation -hotcoldsplit -loop-unroll -speculative-execution -coro-split -rpo-functionattrs -newgvn -div-rem-pairs -hotcoldsplit -tailcallelim -strip-dead-prototypes -lowerinvoke -canonicalize-aliases -name-anon-globals -sancov -gvn-hoist -separate-const-offset-from-gep -name-anon-globals -loop-simplifycfg -memcpyopt -strip-dead-prototypes -tailcallelim -sroa -cross-dso-cfi -loop-deletion -instsimplify -sancov -consthoist -loop-unroll -memcpyopt -loop-distribute -loop-predication -loweratomic -loop-data-prefetch -speculative-execution -name-anon-globals -aggressive-instcombine -coro-cleanup -lcssa -aggressive-instcombine -called-value-propagation -sancov -loop-predication -loop-fusion -libcalls-shrinkwrap -partially-inline-libcalls -coro-cleanup -constprop -loop-guard-widening -break-crit-edges -separate-const-offset-from-gep -lower-matrix-intrinsics -always-inline -mergereturn -sink -lower-guard-intrinsic -break-crit-edges -slsr -sancov -loop-load-elim -strip -lcssa -instcombine -callsite-splitting -coro-split -bdce -rpo-functionattrs -early-cse-memssa -loop-reroll -sancov -die -simplifycfg -coro-elide -lower-constant-intrinsics -loop-data-prefetch -mergefunc -lcssa -nary-reassociate -simple-loop-unswitch -attributor -loop-reroll -name-anon-globals -adce -inferattrs -licm -cross-dso-cfi -newgvn -newgvn -indvars -inferattrs -inject-tli-mappings -loop-unroll -guard-widening -loop-interchange -loop-simplify -instcombine -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffdither,0.9824466551326413,41.701881647109985,opt -dse -constprop -coro-split -sroa -mergereturn -cross-dso-cfi -rpo-functionattrs -memcpyopt -lower-widenable-condition -lowerinvoke -attributor -lowerinvoke -mergefunc -mergefunc -lower-constant-intrinsics -coro-early -prune-eh -loop-unroll-and-jam -slp-vectorizer -loop-unswitch -memcpyopt -loop-idiom -lcssa -post-inline-ee-instrument -jump-threading -constprop -gvn-hoist -simplifycfg -libcalls-shrinkwrap -gvn input.bc -o output.bc +benchmark://cbench-v1/tiffdither,0.9888985005767011,41.054413080215454,opt -infer-address-spaces -sink -elim-avail-extern -deadargelim -loop-distribute -gvn -loop-idiom -loop-deletion -rpo-functionattrs -ee-instrument -loop-versioning -simple-loop-unswitch -constprop -lower-expect -sancov -globalopt -elim-avail-extern -elim-avail-extern -dce -mergefunc -gvn -early-cse-memssa -die -irce -guard-widening -barrier -rewrite-statepoints-for-gc -mergereturn -gvn-hoist -loop-data-prefetch -functionattrs -mem2reg -partial-inliner -die -partial-inliner -strip-debug-declare -loop-distribute -coro-early -tailcallelim -mergereturn -lcssa -mldst-motion -libcalls-shrinkwrap -slsr -consthoist -infer-address-spaces -die -instsimplify -loop-load-elim -mergereturn -gvn -aggressive-instcombine -coro-cleanup -rewrite-statepoints-for-gc -consthoist -tailcallelim -aggressive-instcombine -hotcoldsplit -loop-reroll -strip-debug-declare -globalopt -memcpyopt -lower-matrix-intrinsics -correlated-propagation -newgvn -instcombine -strip -loop-guard-widening -loop-deletion -forceattrs -name-anon-globals -dse -libcalls-shrinkwrap -mergefunc -redundant-dbg-inst-elim -strip-nondebug -scalarizer -mldst-motion -sroa -globaldce -inferattrs -guard-widening -loop-unroll-and-jam -loop-instsimplify -instsimplify -partially-inline-libcalls -lower-widenable-condition -jump-threading -called-value-propagation -newgvn input.bc -o output.bc +benchmark://cbench-v1/tiffdither,0.9970444059976932,49.48758888244629,opt -guard-widening -pgo-memop-opt -gvn-hoist -early-cse-memssa -aggressive-instcombine -strip-nondebug -name-anon-globals -guard-widening -instsimplify -cross-dso-cfi -mem2reg -float2int -loop-data-prefetch -lower-expect -loop-predication -correlated-propagation -insert-gcov-profiling -sink -redundant-dbg-inst-elim -scalarizer -coro-early -elim-avail-extern -adce -scalarizer -separate-const-offset-from-gep -aggressive-instcombine -strip-dead-prototypes -partially-inline-libcalls -licm -loop-simplify -loop-unroll -called-value-propagation -scalarizer -add-discriminators -gvn -callsite-splitting -gvn -inject-tli-mappings -deadargelim -redundant-dbg-inst-elim -loop-rotate -gvn-hoist -functionattrs -simple-loop-unswitch -strip -instnamer -instcombine -loop-data-prefetch -lcssa -early-cse-memssa -indvars -reassociate -strip-nondebug -instcombine -early-cse-memssa -lower-widenable-condition -loop-reroll -post-inline-ee-instrument -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffdither,0.999315167243368,62.450594902038574,opt -lower-widenable-condition -gvn -cross-dso-cfi -strip-nondebug -always-inline -loweratomic -tailcallelim -lower-constant-intrinsics -indvars -mem2reg -float2int -ipconstprop -argpromotion -die -pgo-memop-opt -speculative-execution -dse -globalsplit -loop-fusion -pgo-memop-opt -called-value-propagation -flattencfg -callsite-splitting -loop-data-prefetch -loop-predication -prune-eh -jump-threading -callsite-splitting -div-rem-pairs -loop-simplifycfg -indvars -die -loop-unroll -licm -ipsccp -newgvn -simplifycfg -gvn-hoist -globalopt -coro-early -loop-simplify -loop-deletion -ipsccp -canonicalize-aliases -always-inline -coro-cleanup -globaldce -constprop -gvn -loop-load-elim -lower-guard-intrinsic -nary-reassociate -barrier -infer-address-spaces -lowerinvoke -always-inline -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.0058751441753175,39.923675298690796,opt -post-inline-ee-instrument -coro-early -coro-early -add-discriminators -sroa -hotcoldsplit -loop-unroll -always-inline -insert-gcov-profiling -insert-gcov-profiling -indvars -memcpyopt -ipconstprop -always-inline -instcombine -insert-gcov-profiling -ee-instrument -rpo-functionattrs -adce -reg2mem -gvn-hoist -pgo-memop-opt -instnamer -called-value-propagation -rewrite-statepoints-for-gc -tailcallelim -sccp -barrier -flattencfg -simplifycfg -loweratomic -mergefunc -coro-elide -mem2reg -dse -forceattrs -deadargelim -strip-nondebug -loop-simplify -rpo-functionattrs -slsr -early-cse-memssa -loop-idiom -break-crit-edges -memcpyopt -called-value-propagation -loop-simplifycfg -lower-widenable-condition -mem2reg -dce -consthoist -jump-threading -licm -loop-simplify -adce -strip-dead-prototypes -loop-guard-widening -loop-idiom -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.0083621683967705,67.24185132980347,opt -prune-eh -coro-early -loop-deletion -simplifycfg -instnamer -inject-tli-mappings -bdce -lower-expect -div-rem-pairs -lowerinvoke -loop-load-elim -mergefunc -nary-reassociate -partially-inline-libcalls -prune-eh -sroa -aggressive-instcombine -tailcallelim -gvn-hoist -loop-simplifycfg -sccp -simplifycfg -instsimplify -early-cse-memssa -forceattrs -add-discriminators -dse -insert-gcov-profiling -correlated-propagation -lower-matrix-intrinsics -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.0100562283737027,38.78786373138428,opt -reg2mem -post-inline-ee-instrument -lower-matrix-intrinsics -dce -loop-distribute -ipsccp -newgvn -consthoist -sancov -load-store-vectorizer -mem2reg -indvars -sink -bdce -early-cse-memssa -loop-guard-widening -slp-vectorizer -tailcallelim -scalarizer -strip -licm -constmerge -cross-dso-cfi -mergereturn -gvn -simplifycfg -redundant-dbg-inst-elim -globalopt -inject-tli-mappings -inferattrs -libcalls-shrinkwrap -canonicalize-aliases -bdce -globaldce -instnamer -always-inline -rewrite-statepoints-for-gc -rpo-functionattrs -loop-vectorize -dse -div-rem-pairs -div-rem-pairs -simple-loop-unswitch -prune-eh -flattencfg -gvn -loop-deletion -elim-avail-extern -adce -functionattrs -instcombine input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.0121828143021916,41.328232288360596,opt -deadargelim -scalarizer -sancov -sancov -name-anon-globals -lowerinvoke -reg2mem -slsr -loop-guard-widening -die -jump-threading -argpromotion -loop-vectorize -loop-distribute -lower-constant-intrinsics -simple-loop-unswitch -loop-reroll -lower-expect -adce -separate-const-offset-from-gep -lower-guard-intrinsic -simple-loop-unswitch -reassociate -mem2reg -cross-dso-cfi -attributor -sroa -div-rem-pairs -guard-widening -mergefunc -barrier -forceattrs -redundant-dbg-inst-elim -lower-widenable-condition -loop-idiom -consthoist -mergeicmps -callsite-splitting -tailcallelim -globalsplit -add-discriminators -inject-tli-mappings -argpromotion -globalopt -loop-instsimplify -scalarizer -loop-guard-widening -loop-load-elim -mergefunc -instsimplify -nary-reassociate -loop-simplifycfg -deadargelim -loop-instsimplify -scalarizer -hotcoldsplit -simple-loop-unswitch -lower-expect -die -lcssa -early-cse-memssa -rewrite-statepoints-for-gc -strip-dead-prototypes -licm -loop-unswitch -instcombine -separate-const-offset-from-gep -loop-deletion -loop-versioning-licm -loop-versioning -simplifycfg -loop-interchange -attributor -redundant-dbg-inst-elim -globalopt -mldst-motion -gvn -loop-unroll-and-jam -argpromotion -cross-dso-cfi -loop-deletion -sancov -lower-expect -instcombine -loop-predication -gvn input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.0269247404844288,40.07159352302551,opt -div-rem-pairs -mem2reg -mergereturn -mergeicmps -loop-distribute -instcombine -mergefunc -loop-load-elim -infer-address-spaces -loop-distribute -lcssa -forceattrs -loop-predication -dce -libcalls-shrinkwrap -mergeicmps -loop-versioning-licm -memcpyopt -irce -float2int -loop-fusion -float2int -break-crit-edges -div-rem-pairs -coro-elide -attributor -loop-deletion -coro-elide -name-anon-globals -rpo-functionattrs -irce -inferattrs -canonicalize-aliases -newgvn -lower-constant-intrinsics -lower-constant-intrinsics -argpromotion -simplifycfg -forceattrs -add-discriminators -loop-instsimplify -instcombine -inferattrs -prune-eh -slp-vectorizer -correlated-propagation -aggressive-instcombine -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.0273212226066895,331.82224774360657,opt -strip-dead-prototypes -cross-dso-cfi -loop-distribute -mergefunc -loop-idiom -loop-distribute -lower-widenable-condition -loop-deletion -coro-cleanup -lcssa -post-inline-ee-instrument -elim-avail-extern -add-discriminators -consthoist -inferattrs -partially-inline-libcalls -sink -reg2mem -loop-deletion -coro-early -simplifycfg -strip-nondebug -lcssa -coro-cleanup -indvars -load-store-vectorizer -licm -always-inline -simple-loop-unswitch -instsimplify -sroa -mergeicmps -globaldce -separate-const-offset-from-gep -loweratomic -instcombine -tailcallelim -canonicalize-aliases -loop-predication -tailcallelim -newgvn -partially-inline-libcalls -callsite-splitting -alignment-from-assumptions -strip-nondebug -coro-elide -loop-interchange -coro-split -load-store-vectorizer -lower-constant-intrinsics -guard-widening -nary-reassociate -lowerinvoke -loop-deletion -float2int -constprop -loop-simplify -simplifycfg -separate-const-offset-from-gep -consthoist -early-cse-memssa -jump-threading -newgvn -cross-dso-cfi -pgo-memop-opt -elim-avail-extern -attributor -scalarizer -barrier -coro-cleanup -early-cse-memssa -nary-reassociate -inferattrs -loop-simplify -ipconstprop -speculative-execution -strip -strip-dead-prototypes -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,0.9665311977049962,47.10209608078003,opt -name-anon-globals -globalopt -loop-rotate -lower-widenable-condition -flattencfg -instnamer -div-rem-pairs -lcssa -loop-deletion -loop-rotate -die -ipconstprop -libcalls-shrinkwrap -sink -simplifycfg -loop-simplifycfg -infer-address-spaces -coro-early -attributor -scalarizer -bdce -mem2reg -lowerinvoke -attributor -loop-unroll-and-jam -pgo-memop-opt -ipconstprop -globalsplit -instsimplify -strip -hotcoldsplit -newgvn -instsimplify -licm -loop-distribute -loop-distribute -lcssa -nary-reassociate -lower-guard-intrinsic -reassociate -loop-unroll -guard-widening -lcssa -irce -indvars -strip -coro-early -strip -constprop -mergeicmps -canonicalize-aliases -instcombine -instsimplify -loop-reroll -mergeicmps -loop-fusion -float2int -dse -gvn -rpo-functionattrs -gvn-hoist -flattencfg -loop-distribute -reassociate input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,0.9784843413817833,45.35628080368042,opt -sink -deadargelim -mldst-motion -gvn-hoist -globalopt -elim-avail-extern -infer-address-spaces -instnamer -lcssa -ipconstprop -insert-gcov-profiling -insert-gcov-profiling -inferattrs -mergeicmps -adce -loop-simplifycfg -callsite-splitting -mem2reg -loop-fusion -instsimplify -redundant-dbg-inst-elim -callsite-splitting -mem2reg -tailcallelim -aggressive-instcombine -loop-rotate -constprop -attributor -gvn -consthoist -mldst-motion -sancov -argpromotion -redundant-dbg-inst-elim -simplifycfg -nary-reassociate input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,0.9825142583928143,44.82570767402649,opt -callsite-splitting -rpo-functionattrs -loop-load-elim -partially-inline-libcalls -lower-matrix-intrinsics -separate-const-offset-from-gep -nary-reassociate -lowerinvoke -dse -sink -loop-data-prefetch -separate-const-offset-from-gep -strip-nondebug -gvn -elim-avail-extern -loop-vectorize -strip-nondebug -strip -lower-expect -coro-cleanup -irce -bdce -loop-load-elim -constprop -lowerinvoke -mem2reg -gvn -simplifycfg -inferattrs -ipsccp -lower-guard-intrinsic -memcpyopt -early-cse-memssa -mergeicmps -attributor -strip -argpromotion -loop-distribute -loop-fusion -ipsccp -coro-cleanup -newgvn -slp-vectorizer -loop-data-prefetch -mem2reg -die -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,0.990608244253953,337.1097273826599,opt -partially-inline-libcalls -mem2reg -attributor -consthoist -loweratomic -libcalls-shrinkwrap -loop-guard-widening -loweratomic -lower-expect -instcombine -loop-fusion -inferattrs -argpromotion -aggressive-instcombine -loop-rotate -elim-avail-extern -cross-dso-cfi -strip -div-rem-pairs -correlated-propagation -ee-instrument -sccp -post-inline-ee-instrument -simple-loop-unswitch -loop-interchange -forceattrs -add-discriminators -lcssa -loop-load-elim -rewrite-statepoints-for-gc -inject-tli-mappings -sink -mergeicmps -strip -coro-early -rewrite-statepoints-for-gc -lower-guard-intrinsic -lower-constant-intrinsics -argpromotion -newgvn -cross-dso-cfi -cross-dso-cfi -lower-constant-intrinsics -instnamer -loop-idiom -hotcoldsplit -mergereturn -licm -loop-load-elim -tailcallelim -coro-cleanup -sink -sccp -sroa -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,0.9914278883917897,41.52029347419739,opt -rpo-functionattrs -loop-unswitch -elim-avail-extern -ipsccp -dse -float2int -consthoist -lower-widenable-condition -flattencfg -strip-dead-prototypes -functionattrs -instcombine -partially-inline-libcalls -coro-cleanup -hotcoldsplit -rpo-functionattrs -libcalls-shrinkwrap -rpo-functionattrs -partially-inline-libcalls -slp-vectorizer -mergeicmps -coro-early -gvn-hoist -simple-loop-unswitch -loop-instsimplify -loop-guard-widening -pgo-memop-opt -loop-guard-widening -loop-reduce -div-rem-pairs -instsimplify -alignment-from-assumptions -rewrite-statepoints-for-gc -gvn-hoist -name-anon-globals -sroa -loop-instsimplify -coro-early -reassociate -libcalls-shrinkwrap -float2int -sancov -break-crit-edges -partial-inliner -lcssa -scalarizer -strip -early-cse-memssa -newgvn -memcpyopt -globalopt -deadargelim -globalsplit -simplifycfg -mergeicmps -functionattrs -mldst-motion -lower-matrix-intrinsics -ipsccp -coro-cleanup -dse -loop-unswitch -instcombine -ipconstprop -reg2mem -flattencfg -flattencfg -loop-reduce -coro-split -loop-deletion -loop-simplify -canonicalize-aliases -loop-load-elim -prune-eh -called-value-propagation -sccp -loop-versioning -coro-split -break-crit-edges -inject-tli-mappings -sroa -ipconstprop -lower-matrix-intrinsics -functionattrs -always-inline -elim-avail-extern -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,0.9923499880468563,40.777365922927856,opt -cross-dso-cfi -gvn -die -mem2reg -lcssa -rpo-functionattrs -reassociate -simplifycfg -name-anon-globals -lower-guard-intrinsic -inject-tli-mappings -irce -irce -jump-threading -loop-versioning-licm -inject-tli-mappings -aggressive-instcombine -newgvn -strip-debug-declare -sink -reassociate -aggressive-instcombine input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,0.9933062395409992,46.45159435272217,opt -separate-const-offset-from-gep -mergefunc -strip -ee-instrument -reg2mem -always-inline -scalarizer -coro-cleanup -flattencfg -lcssa -globaldce -sroa -memcpyopt -slp-vectorizer -loop-deletion -coro-early -loop-reduce -break-crit-edges -die -callsite-splitting -instsimplify -coro-split -sroa -instcombine -flattencfg -lower-widenable-condition -loop-unroll-and-jam -bdce -coro-cleanup -mergeicmps -redundant-dbg-inst-elim -loop-simplifycfg -prune-eh -rewrite-statepoints-for-gc -instsimplify -elim-avail-extern -ipsccp -strip-nondebug -dse -gvn -strip -consthoist -elim-avail-extern -partially-inline-libcalls -slsr -loop-idiom -div-rem-pairs -alignment-from-assumptions -coro-elide -simplifycfg -die input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,0.9949796796557496,49.326151609420776,opt -forceattrs -loop-distribute -slp-vectorizer -constmerge -libcalls-shrinkwrap -loop-idiom -sroa -gvn-hoist -simplifycfg -loop-sink -instnamer -instnamer -gvn -constmerge -loop-guard-widening -lower-constant-intrinsics -pgo-memop-opt -forceattrs -rpo-functionattrs -scalarizer -instnamer -loop-rotate -loweratomic -canonicalize-aliases -sink -instcombine -separate-const-offset-from-gep -aggressive-instcombine -loop-predication -instsimplify -ee-instrument -deadargelim -coro-cleanup -coro-split -callsite-splitting -lower-matrix-intrinsics -slsr -loop-predication -hotcoldsplit -mergeicmps -reassociate -always-inline -bdce -strip-nondebug -globaldce -loop-fusion -hotcoldsplit -loop-instsimplify -ipsccp -coro-split -ipconstprop -globaldce -barrier -strip-nondebug -coro-cleanup -sroa -inferattrs -mldst-motion -mergeicmps -post-inline-ee-instrument -globalsplit -globalsplit -adce -lower-guard-intrinsic -sccp -strip-nondebug -loop-reduce -break-crit-edges -deadargelim -memcpyopt -globalopt -sccp -loop-fusion -alignment-from-assumptions -loop-unroll -adce -speculative-execution -dse -die -gvn -coro-cleanup -strip -simple-loop-unswitch -correlated-propagation -lower-guard-intrinsic -constmerge -simplifycfg -gvn -gvn-hoist -lowerinvoke -called-value-propagation -instsimplify input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0114408660906389,45.817564964294434,opt -deadargelim -separate-const-offset-from-gep -alignment-from-assumptions -lower-widenable-condition -loop-versioning -sroa -loop-fusion -loop-distribute -mergereturn -alignment-from-assumptions -guard-widening -partially-inline-libcalls -hotcoldsplit -elim-avail-extern -break-crit-edges -rpo-functionattrs -alignment-from-assumptions -deadargelim -gvn-hoist -deadargelim -consthoist -break-crit-edges -loop-vectorize -reassociate -loop-load-elim -strip-nondebug -instcombine -div-rem-pairs -callsite-splitting -lowerinvoke -strip-dead-prototypes -loop-guard-widening -constprop -loop-versioning-licm -loop-interchange -loop-guard-widening -sroa -load-store-vectorizer -instcombine -loop-interchange -loop-vectorize -strip -newgvn -loop-sink -sroa -rewrite-statepoints-for-gc -simple-loop-unswitch -loop-unroll-and-jam -simplifycfg -loop-sink -float2int -simplifycfg -loop-fusion -separate-const-offset-from-gep -loop-predication -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0162221235613536,45.437578201293945,opt -lowerinvoke -strip -inject-tli-mappings -mem2reg -called-value-propagation -callsite-splitting -globalopt -irce -simplifycfg -irce -sccp -infer-address-spaces -instcombine -loop-predication -slp-vectorizer -constmerge -instsimplify -canonicalize-aliases -memcpyopt -always-inline -dse -functionattrs -sancov -rewrite-statepoints-for-gc -lower-expect -dse -irce -jump-threading -aggressive-instcombine -loop-deletion -adce -separate-const-offset-from-gep -deadargelim -globalsplit -add-discriminators -loop-sink -strip-nondebug -mem2reg -scalarizer -constmerge -newgvn input.bc -o output.bc diff --git a/leaderboard/llvm_instcount/random_search/results_p125_t10800.csv b/leaderboard/llvm_instcount/random_search/results_p125_t10800.csv index 342ce3581..c00e8935c 100644 --- a/leaderboard/llvm_instcount/random_search/results_p125_t10800.csv +++ b/leaderboard/llvm_instcount/random_search/results_p125_t10800.csv @@ -1,24 +1,24 @@ benchmark,reward,walltime,commandline -benchmark://cBench-v1/adpcm,1.0083798882681567,10801.772290468216,opt -loop-distribute -strip-dead-prototypes -loop-unroll-and-jam -loop-distribute -constprop -called-value-propagation -infer-address-spaces -ee-instrument -hotcoldsplit -correlated-propagation -loop-unroll-and-jam -loop-distribute -loop-predication -sroa -infer-address-spaces -die -coro-elide -sancov -partially-inline-libcalls -memcpyopt -coro-early -mergeicmps -ipsccp -loop-predication -called-value-propagation -lowerinvoke -dse -globalsplit -irce -mergereturn -sroa -aggressive-instcombine -rewrite-statepoints-for-gc -coro-split -sancov -inline -instsimplify -sancov -infer-address-spaces -float2int -inject-tli-mappings -mldst-motion -speculative-execution -loop-unroll-and-jam -slsr -loop-unswitch -loweratomic -simplifycfg -dce -instcombine -barrier -div-rem-pairs -early-cse-memssa -loop-guard-widening -strip-nondebug -mergereturn -break-crit-edges -jump-threading -sroa -loweratomic -tailcallelim -nary-reassociate -div-rem-pairs -adce -instcombine -mergefunc -coro-cleanup -globaldce -instcombine -loop-versioning -gvn-hoist -lower-matrix-intrinsics -libcalls-shrinkwrap -globaldce -inline -loop-vectorize -jump-threading -guard-widening -mergeicmps -always-inline -inject-tli-mappings -separate-const-offset-from-gep -instnamer -mergeicmps -memcpyopt -mem2reg -sroa -separate-const-offset-from-gep -div-rem-pairs -lower-matrix-intrinsics -canonicalize-aliases -sancov -constmerge -loop-predication -cross-dso-cfi -simplifycfg -consthoist -barrier -bdce -reassociate -redundant-dbg-inst-elim -strip -instsimplify input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.0154867256637168,10801.793578386307,opt -functionattrs -globaldce -constmerge -argpromotion -sink -ipconstprop -reassociate -gvn-hoist -loop-reduce -loop-fusion -loop-simplifycfg -loop-unroll -mem2reg -indvars -name-anon-globals -early-cse-memssa -globaldce -dse -aggressive-instcombine -lower-constant-intrinsics -argpromotion -called-value-propagation -simplifycfg -loop-unroll-and-jam -rewrite-statepoints-for-gc -simple-loop-unswitch -early-cse-memssa -sroa -reg2mem -loop-simplifycfg -gvn-hoist -coro-early -memcpyopt -reassociate -sccp -tailcallelim -forceattrs -callsite-splitting -early-cse-memssa -loop-unroll -mem2reg -scalarizer -instcombine -pgo-memop-opt -lower-expect -aggressive-instcombine -mergeicmps -nary-reassociate -globaldce -callsite-splitting -coro-cleanup -globalsplit -simplifycfg -strip-nondebug -strip-dead-prototypes -inject-tli-mappings -strip -post-inline-ee-instrument -coro-elide -tailcallelim -libcalls-shrinkwrap -consthoist -rpo-functionattrs -redundant-dbg-inst-elim -sccp -libcalls-shrinkwrap -loop-versioning -elim-avail-extern input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0880407124681934,10801.877015829086,opt -simplifycfg -globalopt -constmerge -consthoist -globalopt -loop-reroll -sroa -coro-early -rpo-functionattrs -mergereturn -lcssa -loop-simplifycfg -mergeicmps -slsr -add-discriminators -flattencfg -instnamer -strip-dead-prototypes -libcalls-shrinkwrap -callsite-splitting -libcalls-shrinkwrap -loop-vectorize -pgo-memop-opt -correlated-propagation -lower-guard-intrinsic -globalopt -hotcoldsplit -loop-fusion -barrier -newgvn -loop-unroll -guard-widening -nary-reassociate -lower-widenable-condition -inferattrs -insert-gcov-profiling -bdce -coro-early -strip -sccp -elim-avail-extern -loop-fusion -strip -name-anon-globals -attributor -hotcoldsplit -lowerinvoke -correlated-propagation -licm -loop-fusion -alignment-from-assumptions -strip-dead-prototypes -loop-vectorize -strip-nondebug -strip-dead-prototypes -float2int -jump-threading -reassociate -redundant-dbg-inst-elim -coro-elide -coro-early -die -instcombine -libcalls-shrinkwrap -slsr -coro-elide -loop-versioning-licm -sancov -forceattrs -gvn-hoist -irce -loop-deletion -hotcoldsplit -div-rem-pairs -strip-debug-declare -break-crit-edges -correlated-propagation -strip -loop-instsimplify -simplifycfg -lower-widenable-condition -prune-eh -newgvn -instnamer -argpromotion -loop-distribute -loop-instsimplify -loweratomic -loop-versioning -slp-vectorizer -called-value-propagation -sancov -mergefunc -globalopt -loop-data-prefetch -coro-elide -strip-nondebug -indvars -scalarizer -loop-guard-widening -adce -float2int -coro-elide -loop-unroll-and-jam -coro-cleanup -canonicalize-aliases -early-cse-memssa -loop-guard-widening -rpo-functionattrs -guard-widening -loop-simplify -hotcoldsplit -coro-split -float2int -bdce -coro-cleanup -die -licm -div-rem-pairs -add-discriminators -strip-nondebug -strip-debug-declare -reassociate -instcombine -lower-constant-intrinsics -strip-dead-prototypes -sccp -slsr -deadargelim -lcssa -globaldce -dse -name-anon-globals -instnamer -globalsplit -globaldce -redundant-dbg-inst-elim -consthoist -gvn-hoist -lower-guard-intrinsic -elim-avail-extern -instsimplify -canonicalize-aliases -memcpyopt -load-store-vectorizer -mergefunc -callsite-splitting -adce -adce -instcombine -functionattrs -lower-matrix-intrinsics -lower-guard-intrinsic -partial-inliner -rewrite-statepoints-for-gc -coro-split -callsite-splitting -guard-widening -inject-tli-mappings -loop-reroll -correlated-propagation -post-inline-ee-instrument -ipconstprop -jump-threading -slp-vectorizer -ee-instrument -loop-instsimplify -slsr -loop-instsimplify -sink -loweratomic -strip-debug-declare -mldst-motion -slp-vectorizer -globalopt -post-inline-ee-instrument -bdce -instcombine input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.209654741446649,10808.157907485962,opt -separate-const-offset-from-gep -barrier -lower-constant-intrinsics -loop-interchange -partially-inline-libcalls -bdce -constmerge -lcssa -loop-sink -globalopt -loop-simplifycfg -loop-deletion -loop-sink -lower-matrix-intrinsics -loop-fusion -strip-nondebug -loop-data-prefetch -licm -constmerge -globalopt -bdce -alignment-from-assumptions -sccp -forceattrs -functionattrs -loop-simplify -sroa -globalsplit -licm -newgvn -lowerinvoke -loop-reroll -ipsccp -globalsplit -speculative-execution -loweratomic -break-crit-edges -adce -loop-load-elim -tailcallelim -barrier -loop-vectorize -loop-guard-widening -callsite-splitting -gvn-hoist -simple-loop-unswitch -consthoist -simplifycfg -insert-gcov-profiling -nary-reassociate -flattencfg -prune-eh -constmerge -guard-widening -constmerge -memcpyopt -memcpyopt -globaldce -instcombine input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,10802.23005247116,opt -loop-sink -jump-threading -prune-eh -loop-instsimplify -reg2mem -nary-reassociate -break-crit-edges -lower-constant-intrinsics -loop-fusion -consthoist -infer-address-spaces -loop-guard-widening -scalarizer -callsite-splitting -lower-constant-intrinsics -alignment-from-assumptions -load-store-vectorizer -coro-cleanup -correlated-propagation -consthoist -insert-gcov-profiling -inject-tli-mappings -adce -loweratomic -loop-data-prefetch -mergeicmps -constprop -callsite-splitting -deadargelim -float2int -coro-cleanup -loop-interchange -functionattrs -float2int -loop-reroll -loop-versioning -indvars -redundant-dbg-inst-elim -separate-const-offset-from-gep -early-cse-memssa -libcalls-shrinkwrap -inferattrs -rewrite-statepoints-for-gc -reassociate -bdce -loop-versioning-licm -nary-reassociate -break-crit-edges -lower-widenable-condition -loop-unswitch -gvn-hoist -memcpyopt -scalarizer -loop-data-prefetch -sccp -alignment-from-assumptions -newgvn -lowerinvoke -die -lower-widenable-condition -irce -mergeicmps -coro-cleanup -alignment-from-assumptions -break-crit-edges -instcombine -mem2reg -called-value-propagation -reassociate -mergefunc -constmerge -loop-versioning-licm -indvars -gvn -insert-gcov-profiling -barrier -globalopt -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.9948979591836737,10801.72380065918,opt -loop-deletion -mem2reg -load-store-vectorizer -loop-unroll -loop-distribute -loop-fusion -loop-reroll -callsite-splitting -flattencfg -prune-eh -loop-load-elim -flattencfg -newgvn -loop-idiom -inferattrs -licm -sink -loop-vectorize -post-inline-ee-instrument -flattencfg -add-discriminators -bdce -lower-constant-intrinsics -loop-reduce -post-inline-ee-instrument -sancov -lower-widenable-condition -slsr -div-rem-pairs -lowerswitch -dce -indvars -loop-simplifycfg -lower-guard-intrinsic -inferattrs -name-anon-globals -jump-threading -lowerinvoke -loop-simplify -loop-simplify -inject-tli-mappings -callsite-splitting -loop-unroll -dce -simple-loop-unswitch -div-rem-pairs -always-inline -coro-split -loop-load-elim -gvn-hoist -redundant-dbg-inst-elim -loop-deletion -loop-instsimplify -mergefunc -slp-vectorizer -coro-early -loop-simplifycfg -early-cse-memssa -barrier -name-anon-globals -mem2reg -adce -loop-vectorize -redundant-dbg-inst-elim -reassociate -inferattrs -called-value-propagation -coro-elide -loop-simplify -loop-guard-widening -strip-nondebug -constprop -prune-eh -dse -ipsccp -sroa -lower-constant-intrinsics -memcpyopt -insert-gcov-profiling -aggressive-instcombine -rewrite-statepoints-for-gc -simplifycfg -loop-distribute -loop-vectorize -adce -ipconstprop -slp-vectorizer -rpo-functionattrs -inferattrs -loop-sink -instcombine -slp-vectorizer -strip-dead-prototypes -loop-distribute -memcpyopt -consthoist -name-anon-globals -libcalls-shrinkwrap -speculative-execution -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/ghostscript,1.0169287793620125,10930.950301408768,opt -loop-versioning-licm -load-store-vectorizer -canonicalize-aliases -loop-simplify -loop-versioning-licm -ee-instrument -mldst-motion -loop-deletion -strip-dead-prototypes -loop-predication -scalarizer -reg2mem -bdce -mldst-motion -sccp -loop-guard-widening -ee-instrument -gvn-hoist -partially-inline-libcalls -name-anon-globals -scalarizer -mem2reg -insert-gcov-profiling -early-cse-memssa -loop-instsimplify -dce -gvn -coro-split -separate-const-offset-from-gep -coro-split -loop-unroll -loop-guard-widening -mldst-motion -break-crit-edges -loop-guard-widening -mergefunc -load-store-vectorizer -loop-deletion -sccp -sancov -gvn -strip-dead-prototypes -memcpyopt -loop-distribute -coro-early -aggressive-instcombine -loop-reroll -inferattrs -add-discriminators -callsite-splitting -inject-tli-mappings -coro-elide -loop-reroll -globalsplit -hotcoldsplit -pgo-memop-opt -mergefunc -irce -insert-gcov-profiling -constmerge -strip -simple-loop-unswitch -instnamer -globaldce -forceattrs -constprop -loop-predication -loop-load-elim -speculative-execution -loop-simplifycfg -instcombine -instsimplify -ipsccp -mergeicmps -called-value-propagation -ipconstprop -loop-vectorize -constmerge -dse -constmerge -strip-nondebug -licm -loop-unroll-and-jam -canonicalize-aliases -inferattrs -mldst-motion -functionattrs -separate-const-offset-from-gep -mergeicmps -loop-reroll -slsr -tailcallelim -load-store-vectorizer -lower-widenable-condition -simple-loop-unswitch -post-inline-ee-instrument -alignment-from-assumptions -ipsccp -always-inline -loop-simplifycfg -lower-widenable-condition -aggressive-instcombine -adce -slp-vectorizer -partially-inline-libcalls -loop-load-elim -dce -name-anon-globals -ee-instrument -globalsplit -simplifycfg -inject-tli-mappings -die -gvn-hoist -separate-const-offset-from-gep -coro-elide -partially-inline-libcalls -callsite-splitting -instsimplify -jump-threading -lower-expect -loop-vectorize -loop-fusion -coro-early -dse -lower-widenable-condition -coro-cleanup -instnamer -add-discriminators -strip-debug-declare -post-inline-ee-instrument -dse -lcssa -div-rem-pairs -nary-reassociate -insert-gcov-profiling -slsr -strip-debug-declare -reassociate -pgo-memop-opt -gvn -irce -pgo-memop-opt -separate-const-offset-from-gep -early-cse-memssa -elim-avail-extern -gvn-hoist -inferattrs -loop-unroll -inject-tli-mappings -always-inline -functionattrs -aggressive-instcombine -sccp -loop-instsimplify -deadargelim -break-crit-edges -aggressive-instcombine -dce -float2int -ee-instrument -loop-idiom -slp-vectorizer -sink -loop-idiom -dse -loop-versioning-licm -licm -loop-unroll -globaldce -flattencfg -globalsplit -strip-debug-declare -loop-load-elim -mem2reg -constprop -loop-guard-widening -bdce -alignment-from-assumptions -dce -loweratomic -loop-data-prefetch -loop-vectorize -div-rem-pairs -constmerge -loop-instsimplify -pgo-memop-opt -lower-constant-intrinsics -called-value-propagation -strip-debug-declare -mldst-motion -loop-load-elim -infer-address-spaces -attributor -strip-nondebug -pgo-memop-opt -instsimplify -lowerinvoke -strip-dead-prototypes -cross-dso-cfi -coro-elide -bdce -libcalls-shrinkwrap -adce -loop-distribute -loop-instsimplify -gvn-hoist -strip-nondebug -consthoist -instcombine -strip-dead-prototypes -loop-data-prefetch -rpo-functionattrs -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/gsm,1.094621513944223,10802.920687913895,opt -mem2reg -strip -loop-fusion -loop-reduce -loop-instsimplify -loop-versioning-licm -canonicalize-aliases -scalarizer -lower-expect -constprop -div-rem-pairs -instcombine -mergefunc -loop-unswitch -inferattrs -lowerinvoke -loweratomic -loop-versioning-licm -rewrite-statepoints-for-gc -add-discriminators -loop-deletion -strip-dead-prototypes -insert-gcov-profiling -newgvn -partially-inline-libcalls -nary-reassociate -loop-predication -lowerinvoke -irce -reassociate -argpromotion -lowerswitch -sroa -attributor -die -strip -called-value-propagation -strip-dead-prototypes -loop-guard-widening -dse -load-store-vectorizer -loop-reduce -pgo-memop-opt -loop-simplify -argpromotion -constmerge -float2int -alignment-from-assumptions -nary-reassociate -prune-eh -separate-const-offset-from-gep -bdce -separate-const-offset-from-gep -slp-vectorizer -mldst-motion -elim-avail-extern -ipconstprop -die -lower-widenable-condition -early-cse-memssa -lowerswitch -ipsccp -bdce -mergereturn -guard-widening -pgo-memop-opt -called-value-propagation -mergefunc -dse -instsimplify -sroa -correlated-propagation -instcombine -lowerinvoke -simple-loop-unswitch -libcalls-shrinkwrap -loop-sink -strip-nondebug -gvn-hoist -lowerswitch -instsimplify -flattencfg -mergeicmps -float2int -constprop -reassociate -gvn -infer-address-spaces -newgvn -loop-load-elim -dse -flattencfg -nary-reassociate -cross-dso-cfi -simplifycfg -load-store-vectorizer -deadargelim -loop-versioning -loop-deletion -dce -deadargelim -forceattrs -loop-data-prefetch -loop-instsimplify -forceattrs -loop-versioning -constmerge -insert-gcov-profiling -cross-dso-cfi -jump-threading -strip-nondebug -jump-threading -libcalls-shrinkwrap -loop-sink -loop-deletion -sroa -cross-dso-cfi -strip -div-rem-pairs -sancov -loop-unswitch -bdce -barrier -strip-nondebug -reassociate -aggressive-instcombine -mergefunc -slp-vectorizer -strip-nondebug -prune-eh -globaldce -coro-cleanup -rpo-functionattrs -simplifycfg -strip-dead-prototypes -constmerge -mergeicmps -separate-const-offset-from-gep -loop-data-prefetch -loop-interchange -irce -div-rem-pairs -loop-unswitch -speculative-execution -instcombine input.bc -o output.bc -benchmark://cBench-v1/ispell,1.0204081632653061,10805.658698558807,opt -deadargelim -name-anon-globals -gvn-hoist -mem2reg -bdce -alignment-from-assumptions -prune-eh -redundant-dbg-inst-elim -dce -attributor -jump-threading -elim-avail-extern -die -ipconstprop -early-cse-memssa -guard-widening -scalarizer -lower-expect -instnamer -redundant-dbg-inst-elim -loop-reroll -pgo-memop-opt -div-rem-pairs -libcalls-shrinkwrap -adce -loop-simplifycfg -loop-instsimplify -libcalls-shrinkwrap -float2int -loop-reroll -globaldce -lcssa -ipconstprop -loop-simplify -attributor -loop-instsimplify -licm -barrier -dse -loop-instsimplify -libcalls-shrinkwrap -instcombine -partially-inline-libcalls -always-inline -loop-unroll-and-jam -globalsplit -loop-unroll -functionattrs -mem2reg -inject-tli-mappings -add-discriminators -licm -loop-fusion -globalopt -simplifycfg -newgvn -inferattrs -rewrite-statepoints-for-gc -die -mergereturn -loop-predication -strip -simplifycfg -gvn -inject-tli-mappings -loop-sink -loop-unroll-and-jam -loop-reroll -redundant-dbg-inst-elim -loop-idiom -inject-tli-mappings -post-inline-ee-instrument -called-value-propagation -loop-guard-widening -slsr -coro-split -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.0373562327556811,10813.031274080276,opt -lower-guard-intrinsic -ipsccp -float2int -lower-constant-intrinsics -early-cse-memssa -mem2reg -loop-idiom -separate-const-offset-from-gep -lower-guard-intrinsic -loop-instsimplify -post-inline-ee-instrument -break-crit-edges -hotcoldsplit -cross-dso-cfi -post-inline-ee-instrument -die -strip-dead-prototypes -loop-deletion -post-inline-ee-instrument -early-cse-memssa -add-discriminators -loop-idiom -redundant-dbg-inst-elim -flattencfg -always-inline -strip-dead-prototypes -consthoist -lower-expect -correlated-propagation -inferattrs -coro-elide -flattencfg -rpo-functionattrs -strip-debug-declare -functionattrs -slp-vectorizer -rpo-functionattrs -guard-widening -mem2reg -forceattrs -loop-instsimplify -licm -called-value-propagation -mergereturn -strip-debug-declare -flattencfg -sink -separate-const-offset-from-gep -memcpyopt -lower-guard-intrinsic -instcombine -functionattrs -elim-avail-extern -always-inline -newgvn -mergefunc -early-cse-memssa -consthoist -sancov -redundant-dbg-inst-elim -loop-sink -loop-reroll -scalarizer -attributor -loop-interchange -sancov -loop-fusion -bdce -loop-vectorize -loweratomic -div-rem-pairs -partially-inline-libcalls -slsr -coro-cleanup -separate-const-offset-from-gep -dse -loop-unroll-and-jam -loweratomic -deadargelim -globalsplit -loop-versioning -constmerge -ipconstprop -loop-vectorize -infer-address-spaces -early-cse-memssa -ee-instrument -attributor -deadargelim -coro-split -rpo-functionattrs -name-anon-globals -loop-reroll -always-inline -mergereturn -rewrite-statepoints-for-gc -loop-versioning -load-store-vectorizer -canonicalize-aliases -coro-split -constmerge -always-inline -cross-dso-cfi -hotcoldsplit -instcombine -mem2reg -loop-predication -globalsplit -lower-guard-intrinsic -partial-inliner -indvars -ipsccp -simplifycfg -attributor -ipsccp -name-anon-globals -forceattrs -newgvn -loop-vectorize -memcpyopt -speculative-execution -insert-gcov-profiling -mergeicmps -slp-vectorizer -insert-gcov-profiling -mem2reg -loop-idiom -gvn-hoist -break-crit-edges -break-crit-edges -lower-matrix-intrinsics -attributor -rewrite-statepoints-for-gc -mergefunc -speculative-execution -instcombine -cross-dso-cfi -pgo-memop-opt -canonicalize-aliases -speculative-execution -lowerinvoke -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.040020605943527,10811.881211042404,opt -gvn-hoist -loop-versioning -forceattrs -loop-interchange -alignment-from-assumptions -redundant-dbg-inst-elim -lower-constant-intrinsics -loop-fusion -rewrite-statepoints-for-gc -simplifycfg -globalopt -coro-elide -inject-tli-mappings -load-store-vectorizer -rpo-functionattrs -hotcoldsplit -jump-threading -early-cse-memssa -cross-dso-cfi -break-crit-edges -globalsplit -loop-distribute -alignment-from-assumptions -reg2mem -sccp -prune-eh -deadargelim -strip-nondebug -guard-widening -separate-const-offset-from-gep -reg2mem -called-value-propagation -bdce -loop-vectorize -dse -sroa -elim-avail-extern -globalopt -loweratomic -aggressive-instcombine -break-crit-edges -canonicalize-aliases -early-cse-memssa -lower-matrix-intrinsics -forceattrs -insert-gcov-profiling -insert-gcov-profiling -pgo-memop-opt -strip -div-rem-pairs -jump-threading -strip-nondebug -loop-load-elim -strip-debug-declare -lower-matrix-intrinsics -nary-reassociate -inferattrs -coro-early -infer-address-spaces -canonicalize-aliases -indvars -pgo-memop-opt -loop-sink -post-inline-ee-instrument -inferattrs -bdce -loop-simplify -licm -tailcallelim -licm -inferattrs -instcombine -loop-interchange -rewrite-statepoints-for-gc -licm -simplifycfg -loop-predication -libcalls-shrinkwrap -flattencfg -ee-instrument -loop-instsimplify -elim-avail-extern -globalopt -newgvn -div-rem-pairs -strip -globalopt -ee-instrument -ipconstprop -add-discriminators -div-rem-pairs -cross-dso-cfi -coro-early -canonicalize-aliases -loop-load-elim -instcombine -scalarizer -flattencfg -sroa -loop-reroll -constprop -always-inline -guard-widening -instsimplify -separate-const-offset-from-gep -coro-elide -inferattrs -loop-vectorize -aggressive-instcombine -sroa -gvn-hoist -speculative-execution -newgvn -lowerinvoke -called-value-propagation -memcpyopt -gvn-hoist -constprop -globalsplit -strip-dead-prototypes -adce -lower-guard-intrinsic -loop-sink -lcssa -inferattrs -instcombine input.bc -o output.bc -benchmark://cBench-v1/lame,1.0565930312001823,10812.291928768158,opt -inferattrs -simple-loop-unswitch -flattencfg -alignment-from-assumptions -callsite-splitting -sccp -dce -coro-elide -libcalls-shrinkwrap -rewrite-statepoints-for-gc -globalsplit -mergereturn -load-store-vectorizer -loop-simplifycfg -rewrite-statepoints-for-gc -loop-interchange -pgo-memop-opt -early-cse-memssa -lowerinvoke -loop-simplifycfg -called-value-propagation -coro-early -bdce -inject-tli-mappings -barrier -guard-widening -mergefunc -slsr -irce -newgvn -consthoist -mem2reg -loop-vectorize -reassociate -float2int -dse -lower-matrix-intrinsics -tailcallelim -slsr -instcombine -float2int -loweratomic -alignment-from-assumptions -nary-reassociate -indvars -rewrite-statepoints-for-gc -coro-early -loop-interchange -always-inline -memcpyopt -loop-predication -globalsplit -slsr -instnamer -bdce -jump-threading -scalarizer -mergefunc -callsite-splitting -reassociate -newgvn -strip -barrier -deadargelim -loop-load-elim -reg2mem -die -gvn-hoist -sroa -loop-interchange -alignment-from-assumptions -forceattrs -mldst-motion -constmerge -newgvn -alignment-from-assumptions -strip-nondebug -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/patricia,1.0077864293659622,10801.536967754364,opt -indvars -loop-versioning -separate-const-offset-from-gep -rewrite-statepoints-for-gc -inject-tli-mappings -aggressive-instcombine -coro-early -licm -lower-expect -add-discriminators -slp-vectorizer -gvn -prune-eh -loop-unroll -libcalls-shrinkwrap -globalopt -newgvn -loop-distribute -dse -coro-elide -globalsplit -callsite-splitting -ipsccp -lowerswitch -lowerinvoke -aggressive-instcombine -name-anon-globals -speculative-execution -loop-vectorize -lcssa -memcpyopt -sancov -reassociate -lowerswitch -sink -canonicalize-aliases -loop-versioning-licm -lower-expect -sroa -sancov -libcalls-shrinkwrap -reassociate -memcpyopt -lcssa -speculative-execution -rpo-functionattrs -loop-instsimplify -div-rem-pairs -lower-constant-intrinsics -cross-dso-cfi -coro-cleanup -indvars -memcpyopt -loop-sink -bdce -loop-load-elim -loop-predication -loop-interchange -loop-deletion -indvars -simplifycfg -tailcallelim -forceattrs -loop-simplifycfg -infer-address-spaces -loop-idiom -globaldce -newgvn -barrier -sink -bdce -canonicalize-aliases -pgo-memop-opt -div-rem-pairs -mldst-motion -coro-split -slsr -redundant-dbg-inst-elim -inject-tli-mappings -loop-unroll -deadargelim -scalarizer -callsite-splitting -loop-predication -early-cse-memssa -loop-vectorize -tailcallelim -called-value-propagation -bdce -coro-split -instcombine -simple-loop-unswitch -globaldce -infer-address-spaces -slp-vectorizer -dce -ipconstprop -infer-address-spaces -functionattrs -gvn-hoist -mergeicmps -lower-constant-intrinsics -early-cse-memssa -mldst-motion -lower-guard-intrinsic -rewrite-statepoints-for-gc -sccp -loop-interchange -simple-loop-unswitch -argpromotion -break-crit-edges -pgo-memop-opt -nary-reassociate -rpo-functionattrs -indvars -functionattrs -loop-deletion -simplifycfg -strip -loop-data-prefetch -lcssa -callsite-splitting -strip -newgvn input.bc -o output.bc -benchmark://cBench-v1/qsort,1.1424148606811146,10801.787313699722,opt -memcpyopt -licm -sink -simple-loop-unswitch -reg2mem -die -loop-simplify -canonicalize-aliases -licm -die -loop-versioning-licm -slp-vectorizer -loop-load-elim -instnamer -inject-tli-mappings -lower-constant-intrinsics -called-value-propagation -irce -lowerswitch -slsr -irce -post-inline-ee-instrument -barrier -sink -loop-reroll -newgvn -inline -mldst-motion -coro-elide -ipsccp -loop-unswitch -constprop -lower-constant-intrinsics -bdce -rewrite-statepoints-for-gc -coro-elide -mem2reg -alignment-from-assumptions -coro-early -forceattrs -loop-fusion -coro-elide -inject-tli-mappings -loop-sink -adce -bdce -inject-tli-mappings -div-rem-pairs -loweratomic -break-crit-edges -argpromotion -instcombine -sancov -consthoist -bdce -coro-elide -memcpyopt -sink -loop-unroll-and-jam -loweratomic -lowerswitch -ipconstprop -lower-guard-intrinsic -post-inline-ee-instrument -early-cse-memssa -gvn-hoist -early-cse-memssa -simplifycfg -tailcallelim -die -mldst-motion -called-value-propagation -mergereturn -inject-tli-mappings -argpromotion -pgo-memop-opt -deadargelim -loop-unroll -pgo-memop-opt -lcssa -dse -nary-reassociate -globalsplit -mldst-motion -simplifycfg -functionattrs -gvn-hoist -newgvn input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.1073208125718668,10804.232735157013,opt -sroa -jump-threading -loop-reroll -indvars -newgvn -rewrite-statepoints-for-gc -instcombine -strip-dead-prototypes -mem2reg -libcalls-shrinkwrap -alignment-from-assumptions -inferattrs -instcombine -scalarizer -newgvn -argpromotion -coro-cleanup -simplifycfg -ee-instrument -lower-constant-intrinsics -strip-nondebug -rewrite-statepoints-for-gc -insert-gcov-profiling -instcombine input.bc -o output.bc -benchmark://cBench-v1/sha,1.535117056856187,10801.805096626282,opt -mergeicmps -loop-versioning-licm -loop-idiom -loop-fusion -barrier -newgvn -sink -separate-const-offset-from-gep -jump-threading -globalsplit -instcombine -rewrite-statepoints-for-gc -inject-tli-mappings -mldst-motion -ipconstprop -elim-avail-extern -sccp -guard-widening -mldst-motion -libcalls-shrinkwrap -strip-nondebug -speculative-execution -coro-elide -loop-predication -ipsccp -reassociate -loop-reroll -slsr -reassociate -early-cse-memssa -canonicalize-aliases -coro-cleanup -early-cse-memssa -partial-inliner -loop-reroll -cross-dso-cfi -loweratomic -dce -add-discriminators -instsimplify -strip-nondebug -rpo-functionattrs -redundant-dbg-inst-elim -globalopt -redundant-dbg-inst-elim -loweratomic -loop-deletion -infer-address-spaces -strip-dead-prototypes -coro-early -sancov -strip-dead-prototypes -irce -loop-versioning -canonicalize-aliases -globalsplit -loop-deletion -globalsplit -instnamer -load-store-vectorizer -mldst-motion -pgo-memop-opt -newgvn -loop-sink -redundant-dbg-inst-elim -infer-address-spaces -loop-unroll-and-jam -prune-eh -coro-split -lower-widenable-condition -bdce -mergereturn -consthoist -inferattrs -inject-tli-mappings -ipsccp -sink -indvars -loop-unroll-and-jam -reassociate -argpromotion -dce -strip-debug-declare -memcpyopt -consthoist -coro-early -add-discriminators -div-rem-pairs -memcpyopt -loop-rotate -instnamer -newgvn -pgo-memop-opt -loop-load-elim -adce -bdce -loop-guard-widening -cross-dso-cfi -mergereturn -ipsccp -lower-expect -barrier -loop-fusion -indvars -loop-predication -irce -loop-instsimplify -loop-predication -lower-matrix-intrinsics -pgo-memop-opt -lowerswitch -loop-fusion -gvn -loop-versioning-licm -instcombine -mldst-motion -loop-idiom -mem2reg -mergefunc -libcalls-shrinkwrap -scalarizer -coro-elide -lowerswitch -separate-const-offset-from-gep -argpromotion -lcssa -loop-reduce -float2int -mergefunc -alignment-from-assumptions -hotcoldsplit -name-anon-globals -ipconstprop -post-inline-ee-instrument -hotcoldsplit -lower-expect -always-inline -called-value-propagation -gvn-hoist -irce -loop-load-elim -lowerinvoke -name-anon-globals -sccp -lower-widenable-condition -strip-debug-declare -mem2reg -inferattrs -mergeicmps -separate-const-offset-from-gep -strip -bdce -argpromotion -ipsccp -always-inline -barrier -sccp -coro-early -inject-tli-mappings -break-crit-edges -canonicalize-aliases -tailcallelim -dse -elim-avail-extern -dce -insert-gcov-profiling -scalarizer -elim-avail-extern -loop-simplify -add-discriminators -loop-rotate -constprop -simple-loop-unswitch -mem2reg -reg2mem -indvars -lowerinvoke -coro-elide -load-store-vectorizer -lowerswitch -loop-simplifycfg -slp-vectorizer -instnamer -infer-address-spaces -lowerinvoke -loop-simplifycfg -dse -loop-sink -infer-address-spaces -dce -loop-simplify -dce -loop-unroll -loop-fusion -coro-cleanup -elim-avail-extern -simplifycfg -lower-matrix-intrinsics -jump-threading -constmerge -mergereturn -loop-deletion -loop-rotate -sink -mem2reg -loop-deletion -libcalls-shrinkwrap -lcssa -sccp -loop-sink -div-rem-pairs -instsimplify -mergefunc -loop-data-prefetch -strip-debug-declare -strip -simplifycfg -jump-threading -loop-predication -ee-instrument -tailcallelim -ipsccp -lower-guard-intrinsic -simplifycfg -rpo-functionattrs -speculative-execution -constprop -strip-nondebug -instcombine input.bc -o output.bc -benchmark://cBench-v1/stringsearch,1.0191256830601092,10801.714073419571,opt -lcssa -infer-address-spaces -dse -simplifycfg -tailcallelim -lower-matrix-intrinsics -inferattrs -infer-address-spaces -lower-constant-intrinsics -sroa -loop-deletion -consthoist -globaldce -lower-expect -correlated-propagation -gvn-hoist -memcpyopt -loop-instsimplify -scalarizer -globalsplit -argpromotion -coro-split -loop-vectorize -mergefunc -loop-idiom -forceattrs -partially-inline-libcalls -loop-load-elim -instsimplify -loop-unroll -tailcallelim -globaldce -loop-deletion -lowerswitch -reassociate -functionattrs -lower-matrix-intrinsics -irce -sink -aggressive-instcombine -adce -attributor -early-cse-memssa -flattencfg -callsite-splitting -deadargelim -speculative-execution -lower-expect -hotcoldsplit -strip-dead-prototypes -loop-instsimplify -attributor -globalsplit -instsimplify -lower-matrix-intrinsics -strip -infer-address-spaces -reassociate -licm -coro-split -infer-address-spaces -lower-matrix-intrinsics -coro-early -dce -lower-widenable-condition -attributor -reassociate -pgo-memop-opt -coro-cleanup -loop-versioning-licm -aggressive-instcombine -lowerinvoke -slp-vectorizer -globaldce -lower-expect -indvars -inferattrs -loop-unroll -memcpyopt -inferattrs -elim-avail-extern -rewrite-statepoints-for-gc -name-anon-globals -constprop -constmerge -break-crit-edges -newgvn -globalopt -add-discriminators -reassociate -slsr -licm -newgvn -separate-const-offset-from-gep -loop-data-prefetch -mergefunc -float2int -lower-matrix-intrinsics -memcpyopt -prune-eh -strip-nondebug -mldst-motion -loop-simplify -aggressive-instcombine -add-discriminators -callsite-splitting -dce -lower-expect -instsimplify -redundant-dbg-inst-elim -lower-constant-intrinsics -globalsplit -instcombine -canonicalize-aliases -called-value-propagation -loop-load-elim -dce -bdce -name-anon-globals -loweratomic -slp-vectorizer -simple-loop-unswitch -barrier -rpo-functionattrs -instcombine -mergefunc -libcalls-shrinkwrap -loop-versioning -loop-load-elim -lowerinvoke -early-cse-memssa -coro-cleanup -lower-guard-intrinsic -ipsccp -coro-cleanup -add-discriminators -globaldce -loop-simplify -sancov -break-crit-edges -lower-guard-intrinsic -aggressive-instcombine -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,1.003731343283582,10801.818507194519,opt -instcombine -scalarizer -loop-instsimplify -strip-debug-declare -pgo-memop-opt -separate-const-offset-from-gep -forceattrs -mergefunc -scalarizer -newgvn -post-inline-ee-instrument -forceattrs -die -newgvn -guard-widening -loop-distribute -libcalls-shrinkwrap -functionattrs -loop-rotate -ee-instrument -forceattrs -ipconstprop -sccp -aggressive-instcombine -loop-data-prefetch -ee-instrument -sroa -scalarizer -loop-instsimplify -called-value-propagation -partial-inliner -mergefunc -add-discriminators -cross-dso-cfi -sccp -nary-reassociate -loop-rotate -div-rem-pairs -loop-unswitch -libcalls-shrinkwrap -elim-avail-extern -newgvn -indvars -lower-constant-intrinsics -globaldce -indvars -loop-rotate -gvn -functionattrs -licm -loop-instsimplify -loop-unswitch -bdce -lower-widenable-condition -attributor -mldst-motion -slsr -instcombine -deadargelim -nary-reassociate -ee-instrument -die -elim-avail-extern -insert-gcov-profiling -add-discriminators -lower-guard-intrinsic -loop-fusion -slp-vectorizer -name-anon-globals -loop-unroll -jump-threading -loop-distribute -infer-address-spaces -dse -div-rem-pairs -constmerge -forceattrs -consthoist -lower-matrix-intrinsics -gvn-hoist -pgo-memop-opt -globalopt -always-inline -dce -lower-matrix-intrinsics -ee-instrument -strip-debug-declare -strip-dead-prototypes -canonicalize-aliases -die -mem2reg -indvars -separate-const-offset-from-gep -partial-inliner -globaldce -always-inline -tailcallelim -simplifycfg -gvn-hoist -constprop -sink -ipconstprop -ipsccp -instcombine input.bc -o output.bc -benchmark://cBench-v1/susan,0.9847709239825954,3603.660972595215,opt -break-crit-edges -lowerinvoke -reg2mem -bdce -loop-predication -newgvn -constprop -loop-interchange -load-store-vectorizer -globalopt -inferattrs -deadargelim -loop-versioning -inline -aggressive-instcombine -gvn -instcombine -strip-nondebug -loop-sink -partially-inline-libcalls -mergefunc -forceattrs -mldst-motion -irce -speculative-execution -strip-debug-declare -bdce -loop-unroll-and-jam -simple-loop-unswitch -inject-tli-mappings -slsr -loop-distribute -lower-guard-intrinsic -lower-widenable-condition -loop-reroll -coro-cleanup -sccp -gvn-hoist -functionattrs -adce -adce -inferattrs -instcombine -strip-debug-declare -scalarizer -sccp -newgvn -mergeicmps -mergeicmps -consthoist -dce -name-anon-globals -gvn -separate-const-offset-from-gep -simplifycfg -loop-instsimplify -name-anon-globals -mem2reg -redundant-dbg-inst-elim -rewrite-statepoints-for-gc -coro-elide -coro-cleanup -consthoist -early-cse-memssa -loop-idiom -constprop -adce -guard-widening -lower-guard-intrinsic -globaldce -gvn -globalsplit -float2int -mergeicmps -coro-elide -loop-guard-widening -functionattrs -constprop -slp-vectorizer -simple-loop-unswitch -loop-sink -mldst-motion -loop-predication -instcombine -callsite-splitting -loop-data-prefetch -sccp -alignment-from-assumptions -cross-dso-cfi -instnamer -inferattrs -mldst-motion -guard-widening -loop-simplify -loop-data-prefetch -die -constprop -strip -sccp -slsr -newgvn -sroa -loop-simplifycfg -loop-instsimplify -elim-avail-extern -mergefunc -loop-interchange -div-rem-pairs -loop-interchange -mergereturn -lower-guard-intrinsic -libcalls-shrinkwrap -nary-reassociate -lower-matrix-intrinsics -aggressive-instcombine -ee-instrument -globaldce -prune-eh -jump-threading -mergereturn -functionattrs -lower-matrix-intrinsics -correlated-propagation -separate-const-offset-from-gep -div-rem-pairs -hotcoldsplit -loop-data-prefetch -mergereturn -insert-gcov-profiling -die -instsimplify -lower-matrix-intrinsics -partially-inline-libcalls -prune-eh -canonicalize-aliases -strip-debug-declare -strip-dead-prototypes -always-inline -strip -jump-threading -coro-split -inferattrs -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.0406533185286009,10814.408720254898,opt -scalarizer -constmerge -die -loop-unswitch -lcssa -dce -libcalls-shrinkwrap -reassociate -simplifycfg -barrier -coro-cleanup -sink -rpo-functionattrs -loop-data-prefetch -lower-guard-intrinsic -sroa -div-rem-pairs -hotcoldsplit -scalarizer -loop-predication -dse -tailcallelim -licm -strip-debug-declare -jump-threading -irce -ipconstprop -loop-interchange -correlated-propagation -loop-versioning -constprop -correlated-propagation -add-discriminators -forceattrs -loop-fusion -loop-data-prefetch -correlated-propagation -lowerinvoke -always-inline -ee-instrument -loop-predication -add-discriminators -simple-loop-unswitch -forceattrs -consthoist -aggressive-instcombine -deadargelim -loop-distribute -mergeicmps -gvn -reassociate -gvn-hoist -nary-reassociate -separate-const-offset-from-gep -simplifycfg -name-anon-globals -scalarizer -instcombine -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.0394226626454115,10816.927260875702,opt -deadargelim -mem2reg -reg2mem -inferattrs -lowerinvoke -separate-const-offset-from-gep -strip-dead-prototypes -infer-address-spaces -nary-reassociate -loop-reroll -mldst-motion -slsr -loop-data-prefetch -loop-guard-widening -hotcoldsplit -loop-unroll -separate-const-offset-from-gep -tailcallelim -adce -strip-dead-prototypes -globalopt -barrier -mergefunc -instsimplify -loop-versioning -lcssa -simple-loop-unswitch -callsite-splitting -lcssa -mergereturn -newgvn -dce -separate-const-offset-from-gep -ipconstprop -loop-versioning -guard-widening -instnamer -coro-elide -coro-elide -alignment-from-assumptions -globalopt -newgvn -loop-unroll -mergereturn -strip-dead-prototypes -loop-simplify -partial-inliner -add-discriminators -loweratomic -mem2reg -simplifycfg -lower-widenable-condition -gvn-hoist -prune-eh -elim-avail-extern -strip-nondebug -lowerinvoke -loop-fusion -lower-guard-intrinsic -newgvn -partially-inline-libcalls -instcombine -separate-const-offset-from-gep -reassociate -lower-guard-intrinsic -div-rem-pairs -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.0419550173010381,10943.992988586426,opt -mem2reg -simplifycfg -strip-nondebug -add-discriminators -tailcallelim -tailcallelim -jump-threading -gvn-hoist -consthoist -strip -coro-cleanup -alignment-from-assumptions -callsite-splitting -hotcoldsplit -jump-threading -loop-data-prefetch -dce -bdce -mldst-motion -bdce -loop-guard-widening -guard-widening -nary-reassociate -barrier -loop-interchange -lower-matrix-intrinsics -loop-simplify -tailcallelim -separate-const-offset-from-gep -loweratomic -libcalls-shrinkwrap -flattencfg -rewrite-statepoints-for-gc -globalopt -inferattrs -tailcallelim -loweratomic -slp-vectorizer -name-anon-globals -gvn-hoist -sancov -loop-unroll-and-jam -add-discriminators -loop-idiom -rewrite-statepoints-for-gc -slp-vectorizer -loop-data-prefetch -loop-simplifycfg -argpromotion -loop-load-elim -constmerge -globaldce -loop-distribute -rpo-functionattrs -sancov -loop-load-elim -jump-threading -adce -lowerinvoke -cross-dso-cfi -reg2mem -strip-debug-declare -mem2reg -prune-eh -rewrite-statepoints-for-gc -constmerge -post-inline-ee-instrument -mem2reg -elim-avail-extern -mergefunc -slp-vectorizer -prune-eh -newgvn -jump-threading -loop-deletion -mldst-motion -functionattrs -coro-early -lower-constant-intrinsics -loop-simplify -speculative-execution -deadargelim -licm -coro-elide -lower-expect -memcpyopt -insert-gcov-profiling -gvn -loop-reroll -loweratomic -barrier -loop-predication -lower-matrix-intrinsics -barrier -loop-distribute -hotcoldsplit -lower-widenable-condition -ipsccp -break-crit-edges -reassociate -coro-early -dce -loop-sink -constmerge -loop-idiom -lowerinvoke -reassociate -called-value-propagation -newgvn -sroa -partial-inliner -instcombine -lcssa -flattencfg -lower-matrix-intrinsics -early-cse-memssa -called-value-propagation -infer-address-spaces -float2int -inject-tli-mappings -insert-gcov-profiling -loop-sink -break-crit-edges -nary-reassociate -scalarizer -libcalls-shrinkwrap -adce -prune-eh -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.0387964891909427,10998.024054765701,opt -simplifycfg -constmerge -loop-simplifycfg -loop-predication -prune-eh -attributor -reg2mem -memcpyopt -deadargelim -dce -partially-inline-libcalls -instsimplify -indvars -slsr -forceattrs -newgvn -constmerge -lower-constant-intrinsics -sccp -mem2reg -prune-eh -sancov -sccp -partially-inline-libcalls -rewrite-statepoints-for-gc -loweratomic -loop-reroll -ipconstprop -strip-dead-prototypes -functionattrs -loop-simplify -sancov -barrier -lower-widenable-condition -attributor -licm -instcombine -loop-instsimplify -mem2reg -loop-data-prefetch -newgvn -rewrite-statepoints-for-gc -aggressive-instcombine -lower-guard-intrinsic -called-value-propagation -constmerge -functionattrs -name-anon-globals -barrier -loop-instsimplify -loop-versioning-licm -newgvn -simplifycfg -slp-vectorizer -constprop -flattencfg -rpo-functionattrs -loweratomic -instsimplify -memcpyopt input.bc -o output.bc +benchmark://cbench-v1/adpcm,1.0083798882681567,10801.772290468216,opt -loop-distribute -strip-dead-prototypes -loop-unroll-and-jam -loop-distribute -constprop -called-value-propagation -infer-address-spaces -ee-instrument -hotcoldsplit -correlated-propagation -loop-unroll-and-jam -loop-distribute -loop-predication -sroa -infer-address-spaces -die -coro-elide -sancov -partially-inline-libcalls -memcpyopt -coro-early -mergeicmps -ipsccp -loop-predication -called-value-propagation -lowerinvoke -dse -globalsplit -irce -mergereturn -sroa -aggressive-instcombine -rewrite-statepoints-for-gc -coro-split -sancov -inline -instsimplify -sancov -infer-address-spaces -float2int -inject-tli-mappings -mldst-motion -speculative-execution -loop-unroll-and-jam -slsr -loop-unswitch -loweratomic -simplifycfg -dce -instcombine -barrier -div-rem-pairs -early-cse-memssa -loop-guard-widening -strip-nondebug -mergereturn -break-crit-edges -jump-threading -sroa -loweratomic -tailcallelim -nary-reassociate -div-rem-pairs -adce -instcombine -mergefunc -coro-cleanup -globaldce -instcombine -loop-versioning -gvn-hoist -lower-matrix-intrinsics -libcalls-shrinkwrap -globaldce -inline -loop-vectorize -jump-threading -guard-widening -mergeicmps -always-inline -inject-tli-mappings -separate-const-offset-from-gep -instnamer -mergeicmps -memcpyopt -mem2reg -sroa -separate-const-offset-from-gep -div-rem-pairs -lower-matrix-intrinsics -canonicalize-aliases -sancov -constmerge -loop-predication -cross-dso-cfi -simplifycfg -consthoist -barrier -bdce -reassociate -redundant-dbg-inst-elim -strip -instsimplify input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0154867256637168,10801.793578386307,opt -functionattrs -globaldce -constmerge -argpromotion -sink -ipconstprop -reassociate -gvn-hoist -loop-reduce -loop-fusion -loop-simplifycfg -loop-unroll -mem2reg -indvars -name-anon-globals -early-cse-memssa -globaldce -dse -aggressive-instcombine -lower-constant-intrinsics -argpromotion -called-value-propagation -simplifycfg -loop-unroll-and-jam -rewrite-statepoints-for-gc -simple-loop-unswitch -early-cse-memssa -sroa -reg2mem -loop-simplifycfg -gvn-hoist -coro-early -memcpyopt -reassociate -sccp -tailcallelim -forceattrs -callsite-splitting -early-cse-memssa -loop-unroll -mem2reg -scalarizer -instcombine -pgo-memop-opt -lower-expect -aggressive-instcombine -mergeicmps -nary-reassociate -globaldce -callsite-splitting -coro-cleanup -globalsplit -simplifycfg -strip-nondebug -strip-dead-prototypes -inject-tli-mappings -strip -post-inline-ee-instrument -coro-elide -tailcallelim -libcalls-shrinkwrap -consthoist -rpo-functionattrs -redundant-dbg-inst-elim -sccp -libcalls-shrinkwrap -loop-versioning -elim-avail-extern input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0880407124681934,10801.877015829086,opt -simplifycfg -globalopt -constmerge -consthoist -globalopt -loop-reroll -sroa -coro-early -rpo-functionattrs -mergereturn -lcssa -loop-simplifycfg -mergeicmps -slsr -add-discriminators -flattencfg -instnamer -strip-dead-prototypes -libcalls-shrinkwrap -callsite-splitting -libcalls-shrinkwrap -loop-vectorize -pgo-memop-opt -correlated-propagation -lower-guard-intrinsic -globalopt -hotcoldsplit -loop-fusion -barrier -newgvn -loop-unroll -guard-widening -nary-reassociate -lower-widenable-condition -inferattrs -insert-gcov-profiling -bdce -coro-early -strip -sccp -elim-avail-extern -loop-fusion -strip -name-anon-globals -attributor -hotcoldsplit -lowerinvoke -correlated-propagation -licm -loop-fusion -alignment-from-assumptions -strip-dead-prototypes -loop-vectorize -strip-nondebug -strip-dead-prototypes -float2int -jump-threading -reassociate -redundant-dbg-inst-elim -coro-elide -coro-early -die -instcombine -libcalls-shrinkwrap -slsr -coro-elide -loop-versioning-licm -sancov -forceattrs -gvn-hoist -irce -loop-deletion -hotcoldsplit -div-rem-pairs -strip-debug-declare -break-crit-edges -correlated-propagation -strip -loop-instsimplify -simplifycfg -lower-widenable-condition -prune-eh -newgvn -instnamer -argpromotion -loop-distribute -loop-instsimplify -loweratomic -loop-versioning -slp-vectorizer -called-value-propagation -sancov -mergefunc -globalopt -loop-data-prefetch -coro-elide -strip-nondebug -indvars -scalarizer -loop-guard-widening -adce -float2int -coro-elide -loop-unroll-and-jam -coro-cleanup -canonicalize-aliases -early-cse-memssa -loop-guard-widening -rpo-functionattrs -guard-widening -loop-simplify -hotcoldsplit -coro-split -float2int -bdce -coro-cleanup -die -licm -div-rem-pairs -add-discriminators -strip-nondebug -strip-debug-declare -reassociate -instcombine -lower-constant-intrinsics -strip-dead-prototypes -sccp -slsr -deadargelim -lcssa -globaldce -dse -name-anon-globals -instnamer -globalsplit -globaldce -redundant-dbg-inst-elim -consthoist -gvn-hoist -lower-guard-intrinsic -elim-avail-extern -instsimplify -canonicalize-aliases -memcpyopt -load-store-vectorizer -mergefunc -callsite-splitting -adce -adce -instcombine -functionattrs -lower-matrix-intrinsics -lower-guard-intrinsic -partial-inliner -rewrite-statepoints-for-gc -coro-split -callsite-splitting -guard-widening -inject-tli-mappings -loop-reroll -correlated-propagation -post-inline-ee-instrument -ipconstprop -jump-threading -slp-vectorizer -ee-instrument -loop-instsimplify -slsr -loop-instsimplify -sink -loweratomic -strip-debug-declare -mldst-motion -slp-vectorizer -globalopt -post-inline-ee-instrument -bdce -instcombine input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.209654741446649,10808.157907485962,opt -separate-const-offset-from-gep -barrier -lower-constant-intrinsics -loop-interchange -partially-inline-libcalls -bdce -constmerge -lcssa -loop-sink -globalopt -loop-simplifycfg -loop-deletion -loop-sink -lower-matrix-intrinsics -loop-fusion -strip-nondebug -loop-data-prefetch -licm -constmerge -globalopt -bdce -alignment-from-assumptions -sccp -forceattrs -functionattrs -loop-simplify -sroa -globalsplit -licm -newgvn -lowerinvoke -loop-reroll -ipsccp -globalsplit -speculative-execution -loweratomic -break-crit-edges -adce -loop-load-elim -tailcallelim -barrier -loop-vectorize -loop-guard-widening -callsite-splitting -gvn-hoist -simple-loop-unswitch -consthoist -simplifycfg -insert-gcov-profiling -nary-reassociate -flattencfg -prune-eh -constmerge -guard-widening -constmerge -memcpyopt -memcpyopt -globaldce -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,10802.23005247116,opt -loop-sink -jump-threading -prune-eh -loop-instsimplify -reg2mem -nary-reassociate -break-crit-edges -lower-constant-intrinsics -loop-fusion -consthoist -infer-address-spaces -loop-guard-widening -scalarizer -callsite-splitting -lower-constant-intrinsics -alignment-from-assumptions -load-store-vectorizer -coro-cleanup -correlated-propagation -consthoist -insert-gcov-profiling -inject-tli-mappings -adce -loweratomic -loop-data-prefetch -mergeicmps -constprop -callsite-splitting -deadargelim -float2int -coro-cleanup -loop-interchange -functionattrs -float2int -loop-reroll -loop-versioning -indvars -redundant-dbg-inst-elim -separate-const-offset-from-gep -early-cse-memssa -libcalls-shrinkwrap -inferattrs -rewrite-statepoints-for-gc -reassociate -bdce -loop-versioning-licm -nary-reassociate -break-crit-edges -lower-widenable-condition -loop-unswitch -gvn-hoist -memcpyopt -scalarizer -loop-data-prefetch -sccp -alignment-from-assumptions -newgvn -lowerinvoke -die -lower-widenable-condition -irce -mergeicmps -coro-cleanup -alignment-from-assumptions -break-crit-edges -instcombine -mem2reg -called-value-propagation -reassociate -mergefunc -constmerge -loop-versioning-licm -indvars -gvn -insert-gcov-profiling -barrier -globalopt -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.9948979591836737,10801.72380065918,opt -loop-deletion -mem2reg -load-store-vectorizer -loop-unroll -loop-distribute -loop-fusion -loop-reroll -callsite-splitting -flattencfg -prune-eh -loop-load-elim -flattencfg -newgvn -loop-idiom -inferattrs -licm -sink -loop-vectorize -post-inline-ee-instrument -flattencfg -add-discriminators -bdce -lower-constant-intrinsics -loop-reduce -post-inline-ee-instrument -sancov -lower-widenable-condition -slsr -div-rem-pairs -lowerswitch -dce -indvars -loop-simplifycfg -lower-guard-intrinsic -inferattrs -name-anon-globals -jump-threading -lowerinvoke -loop-simplify -loop-simplify -inject-tli-mappings -callsite-splitting -loop-unroll -dce -simple-loop-unswitch -div-rem-pairs -always-inline -coro-split -loop-load-elim -gvn-hoist -redundant-dbg-inst-elim -loop-deletion -loop-instsimplify -mergefunc -slp-vectorizer -coro-early -loop-simplifycfg -early-cse-memssa -barrier -name-anon-globals -mem2reg -adce -loop-vectorize -redundant-dbg-inst-elim -reassociate -inferattrs -called-value-propagation -coro-elide -loop-simplify -loop-guard-widening -strip-nondebug -constprop -prune-eh -dse -ipsccp -sroa -lower-constant-intrinsics -memcpyopt -insert-gcov-profiling -aggressive-instcombine -rewrite-statepoints-for-gc -simplifycfg -loop-distribute -loop-vectorize -adce -ipconstprop -slp-vectorizer -rpo-functionattrs -inferattrs -loop-sink -instcombine -slp-vectorizer -strip-dead-prototypes -loop-distribute -memcpyopt -consthoist -name-anon-globals -libcalls-shrinkwrap -speculative-execution -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/ghostscript,1.0169287793620125,10930.950301408768,opt -loop-versioning-licm -load-store-vectorizer -canonicalize-aliases -loop-simplify -loop-versioning-licm -ee-instrument -mldst-motion -loop-deletion -strip-dead-prototypes -loop-predication -scalarizer -reg2mem -bdce -mldst-motion -sccp -loop-guard-widening -ee-instrument -gvn-hoist -partially-inline-libcalls -name-anon-globals -scalarizer -mem2reg -insert-gcov-profiling -early-cse-memssa -loop-instsimplify -dce -gvn -coro-split -separate-const-offset-from-gep -coro-split -loop-unroll -loop-guard-widening -mldst-motion -break-crit-edges -loop-guard-widening -mergefunc -load-store-vectorizer -loop-deletion -sccp -sancov -gvn -strip-dead-prototypes -memcpyopt -loop-distribute -coro-early -aggressive-instcombine -loop-reroll -inferattrs -add-discriminators -callsite-splitting -inject-tli-mappings -coro-elide -loop-reroll -globalsplit -hotcoldsplit -pgo-memop-opt -mergefunc -irce -insert-gcov-profiling -constmerge -strip -simple-loop-unswitch -instnamer -globaldce -forceattrs -constprop -loop-predication -loop-load-elim -speculative-execution -loop-simplifycfg -instcombine -instsimplify -ipsccp -mergeicmps -called-value-propagation -ipconstprop -loop-vectorize -constmerge -dse -constmerge -strip-nondebug -licm -loop-unroll-and-jam -canonicalize-aliases -inferattrs -mldst-motion -functionattrs -separate-const-offset-from-gep -mergeicmps -loop-reroll -slsr -tailcallelim -load-store-vectorizer -lower-widenable-condition -simple-loop-unswitch -post-inline-ee-instrument -alignment-from-assumptions -ipsccp -always-inline -loop-simplifycfg -lower-widenable-condition -aggressive-instcombine -adce -slp-vectorizer -partially-inline-libcalls -loop-load-elim -dce -name-anon-globals -ee-instrument -globalsplit -simplifycfg -inject-tli-mappings -die -gvn-hoist -separate-const-offset-from-gep -coro-elide -partially-inline-libcalls -callsite-splitting -instsimplify -jump-threading -lower-expect -loop-vectorize -loop-fusion -coro-early -dse -lower-widenable-condition -coro-cleanup -instnamer -add-discriminators -strip-debug-declare -post-inline-ee-instrument -dse -lcssa -div-rem-pairs -nary-reassociate -insert-gcov-profiling -slsr -strip-debug-declare -reassociate -pgo-memop-opt -gvn -irce -pgo-memop-opt -separate-const-offset-from-gep -early-cse-memssa -elim-avail-extern -gvn-hoist -inferattrs -loop-unroll -inject-tli-mappings -always-inline -functionattrs -aggressive-instcombine -sccp -loop-instsimplify -deadargelim -break-crit-edges -aggressive-instcombine -dce -float2int -ee-instrument -loop-idiom -slp-vectorizer -sink -loop-idiom -dse -loop-versioning-licm -licm -loop-unroll -globaldce -flattencfg -globalsplit -strip-debug-declare -loop-load-elim -mem2reg -constprop -loop-guard-widening -bdce -alignment-from-assumptions -dce -loweratomic -loop-data-prefetch -loop-vectorize -div-rem-pairs -constmerge -loop-instsimplify -pgo-memop-opt -lower-constant-intrinsics -called-value-propagation -strip-debug-declare -mldst-motion -loop-load-elim -infer-address-spaces -attributor -strip-nondebug -pgo-memop-opt -instsimplify -lowerinvoke -strip-dead-prototypes -cross-dso-cfi -coro-elide -bdce -libcalls-shrinkwrap -adce -loop-distribute -loop-instsimplify -gvn-hoist -strip-nondebug -consthoist -instcombine -strip-dead-prototypes -loop-data-prefetch -rpo-functionattrs -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/gsm,1.094621513944223,10802.920687913895,opt -mem2reg -strip -loop-fusion -loop-reduce -loop-instsimplify -loop-versioning-licm -canonicalize-aliases -scalarizer -lower-expect -constprop -div-rem-pairs -instcombine -mergefunc -loop-unswitch -inferattrs -lowerinvoke -loweratomic -loop-versioning-licm -rewrite-statepoints-for-gc -add-discriminators -loop-deletion -strip-dead-prototypes -insert-gcov-profiling -newgvn -partially-inline-libcalls -nary-reassociate -loop-predication -lowerinvoke -irce -reassociate -argpromotion -lowerswitch -sroa -attributor -die -strip -called-value-propagation -strip-dead-prototypes -loop-guard-widening -dse -load-store-vectorizer -loop-reduce -pgo-memop-opt -loop-simplify -argpromotion -constmerge -float2int -alignment-from-assumptions -nary-reassociate -prune-eh -separate-const-offset-from-gep -bdce -separate-const-offset-from-gep -slp-vectorizer -mldst-motion -elim-avail-extern -ipconstprop -die -lower-widenable-condition -early-cse-memssa -lowerswitch -ipsccp -bdce -mergereturn -guard-widening -pgo-memop-opt -called-value-propagation -mergefunc -dse -instsimplify -sroa -correlated-propagation -instcombine -lowerinvoke -simple-loop-unswitch -libcalls-shrinkwrap -loop-sink -strip-nondebug -gvn-hoist -lowerswitch -instsimplify -flattencfg -mergeicmps -float2int -constprop -reassociate -gvn -infer-address-spaces -newgvn -loop-load-elim -dse -flattencfg -nary-reassociate -cross-dso-cfi -simplifycfg -load-store-vectorizer -deadargelim -loop-versioning -loop-deletion -dce -deadargelim -forceattrs -loop-data-prefetch -loop-instsimplify -forceattrs -loop-versioning -constmerge -insert-gcov-profiling -cross-dso-cfi -jump-threading -strip-nondebug -jump-threading -libcalls-shrinkwrap -loop-sink -loop-deletion -sroa -cross-dso-cfi -strip -div-rem-pairs -sancov -loop-unswitch -bdce -barrier -strip-nondebug -reassociate -aggressive-instcombine -mergefunc -slp-vectorizer -strip-nondebug -prune-eh -globaldce -coro-cleanup -rpo-functionattrs -simplifycfg -strip-dead-prototypes -constmerge -mergeicmps -separate-const-offset-from-gep -loop-data-prefetch -loop-interchange -irce -div-rem-pairs -loop-unswitch -speculative-execution -instcombine input.bc -o output.bc +benchmark://cbench-v1/ispell,1.0204081632653061,10805.658698558807,opt -deadargelim -name-anon-globals -gvn-hoist -mem2reg -bdce -alignment-from-assumptions -prune-eh -redundant-dbg-inst-elim -dce -attributor -jump-threading -elim-avail-extern -die -ipconstprop -early-cse-memssa -guard-widening -scalarizer -lower-expect -instnamer -redundant-dbg-inst-elim -loop-reroll -pgo-memop-opt -div-rem-pairs -libcalls-shrinkwrap -adce -loop-simplifycfg -loop-instsimplify -libcalls-shrinkwrap -float2int -loop-reroll -globaldce -lcssa -ipconstprop -loop-simplify -attributor -loop-instsimplify -licm -barrier -dse -loop-instsimplify -libcalls-shrinkwrap -instcombine -partially-inline-libcalls -always-inline -loop-unroll-and-jam -globalsplit -loop-unroll -functionattrs -mem2reg -inject-tli-mappings -add-discriminators -licm -loop-fusion -globalopt -simplifycfg -newgvn -inferattrs -rewrite-statepoints-for-gc -die -mergereturn -loop-predication -strip -simplifycfg -gvn -inject-tli-mappings -loop-sink -loop-unroll-and-jam -loop-reroll -redundant-dbg-inst-elim -loop-idiom -inject-tli-mappings -post-inline-ee-instrument -called-value-propagation -loop-guard-widening -slsr -coro-split -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0373562327556811,10813.031274080276,opt -lower-guard-intrinsic -ipsccp -float2int -lower-constant-intrinsics -early-cse-memssa -mem2reg -loop-idiom -separate-const-offset-from-gep -lower-guard-intrinsic -loop-instsimplify -post-inline-ee-instrument -break-crit-edges -hotcoldsplit -cross-dso-cfi -post-inline-ee-instrument -die -strip-dead-prototypes -loop-deletion -post-inline-ee-instrument -early-cse-memssa -add-discriminators -loop-idiom -redundant-dbg-inst-elim -flattencfg -always-inline -strip-dead-prototypes -consthoist -lower-expect -correlated-propagation -inferattrs -coro-elide -flattencfg -rpo-functionattrs -strip-debug-declare -functionattrs -slp-vectorizer -rpo-functionattrs -guard-widening -mem2reg -forceattrs -loop-instsimplify -licm -called-value-propagation -mergereturn -strip-debug-declare -flattencfg -sink -separate-const-offset-from-gep -memcpyopt -lower-guard-intrinsic -instcombine -functionattrs -elim-avail-extern -always-inline -newgvn -mergefunc -early-cse-memssa -consthoist -sancov -redundant-dbg-inst-elim -loop-sink -loop-reroll -scalarizer -attributor -loop-interchange -sancov -loop-fusion -bdce -loop-vectorize -loweratomic -div-rem-pairs -partially-inline-libcalls -slsr -coro-cleanup -separate-const-offset-from-gep -dse -loop-unroll-and-jam -loweratomic -deadargelim -globalsplit -loop-versioning -constmerge -ipconstprop -loop-vectorize -infer-address-spaces -early-cse-memssa -ee-instrument -attributor -deadargelim -coro-split -rpo-functionattrs -name-anon-globals -loop-reroll -always-inline -mergereturn -rewrite-statepoints-for-gc -loop-versioning -load-store-vectorizer -canonicalize-aliases -coro-split -constmerge -always-inline -cross-dso-cfi -hotcoldsplit -instcombine -mem2reg -loop-predication -globalsplit -lower-guard-intrinsic -partial-inliner -indvars -ipsccp -simplifycfg -attributor -ipsccp -name-anon-globals -forceattrs -newgvn -loop-vectorize -memcpyopt -speculative-execution -insert-gcov-profiling -mergeicmps -slp-vectorizer -insert-gcov-profiling -mem2reg -loop-idiom -gvn-hoist -break-crit-edges -break-crit-edges -lower-matrix-intrinsics -attributor -rewrite-statepoints-for-gc -mergefunc -speculative-execution -instcombine -cross-dso-cfi -pgo-memop-opt -canonicalize-aliases -speculative-execution -lowerinvoke -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.040020605943527,10811.881211042404,opt -gvn-hoist -loop-versioning -forceattrs -loop-interchange -alignment-from-assumptions -redundant-dbg-inst-elim -lower-constant-intrinsics -loop-fusion -rewrite-statepoints-for-gc -simplifycfg -globalopt -coro-elide -inject-tli-mappings -load-store-vectorizer -rpo-functionattrs -hotcoldsplit -jump-threading -early-cse-memssa -cross-dso-cfi -break-crit-edges -globalsplit -loop-distribute -alignment-from-assumptions -reg2mem -sccp -prune-eh -deadargelim -strip-nondebug -guard-widening -separate-const-offset-from-gep -reg2mem -called-value-propagation -bdce -loop-vectorize -dse -sroa -elim-avail-extern -globalopt -loweratomic -aggressive-instcombine -break-crit-edges -canonicalize-aliases -early-cse-memssa -lower-matrix-intrinsics -forceattrs -insert-gcov-profiling -insert-gcov-profiling -pgo-memop-opt -strip -div-rem-pairs -jump-threading -strip-nondebug -loop-load-elim -strip-debug-declare -lower-matrix-intrinsics -nary-reassociate -inferattrs -coro-early -infer-address-spaces -canonicalize-aliases -indvars -pgo-memop-opt -loop-sink -post-inline-ee-instrument -inferattrs -bdce -loop-simplify -licm -tailcallelim -licm -inferattrs -instcombine -loop-interchange -rewrite-statepoints-for-gc -licm -simplifycfg -loop-predication -libcalls-shrinkwrap -flattencfg -ee-instrument -loop-instsimplify -elim-avail-extern -globalopt -newgvn -div-rem-pairs -strip -globalopt -ee-instrument -ipconstprop -add-discriminators -div-rem-pairs -cross-dso-cfi -coro-early -canonicalize-aliases -loop-load-elim -instcombine -scalarizer -flattencfg -sroa -loop-reroll -constprop -always-inline -guard-widening -instsimplify -separate-const-offset-from-gep -coro-elide -inferattrs -loop-vectorize -aggressive-instcombine -sroa -gvn-hoist -speculative-execution -newgvn -lowerinvoke -called-value-propagation -memcpyopt -gvn-hoist -constprop -globalsplit -strip-dead-prototypes -adce -lower-guard-intrinsic -loop-sink -lcssa -inferattrs -instcombine input.bc -o output.bc +benchmark://cbench-v1/lame,1.0565930312001823,10812.291928768158,opt -inferattrs -simple-loop-unswitch -flattencfg -alignment-from-assumptions -callsite-splitting -sccp -dce -coro-elide -libcalls-shrinkwrap -rewrite-statepoints-for-gc -globalsplit -mergereturn -load-store-vectorizer -loop-simplifycfg -rewrite-statepoints-for-gc -loop-interchange -pgo-memop-opt -early-cse-memssa -lowerinvoke -loop-simplifycfg -called-value-propagation -coro-early -bdce -inject-tli-mappings -barrier -guard-widening -mergefunc -slsr -irce -newgvn -consthoist -mem2reg -loop-vectorize -reassociate -float2int -dse -lower-matrix-intrinsics -tailcallelim -slsr -instcombine -float2int -loweratomic -alignment-from-assumptions -nary-reassociate -indvars -rewrite-statepoints-for-gc -coro-early -loop-interchange -always-inline -memcpyopt -loop-predication -globalsplit -slsr -instnamer -bdce -jump-threading -scalarizer -mergefunc -callsite-splitting -reassociate -newgvn -strip -barrier -deadargelim -loop-load-elim -reg2mem -die -gvn-hoist -sroa -loop-interchange -alignment-from-assumptions -forceattrs -mldst-motion -constmerge -newgvn -alignment-from-assumptions -strip-nondebug -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/patricia,1.0077864293659622,10801.536967754364,opt -indvars -loop-versioning -separate-const-offset-from-gep -rewrite-statepoints-for-gc -inject-tli-mappings -aggressive-instcombine -coro-early -licm -lower-expect -add-discriminators -slp-vectorizer -gvn -prune-eh -loop-unroll -libcalls-shrinkwrap -globalopt -newgvn -loop-distribute -dse -coro-elide -globalsplit -callsite-splitting -ipsccp -lowerswitch -lowerinvoke -aggressive-instcombine -name-anon-globals -speculative-execution -loop-vectorize -lcssa -memcpyopt -sancov -reassociate -lowerswitch -sink -canonicalize-aliases -loop-versioning-licm -lower-expect -sroa -sancov -libcalls-shrinkwrap -reassociate -memcpyopt -lcssa -speculative-execution -rpo-functionattrs -loop-instsimplify -div-rem-pairs -lower-constant-intrinsics -cross-dso-cfi -coro-cleanup -indvars -memcpyopt -loop-sink -bdce -loop-load-elim -loop-predication -loop-interchange -loop-deletion -indvars -simplifycfg -tailcallelim -forceattrs -loop-simplifycfg -infer-address-spaces -loop-idiom -globaldce -newgvn -barrier -sink -bdce -canonicalize-aliases -pgo-memop-opt -div-rem-pairs -mldst-motion -coro-split -slsr -redundant-dbg-inst-elim -inject-tli-mappings -loop-unroll -deadargelim -scalarizer -callsite-splitting -loop-predication -early-cse-memssa -loop-vectorize -tailcallelim -called-value-propagation -bdce -coro-split -instcombine -simple-loop-unswitch -globaldce -infer-address-spaces -slp-vectorizer -dce -ipconstprop -infer-address-spaces -functionattrs -gvn-hoist -mergeicmps -lower-constant-intrinsics -early-cse-memssa -mldst-motion -lower-guard-intrinsic -rewrite-statepoints-for-gc -sccp -loop-interchange -simple-loop-unswitch -argpromotion -break-crit-edges -pgo-memop-opt -nary-reassociate -rpo-functionattrs -indvars -functionattrs -loop-deletion -simplifycfg -strip -loop-data-prefetch -lcssa -callsite-splitting -strip -newgvn input.bc -o output.bc +benchmark://cbench-v1/qsort,1.1424148606811146,10801.787313699722,opt -memcpyopt -licm -sink -simple-loop-unswitch -reg2mem -die -loop-simplify -canonicalize-aliases -licm -die -loop-versioning-licm -slp-vectorizer -loop-load-elim -instnamer -inject-tli-mappings -lower-constant-intrinsics -called-value-propagation -irce -lowerswitch -slsr -irce -post-inline-ee-instrument -barrier -sink -loop-reroll -newgvn -inline -mldst-motion -coro-elide -ipsccp -loop-unswitch -constprop -lower-constant-intrinsics -bdce -rewrite-statepoints-for-gc -coro-elide -mem2reg -alignment-from-assumptions -coro-early -forceattrs -loop-fusion -coro-elide -inject-tli-mappings -loop-sink -adce -bdce -inject-tli-mappings -div-rem-pairs -loweratomic -break-crit-edges -argpromotion -instcombine -sancov -consthoist -bdce -coro-elide -memcpyopt -sink -loop-unroll-and-jam -loweratomic -lowerswitch -ipconstprop -lower-guard-intrinsic -post-inline-ee-instrument -early-cse-memssa -gvn-hoist -early-cse-memssa -simplifycfg -tailcallelim -die -mldst-motion -called-value-propagation -mergereturn -inject-tli-mappings -argpromotion -pgo-memop-opt -deadargelim -loop-unroll -pgo-memop-opt -lcssa -dse -nary-reassociate -globalsplit -mldst-motion -simplifycfg -functionattrs -gvn-hoist -newgvn input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1073208125718668,10804.232735157013,opt -sroa -jump-threading -loop-reroll -indvars -newgvn -rewrite-statepoints-for-gc -instcombine -strip-dead-prototypes -mem2reg -libcalls-shrinkwrap -alignment-from-assumptions -inferattrs -instcombine -scalarizer -newgvn -argpromotion -coro-cleanup -simplifycfg -ee-instrument -lower-constant-intrinsics -strip-nondebug -rewrite-statepoints-for-gc -insert-gcov-profiling -instcombine input.bc -o output.bc +benchmark://cbench-v1/sha,1.535117056856187,10801.805096626282,opt -mergeicmps -loop-versioning-licm -loop-idiom -loop-fusion -barrier -newgvn -sink -separate-const-offset-from-gep -jump-threading -globalsplit -instcombine -rewrite-statepoints-for-gc -inject-tli-mappings -mldst-motion -ipconstprop -elim-avail-extern -sccp -guard-widening -mldst-motion -libcalls-shrinkwrap -strip-nondebug -speculative-execution -coro-elide -loop-predication -ipsccp -reassociate -loop-reroll -slsr -reassociate -early-cse-memssa -canonicalize-aliases -coro-cleanup -early-cse-memssa -partial-inliner -loop-reroll -cross-dso-cfi -loweratomic -dce -add-discriminators -instsimplify -strip-nondebug -rpo-functionattrs -redundant-dbg-inst-elim -globalopt -redundant-dbg-inst-elim -loweratomic -loop-deletion -infer-address-spaces -strip-dead-prototypes -coro-early -sancov -strip-dead-prototypes -irce -loop-versioning -canonicalize-aliases -globalsplit -loop-deletion -globalsplit -instnamer -load-store-vectorizer -mldst-motion -pgo-memop-opt -newgvn -loop-sink -redundant-dbg-inst-elim -infer-address-spaces -loop-unroll-and-jam -prune-eh -coro-split -lower-widenable-condition -bdce -mergereturn -consthoist -inferattrs -inject-tli-mappings -ipsccp -sink -indvars -loop-unroll-and-jam -reassociate -argpromotion -dce -strip-debug-declare -memcpyopt -consthoist -coro-early -add-discriminators -div-rem-pairs -memcpyopt -loop-rotate -instnamer -newgvn -pgo-memop-opt -loop-load-elim -adce -bdce -loop-guard-widening -cross-dso-cfi -mergereturn -ipsccp -lower-expect -barrier -loop-fusion -indvars -loop-predication -irce -loop-instsimplify -loop-predication -lower-matrix-intrinsics -pgo-memop-opt -lowerswitch -loop-fusion -gvn -loop-versioning-licm -instcombine -mldst-motion -loop-idiom -mem2reg -mergefunc -libcalls-shrinkwrap -scalarizer -coro-elide -lowerswitch -separate-const-offset-from-gep -argpromotion -lcssa -loop-reduce -float2int -mergefunc -alignment-from-assumptions -hotcoldsplit -name-anon-globals -ipconstprop -post-inline-ee-instrument -hotcoldsplit -lower-expect -always-inline -called-value-propagation -gvn-hoist -irce -loop-load-elim -lowerinvoke -name-anon-globals -sccp -lower-widenable-condition -strip-debug-declare -mem2reg -inferattrs -mergeicmps -separate-const-offset-from-gep -strip -bdce -argpromotion -ipsccp -always-inline -barrier -sccp -coro-early -inject-tli-mappings -break-crit-edges -canonicalize-aliases -tailcallelim -dse -elim-avail-extern -dce -insert-gcov-profiling -scalarizer -elim-avail-extern -loop-simplify -add-discriminators -loop-rotate -constprop -simple-loop-unswitch -mem2reg -reg2mem -indvars -lowerinvoke -coro-elide -load-store-vectorizer -lowerswitch -loop-simplifycfg -slp-vectorizer -instnamer -infer-address-spaces -lowerinvoke -loop-simplifycfg -dse -loop-sink -infer-address-spaces -dce -loop-simplify -dce -loop-unroll -loop-fusion -coro-cleanup -elim-avail-extern -simplifycfg -lower-matrix-intrinsics -jump-threading -constmerge -mergereturn -loop-deletion -loop-rotate -sink -mem2reg -loop-deletion -libcalls-shrinkwrap -lcssa -sccp -loop-sink -div-rem-pairs -instsimplify -mergefunc -loop-data-prefetch -strip-debug-declare -strip -simplifycfg -jump-threading -loop-predication -ee-instrument -tailcallelim -ipsccp -lower-guard-intrinsic -simplifycfg -rpo-functionattrs -speculative-execution -constprop -strip-nondebug -instcombine input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0191256830601092,10801.714073419571,opt -lcssa -infer-address-spaces -dse -simplifycfg -tailcallelim -lower-matrix-intrinsics -inferattrs -infer-address-spaces -lower-constant-intrinsics -sroa -loop-deletion -consthoist -globaldce -lower-expect -correlated-propagation -gvn-hoist -memcpyopt -loop-instsimplify -scalarizer -globalsplit -argpromotion -coro-split -loop-vectorize -mergefunc -loop-idiom -forceattrs -partially-inline-libcalls -loop-load-elim -instsimplify -loop-unroll -tailcallelim -globaldce -loop-deletion -lowerswitch -reassociate -functionattrs -lower-matrix-intrinsics -irce -sink -aggressive-instcombine -adce -attributor -early-cse-memssa -flattencfg -callsite-splitting -deadargelim -speculative-execution -lower-expect -hotcoldsplit -strip-dead-prototypes -loop-instsimplify -attributor -globalsplit -instsimplify -lower-matrix-intrinsics -strip -infer-address-spaces -reassociate -licm -coro-split -infer-address-spaces -lower-matrix-intrinsics -coro-early -dce -lower-widenable-condition -attributor -reassociate -pgo-memop-opt -coro-cleanup -loop-versioning-licm -aggressive-instcombine -lowerinvoke -slp-vectorizer -globaldce -lower-expect -indvars -inferattrs -loop-unroll -memcpyopt -inferattrs -elim-avail-extern -rewrite-statepoints-for-gc -name-anon-globals -constprop -constmerge -break-crit-edges -newgvn -globalopt -add-discriminators -reassociate -slsr -licm -newgvn -separate-const-offset-from-gep -loop-data-prefetch -mergefunc -float2int -lower-matrix-intrinsics -memcpyopt -prune-eh -strip-nondebug -mldst-motion -loop-simplify -aggressive-instcombine -add-discriminators -callsite-splitting -dce -lower-expect -instsimplify -redundant-dbg-inst-elim -lower-constant-intrinsics -globalsplit -instcombine -canonicalize-aliases -called-value-propagation -loop-load-elim -dce -bdce -name-anon-globals -loweratomic -slp-vectorizer -simple-loop-unswitch -barrier -rpo-functionattrs -instcombine -mergefunc -libcalls-shrinkwrap -loop-versioning -loop-load-elim -lowerinvoke -early-cse-memssa -coro-cleanup -lower-guard-intrinsic -ipsccp -coro-cleanup -add-discriminators -globaldce -loop-simplify -sancov -break-crit-edges -lower-guard-intrinsic -aggressive-instcombine -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,1.003731343283582,10801.818507194519,opt -instcombine -scalarizer -loop-instsimplify -strip-debug-declare -pgo-memop-opt -separate-const-offset-from-gep -forceattrs -mergefunc -scalarizer -newgvn -post-inline-ee-instrument -forceattrs -die -newgvn -guard-widening -loop-distribute -libcalls-shrinkwrap -functionattrs -loop-rotate -ee-instrument -forceattrs -ipconstprop -sccp -aggressive-instcombine -loop-data-prefetch -ee-instrument -sroa -scalarizer -loop-instsimplify -called-value-propagation -partial-inliner -mergefunc -add-discriminators -cross-dso-cfi -sccp -nary-reassociate -loop-rotate -div-rem-pairs -loop-unswitch -libcalls-shrinkwrap -elim-avail-extern -newgvn -indvars -lower-constant-intrinsics -globaldce -indvars -loop-rotate -gvn -functionattrs -licm -loop-instsimplify -loop-unswitch -bdce -lower-widenable-condition -attributor -mldst-motion -slsr -instcombine -deadargelim -nary-reassociate -ee-instrument -die -elim-avail-extern -insert-gcov-profiling -add-discriminators -lower-guard-intrinsic -loop-fusion -slp-vectorizer -name-anon-globals -loop-unroll -jump-threading -loop-distribute -infer-address-spaces -dse -div-rem-pairs -constmerge -forceattrs -consthoist -lower-matrix-intrinsics -gvn-hoist -pgo-memop-opt -globalopt -always-inline -dce -lower-matrix-intrinsics -ee-instrument -strip-debug-declare -strip-dead-prototypes -canonicalize-aliases -die -mem2reg -indvars -separate-const-offset-from-gep -partial-inliner -globaldce -always-inline -tailcallelim -simplifycfg -gvn-hoist -constprop -sink -ipconstprop -ipsccp -instcombine input.bc -o output.bc +benchmark://cbench-v1/susan,0.9847709239825954,3603.660972595215,opt -break-crit-edges -lowerinvoke -reg2mem -bdce -loop-predication -newgvn -constprop -loop-interchange -load-store-vectorizer -globalopt -inferattrs -deadargelim -loop-versioning -inline -aggressive-instcombine -gvn -instcombine -strip-nondebug -loop-sink -partially-inline-libcalls -mergefunc -forceattrs -mldst-motion -irce -speculative-execution -strip-debug-declare -bdce -loop-unroll-and-jam -simple-loop-unswitch -inject-tli-mappings -slsr -loop-distribute -lower-guard-intrinsic -lower-widenable-condition -loop-reroll -coro-cleanup -sccp -gvn-hoist -functionattrs -adce -adce -inferattrs -instcombine -strip-debug-declare -scalarizer -sccp -newgvn -mergeicmps -mergeicmps -consthoist -dce -name-anon-globals -gvn -separate-const-offset-from-gep -simplifycfg -loop-instsimplify -name-anon-globals -mem2reg -redundant-dbg-inst-elim -rewrite-statepoints-for-gc -coro-elide -coro-cleanup -consthoist -early-cse-memssa -loop-idiom -constprop -adce -guard-widening -lower-guard-intrinsic -globaldce -gvn -globalsplit -float2int -mergeicmps -coro-elide -loop-guard-widening -functionattrs -constprop -slp-vectorizer -simple-loop-unswitch -loop-sink -mldst-motion -loop-predication -instcombine -callsite-splitting -loop-data-prefetch -sccp -alignment-from-assumptions -cross-dso-cfi -instnamer -inferattrs -mldst-motion -guard-widening -loop-simplify -loop-data-prefetch -die -constprop -strip -sccp -slsr -newgvn -sroa -loop-simplifycfg -loop-instsimplify -elim-avail-extern -mergefunc -loop-interchange -div-rem-pairs -loop-interchange -mergereturn -lower-guard-intrinsic -libcalls-shrinkwrap -nary-reassociate -lower-matrix-intrinsics -aggressive-instcombine -ee-instrument -globaldce -prune-eh -jump-threading -mergereturn -functionattrs -lower-matrix-intrinsics -correlated-propagation -separate-const-offset-from-gep -div-rem-pairs -hotcoldsplit -loop-data-prefetch -mergereturn -insert-gcov-profiling -die -instsimplify -lower-matrix-intrinsics -partially-inline-libcalls -prune-eh -canonicalize-aliases -strip-debug-declare -strip-dead-prototypes -always-inline -strip -jump-threading -coro-split -inferattrs -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0406533185286009,10814.408720254898,opt -scalarizer -constmerge -die -loop-unswitch -lcssa -dce -libcalls-shrinkwrap -reassociate -simplifycfg -barrier -coro-cleanup -sink -rpo-functionattrs -loop-data-prefetch -lower-guard-intrinsic -sroa -div-rem-pairs -hotcoldsplit -scalarizer -loop-predication -dse -tailcallelim -licm -strip-debug-declare -jump-threading -irce -ipconstprop -loop-interchange -correlated-propagation -loop-versioning -constprop -correlated-propagation -add-discriminators -forceattrs -loop-fusion -loop-data-prefetch -correlated-propagation -lowerinvoke -always-inline -ee-instrument -loop-predication -add-discriminators -simple-loop-unswitch -forceattrs -consthoist -aggressive-instcombine -deadargelim -loop-distribute -mergeicmps -gvn -reassociate -gvn-hoist -nary-reassociate -separate-const-offset-from-gep -simplifycfg -name-anon-globals -scalarizer -instcombine -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0394226626454115,10816.927260875702,opt -deadargelim -mem2reg -reg2mem -inferattrs -lowerinvoke -separate-const-offset-from-gep -strip-dead-prototypes -infer-address-spaces -nary-reassociate -loop-reroll -mldst-motion -slsr -loop-data-prefetch -loop-guard-widening -hotcoldsplit -loop-unroll -separate-const-offset-from-gep -tailcallelim -adce -strip-dead-prototypes -globalopt -barrier -mergefunc -instsimplify -loop-versioning -lcssa -simple-loop-unswitch -callsite-splitting -lcssa -mergereturn -newgvn -dce -separate-const-offset-from-gep -ipconstprop -loop-versioning -guard-widening -instnamer -coro-elide -coro-elide -alignment-from-assumptions -globalopt -newgvn -loop-unroll -mergereturn -strip-dead-prototypes -loop-simplify -partial-inliner -add-discriminators -loweratomic -mem2reg -simplifycfg -lower-widenable-condition -gvn-hoist -prune-eh -elim-avail-extern -strip-nondebug -lowerinvoke -loop-fusion -lower-guard-intrinsic -newgvn -partially-inline-libcalls -instcombine -separate-const-offset-from-gep -reassociate -lower-guard-intrinsic -div-rem-pairs -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.0419550173010381,10943.992988586426,opt -mem2reg -simplifycfg -strip-nondebug -add-discriminators -tailcallelim -tailcallelim -jump-threading -gvn-hoist -consthoist -strip -coro-cleanup -alignment-from-assumptions -callsite-splitting -hotcoldsplit -jump-threading -loop-data-prefetch -dce -bdce -mldst-motion -bdce -loop-guard-widening -guard-widening -nary-reassociate -barrier -loop-interchange -lower-matrix-intrinsics -loop-simplify -tailcallelim -separate-const-offset-from-gep -loweratomic -libcalls-shrinkwrap -flattencfg -rewrite-statepoints-for-gc -globalopt -inferattrs -tailcallelim -loweratomic -slp-vectorizer -name-anon-globals -gvn-hoist -sancov -loop-unroll-and-jam -add-discriminators -loop-idiom -rewrite-statepoints-for-gc -slp-vectorizer -loop-data-prefetch -loop-simplifycfg -argpromotion -loop-load-elim -constmerge -globaldce -loop-distribute -rpo-functionattrs -sancov -loop-load-elim -jump-threading -adce -lowerinvoke -cross-dso-cfi -reg2mem -strip-debug-declare -mem2reg -prune-eh -rewrite-statepoints-for-gc -constmerge -post-inline-ee-instrument -mem2reg -elim-avail-extern -mergefunc -slp-vectorizer -prune-eh -newgvn -jump-threading -loop-deletion -mldst-motion -functionattrs -coro-early -lower-constant-intrinsics -loop-simplify -speculative-execution -deadargelim -licm -coro-elide -lower-expect -memcpyopt -insert-gcov-profiling -gvn -loop-reroll -loweratomic -barrier -loop-predication -lower-matrix-intrinsics -barrier -loop-distribute -hotcoldsplit -lower-widenable-condition -ipsccp -break-crit-edges -reassociate -coro-early -dce -loop-sink -constmerge -loop-idiom -lowerinvoke -reassociate -called-value-propagation -newgvn -sroa -partial-inliner -instcombine -lcssa -flattencfg -lower-matrix-intrinsics -early-cse-memssa -called-value-propagation -infer-address-spaces -float2int -inject-tli-mappings -insert-gcov-profiling -loop-sink -break-crit-edges -nary-reassociate -scalarizer -libcalls-shrinkwrap -adce -prune-eh -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0387964891909427,10998.024054765701,opt -simplifycfg -constmerge -loop-simplifycfg -loop-predication -prune-eh -attributor -reg2mem -memcpyopt -deadargelim -dce -partially-inline-libcalls -instsimplify -indvars -slsr -forceattrs -newgvn -constmerge -lower-constant-intrinsics -sccp -mem2reg -prune-eh -sancov -sccp -partially-inline-libcalls -rewrite-statepoints-for-gc -loweratomic -loop-reroll -ipconstprop -strip-dead-prototypes -functionattrs -loop-simplify -sancov -barrier -lower-widenable-condition -attributor -licm -instcombine -loop-instsimplify -mem2reg -loop-data-prefetch -newgvn -rewrite-statepoints-for-gc -aggressive-instcombine -lower-guard-intrinsic -called-value-propagation -constmerge -functionattrs -name-anon-globals -barrier -loop-instsimplify -loop-versioning-licm -newgvn -simplifycfg -slp-vectorizer -constprop -flattencfg -rpo-functionattrs -loweratomic -instsimplify -memcpyopt input.bc -o output.bc diff --git a/leaderboard/llvm_instcount/random_search/results_p125_t3600.csv b/leaderboard/llvm_instcount/random_search/results_p125_t3600.csv index 48e9420de..64128d4b7 100644 --- a/leaderboard/llvm_instcount/random_search/results_p125_t3600.csv +++ b/leaderboard/llvm_instcount/random_search/results_p125_t3600.csv @@ -1,24 +1,24 @@ benchmark,reward,walltime,commandline -benchmark://cBench-v1/adpcm,1.0083798882681565,3601.6958680152893,opt -loop-deletion -nary-reassociate -alignment-from-assumptions -add-discriminators -loop-idiom -mem2reg -scalarizer -ee-instrument -globalopt -partial-inliner -loop-reroll -reassociate -loop-data-prefetch -strip -globalopt -float2int -add-discriminators -deadargelim -inject-tli-mappings -guard-widening -sroa -insert-gcov-profiling -loop-unroll-and-jam -alignment-from-assumptions -deadargelim -loop-deletion -prune-eh -constprop -infer-address-spaces -loop-simplify -loop-interchange -correlated-propagation -attributor -memcpyopt -div-rem-pairs -loop-interchange -ee-instrument -elim-avail-extern -dse -div-rem-pairs -prune-eh -argpromotion -libcalls-shrinkwrap -mergeicmps -infer-address-spaces -loop-distribute -globalopt -loop-sink -correlated-propagation -loop-versioning-licm -lower-matrix-intrinsics -constmerge -forceattrs -alignment-from-assumptions -jump-threading -inferattrs -called-value-propagation -mergeicmps -load-store-vectorizer -simplifycfg -strip-dead-prototypes -add-discriminators -mergeicmps -memcpyopt -strip -lower-expect -loop-reroll -loop-load-elim -instcombine -attributor -loop-reroll -inline -mergereturn -globalopt -div-rem-pairs -partial-inliner -inferattrs -adce -mergefunc -mldst-motion -coro-split -loop-reduce -deadargelim -reassociate -adce -lower-expect -always-inline -mergefunc -instsimplify -attributor -slp-vectorizer -speculative-execution -constmerge -consthoist -barrier -strip-dead-prototypes -gvn-hoist -early-cse-memssa -inferattrs -coro-split -flattencfg -newgvn -coro-elide -reassociate -separate-const-offset-from-gep -loop-idiom -constprop -functionattrs -jump-threading -insert-gcov-profiling -simplifycfg -sancov -dse -instcombine input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.0154867256637168,3601.5673730373383,opt -loop-instsimplify -inferattrs -indvars -tailcallelim -adce -lower-expect -loop-guard-widening -hotcoldsplit -loop-versioning -memcpyopt -loop-instsimplify -loop-load-elim -sink -canonicalize-aliases -float2int -barrier -reg2mem -always-inline -div-rem-pairs -loop-data-prefetch -attributor -loop-idiom -alignment-from-assumptions -globalsplit -scalarizer -div-rem-pairs -add-discriminators -strip -flattencfg -elim-avail-extern -strip-dead-prototypes -reassociate -lower-guard-intrinsic -separate-const-offset-from-gep -div-rem-pairs -lowerswitch -sroa -elim-avail-extern -indvars -adce -irce -lower-guard-intrinsic -ipconstprop -called-value-propagation -strip-debug-declare -gvn-hoist -lowerinvoke -mergereturn -lower-expect -reassociate -barrier -ipconstprop -libcalls-shrinkwrap -early-cse-memssa -infer-address-spaces -globalopt -simple-loop-unswitch -partially-inline-libcalls -tailcallelim -loop-fusion -simplifycfg -mergefunc -loop-unroll-and-jam -separate-const-offset-from-gep -infer-address-spaces -loop-data-prefetch -ipsccp -deadargelim -indvars -jump-threading -loop-reduce -licm -loop-reduce -instcombine -flattencfg -inject-tli-mappings -constmerge -add-discriminators -alignment-from-assumptions -ee-instrument -speculative-execution -loop-interchange -mldst-motion -instnamer -mem2reg -argpromotion -memcpyopt -pgo-memop-opt -early-cse-memssa -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0814249363867694,3601.9053058624268,opt -licm -sroa -post-inline-ee-instrument -float2int -instsimplify -pgo-memop-opt -dce -early-cse-memssa -inferattrs -strip-nondebug -flattencfg -loop-interchange -float2int -add-discriminators -loop-vectorize -aggressive-instcombine -prune-eh -gvn-hoist -loop-predication -irce -instcombine -globalsplit -pgo-memop-opt -lcssa -loop-guard-widening -mldst-motion -loop-simplifycfg -hotcoldsplit -loop-vectorize -forceattrs -rewrite-statepoints-for-gc -coro-elide -forceattrs -deadargelim -infer-address-spaces -float2int -deadargelim -coro-early -libcalls-shrinkwrap -loop-fusion -prune-eh -aggressive-instcombine -coro-early -loop-load-elim -elim-avail-extern -flattencfg -ipconstprop -lower-matrix-intrinsics -aggressive-instcombine -strip -memcpyopt -lcssa -irce -scalarizer -lcssa -add-discriminators -coro-cleanup -coro-elide -sink -tailcallelim -barrier -lower-guard-intrinsic -bdce -deadargelim -load-store-vectorizer -die -reassociate -post-inline-ee-instrument -attributor -simple-loop-unswitch -loop-guard-widening -canonicalize-aliases -sink -pgo-memop-opt -bdce -ee-instrument -tailcallelim -loop-versioning -alignment-from-assumptions -instsimplify -simplifycfg -add-discriminators -pgo-memop-opt -dce -loop-simplifycfg -inject-tli-mappings -licm -strip-dead-prototypes -irce -globaldce -pgo-memop-opt -lower-widenable-condition -alignment-from-assumptions -globaldce -slp-vectorizer -globaldce -alignment-from-assumptions -loop-sink -barrier -instcombine -correlated-propagation -ipsccp -loop-instsimplify -sccp -alignment-from-assumptions -partial-inliner -forceattrs -loop-distribute -loop-interchange -separate-const-offset-from-gep -newgvn -loop-instsimplify -globaldce -indvars -deadargelim -instsimplify -redundant-dbg-inst-elim -loop-idiom -licm -loop-unroll-and-jam -hotcoldsplit -mergereturn -partially-inline-libcalls -div-rem-pairs -sink -strip-debug-declare -infer-address-spaces -instnamer -inline -gvn -functionattrs -nary-reassociate -loop-reroll -barrier -prune-eh -loop-unroll-and-jam -functionattrs -post-inline-ee-instrument -partial-inliner -simple-loop-unswitch -mergefunc -rewrite-statepoints-for-gc -loop-distribute -instnamer -memcpyopt -loop-load-elim -strip-debug-declare -ee-instrument -insert-gcov-profiling -ee-instrument -sink -simplifycfg -memcpyopt -die -deadargelim -newgvn -loop-idiom -lowerinvoke -scalarizer -loop-simplifycfg -early-cse-memssa -partial-inliner -globalsplit -lower-matrix-intrinsics -loop-data-prefetch -coro-cleanup -nary-reassociate -dce -forceattrs -always-inline -strip-nondebug -lower-expect -callsite-splitting -prune-eh -bdce -loop-versioning-licm -always-inline -post-inline-ee-instrument -insert-gcov-profiling -loop-data-prefetch -sancov -loop-guard-widening -alignment-from-assumptions -functionattrs -sroa -strip-nondebug -consthoist -jump-threading -guard-widening -consthoist -speculative-execution -die -reassociate -forceattrs -adce -loop-data-prefetch -float2int -forceattrs -loop-distribute -bdce -loop-load-elim -indvars -sancov -slp-vectorizer -tailcallelim -lower-guard-intrinsic -irce -float2int -consthoist -strip-debug-declare -sancov -loop-simplify -memcpyopt -loop-simplify -guard-widening -ipconstprop -coro-cleanup -hotcoldsplit -strip-debug-declare -instcombine -dse -strip-debug-declare -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.1955944383690047,3768.8419275283813,opt -consthoist -jump-threading -hotcoldsplit -dce -correlated-propagation -partially-inline-libcalls -coro-split -adce -loop-instsimplify -loop-versioning -globalsplit -mergereturn -guard-widening -dse -ee-instrument -aggressive-instcombine -simplifycfg -coro-cleanup -early-cse-memssa -sroa -inject-tli-mappings -rpo-functionattrs -simplifycfg -loop-interchange -loop-distribute -sccp -name-anon-globals -loop-idiom -loop-predication -name-anon-globals -sink -barrier -functionattrs -loop-idiom -newgvn -mem2reg -mergeicmps -licm -loop-versioning -loop-versioning -loop-versioning-licm -constmerge -die -ee-instrument -loop-versioning-licm -mergefunc -jump-threading -instcombine -name-anon-globals -forceattrs -nary-reassociate -deadargelim -sink -gvn -pgo-memop-opt -inject-tli-mappings -loop-deletion -strip-debug-declare -jump-threading -div-rem-pairs -gvn input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,3601.8237340450287,opt -gvn -instcombine -constprop -slsr -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.9948979591836737,3601.5456669330597,opt -loop-vectorize -scalarizer -loop-unswitch -canonicalize-aliases -instnamer -dce -early-cse-memssa -prune-eh -loop-reduce -post-inline-ee-instrument -loop-unroll -ipconstprop -reg2mem -mem2reg -ee-instrument -globalsplit -simplifycfg -div-rem-pairs -always-inline -simplifycfg -newgvn -early-cse-memssa -lowerswitch -inferattrs -scalarizer -sancov -loop-interchange -reassociate -dse -libcalls-shrinkwrap -sccp -loop-sink -globaldce -loop-deletion -functionattrs -licm -adce -simple-loop-unswitch -rewrite-statepoints-for-gc -mergefunc -post-inline-ee-instrument -coro-split -argpromotion -load-store-vectorizer -lower-matrix-intrinsics -early-cse-memssa -sroa -called-value-propagation -sancov -canonicalize-aliases -reassociate -elim-avail-extern -jump-threading -gvn-hoist -loop-vectorize -loop-data-prefetch -callsite-splitting -loop-sink -irce -attributor -load-store-vectorizer -coro-elide -gvn-hoist -elim-avail-extern -deadargelim -coro-early -callsite-splitting -loop-vectorize -load-store-vectorizer -loop-idiom -instcombine -elim-avail-extern -post-inline-ee-instrument -callsite-splitting -jump-threading -elim-avail-extern -insert-gcov-profiling -partially-inline-libcalls -slp-vectorizer -float2int -inferattrs -reassociate -slsr -prune-eh -tailcallelim -canonicalize-aliases -ipconstprop -indvars -redundant-dbg-inst-elim -prune-eh -lower-matrix-intrinsics -loop-vectorize -coro-elide -strip-debug-declare -canonicalize-aliases -coro-elide -adce -lower-expect -mergereturn -instsimplify -infer-address-spaces -mergeicmps -lower-guard-intrinsic -lower-constant-intrinsics -redundant-dbg-inst-elim -barrier -mldst-motion -loop-distribute -guard-widening -loop-simplifycfg -lower-expect -lowerswitch -dce -jump-threading -lowerinvoke -tailcallelim -lower-widenable-condition -coro-split -cross-dso-cfi -reg2mem -loop-reroll -sroa -loop-simplifycfg -partially-inline-libcalls -slp-vectorizer -dce -break-crit-edges -loop-instsimplify -correlated-propagation -insert-gcov-profiling -early-cse-memssa -loop-unroll-and-jam -tailcallelim -jump-threading -infer-address-spaces -coro-early -pgo-memop-opt -pgo-memop-opt -canonicalize-aliases -irce -loop-idiom -rpo-functionattrs -loop-unroll-and-jam -instcombine -redundant-dbg-inst-elim -loop-vectorize -speculative-execution -simplifycfg -sccp -partially-inline-libcalls -correlated-propagation input.bc -o output.bc -benchmark://cBench-v1/ghostscript,1.0082655103985454,3718.0952739715576,opt -name-anon-globals -coro-cleanup -forceattrs -argpromotion -coro-elide -slp-vectorizer -scalarizer -inject-tli-mappings -loop-deletion -elim-avail-extern -partially-inline-libcalls -loop-fusion -infer-address-spaces -sroa -mergefunc -reg2mem -sroa -irce -lcssa -float2int -loop-simplifycfg -dse -adce -float2int -argpromotion -sroa -loop-idiom -reassociate -lower-guard-intrinsic -loop-distribute -lowerinvoke -break-crit-edges -lower-guard-intrinsic -memcpyopt -gvn-hoist -loop-sink -attributor -jump-threading -loop-unroll-and-jam -attributor -irce -flattencfg -indvars -instsimplify -ipsccp -loop-guard-widening -slp-vectorizer -lower-expect -guard-widening -loop-instsimplify -inject-tli-mappings -slsr -coro-elide -strip-dead-prototypes -ipsccp -mldst-motion -nary-reassociate -alignment-from-assumptions -callsite-splitting -lowerinvoke -rewrite-statepoints-for-gc -argpromotion -consthoist -coro-cleanup -early-cse-memssa -redundant-dbg-inst-elim -loop-versioning-licm -loop-deletion -deadargelim -coro-elide -lower-guard-intrinsic -inject-tli-mappings -strip -always-inline -instcombine -ee-instrument -globalsplit -float2int -canonicalize-aliases -coro-cleanup -barrier -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/gsm,1.086030876494024,3625.1922268867493,opt -instnamer -post-inline-ee-instrument -sroa -loop-guard-widening -ipconstprop -newgvn -loop-versioning -flattencfg -functionattrs -barrier -insert-gcov-profiling -loop-guard-widening -barrier -inferattrs -pgo-memop-opt -mldst-motion -loop-vectorize -mergefunc -libcalls-shrinkwrap -loop-fusion -canonicalize-aliases -irce -attributor -barrier -dce -instcombine -adce -simplifycfg -instsimplify -consthoist -instcombine -loop-distribute -loop-data-prefetch -inject-tli-mappings -strip-nondebug -ipconstprop -mldst-motion -load-store-vectorizer -instcombine -mergefunc -inject-tli-mappings -loop-deletion -called-value-propagation -libcalls-shrinkwrap -die -indvars -globalsplit -alignment-from-assumptions -jump-threading -loweratomic -loop-guard-widening -loop-unswitch -loop-deletion -lowerinvoke -slsr -rpo-functionattrs -alignment-from-assumptions -strip-debug-declare -constmerge -strip-dead-prototypes -adce -always-inline -prune-eh -dce -ee-instrument -slsr -loop-data-prefetch -post-inline-ee-instrument -loop-distribute -jump-threading -rpo-functionattrs -loop-simplify -consthoist -separate-const-offset-from-gep -licm -aggressive-instcombine -adce -slp-vectorizer -indvars -loop-fusion -attributor -indvars -gvn -redundant-dbg-inst-elim -globalopt -loop-simplify -insert-gcov-profiling -forceattrs -loop-load-elim -canonicalize-aliases -inject-tli-mappings -mldst-motion -mergereturn -sink -lower-widenable-condition -load-store-vectorizer -early-cse-memssa -attributor -newgvn -redundant-dbg-inst-elim -lower-constant-intrinsics -die -mergefunc -globaldce -strip-debug-declare -ipsccp -float2int -rewrite-statepoints-for-gc -ipconstprop -instcombine input.bc -o output.bc -benchmark://cBench-v1/ispell,1.0108374384236454,3604.3012421131134,opt -loop-idiom -loop-unroll -sancov -loop-versioning -infer-address-spaces -early-cse-memssa -sccp -called-value-propagation -lcssa -separate-const-offset-from-gep -constmerge -newgvn -constprop -forceattrs -coro-split -globalopt -partially-inline-libcalls -lower-constant-intrinsics -ipsccp -redundant-dbg-inst-elim -barrier -constprop -hotcoldsplit -adce -prune-eh -strip-nondebug -constmerge -constprop -globalopt -gvn-hoist -loop-guard-widening -instsimplify -loop-interchange -break-crit-edges -loop-simplifycfg -irce -loop-deletion -lower-widenable-condition -rpo-functionattrs -functionattrs -guard-widening -strip-debug-declare -loop-sink -flattencfg -inject-tli-mappings -adce -argpromotion -loop-interchange -lower-constant-intrinsics -sccp -loop-reduce -mem2reg -simplifycfg -loop-data-prefetch -indvars -mem2reg -nary-reassociate -canonicalize-aliases -partially-inline-libcalls -loop-instsimplify -irce -hotcoldsplit -loop-simplify -always-inline -attributor -globalopt -lowerinvoke -rpo-functionattrs -loop-interchange -slsr -flattencfg -coro-early -deadargelim -instcombine -loop-data-prefetch -lower-constant-intrinsics -always-inline -add-discriminators -nary-reassociate -coro-early -memcpyopt -coro-split -div-rem-pairs -loop-vectorize -coro-early -loop-unroll -mldst-motion -functionattrs -mergereturn -simplifycfg -cross-dso-cfi -slsr -ipconstprop -loweratomic -canonicalize-aliases -globalopt -correlated-propagation -irce -break-crit-edges -lower-expect -bdce -redundant-dbg-inst-elim -bdce -pgo-memop-opt -globalsplit -loop-unroll-and-jam -instcombine -early-cse-memssa -cross-dso-cfi -mem2reg -globalsplit -loop-simplifycfg -correlated-propagation -mergeicmps -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.0321790619090427,3613.718739748001,opt -newgvn -insert-gcov-profiling -canonicalize-aliases -die -consthoist -scalarizer -consthoist -coro-early -loop-simplifycfg -always-inline -loop-unroll-and-jam -sroa -die -lowerinvoke -sink -loop-predication -reg2mem -scalarizer -lcssa -early-cse-memssa -inject-tli-mappings -constprop -always-inline -reg2mem -loop-fusion -speculative-execution -insert-gcov-profiling -prune-eh -loop-data-prefetch -newgvn -canonicalize-aliases -loop-vectorize -loop-simplifycfg -argpromotion -constmerge -prune-eh -rpo-functionattrs -loop-reduce -strip-dead-prototypes -loop-unroll-and-jam -loop-distribute -always-inline -loop-versioning -loop-simplify -partially-inline-libcalls -loop-data-prefetch -aggressive-instcombine -loop-simplify -dce -ipsccp -mem2reg -ipconstprop -memcpyopt -loop-interchange -loop-load-elim -mergeicmps -inject-tli-mappings -alignment-from-assumptions -insert-gcov-profiling -loop-fusion -partial-inliner -early-cse-memssa -elim-avail-extern -insert-gcov-profiling -rpo-functionattrs -separate-const-offset-from-gep -inject-tli-mappings -deadargelim -consthoist -loop-interchange -instcombine -nary-reassociate -licm -libcalls-shrinkwrap -simplifycfg -partially-inline-libcalls -infer-address-spaces -forceattrs -slp-vectorizer -die -mldst-motion -instsimplify -sccp -newgvn -infer-address-spaces -simple-loop-unswitch -dce -nary-reassociate -loop-distribute -callsite-splitting -loop-sink -loop-fusion -mergefunc -gvn -canonicalize-aliases -jump-threading -loop-versioning -newgvn -loop-sink -float2int -gvn -strip-debug-declare -inferattrs -simplifycfg -prune-eh -nary-reassociate -loop-versioning -consthoist -dce input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.0331948871502625,3639.5563414096832,opt -constmerge -loop-distribute -sink -separate-const-offset-from-gep -loop-idiom -loop-unroll-and-jam -load-store-vectorizer -aggressive-instcombine -load-store-vectorizer -licm -slp-vectorizer -flattencfg -loweratomic -licm -elim-avail-extern -elim-avail-extern -redundant-dbg-inst-elim -irce -partially-inline-libcalls -deadargelim -loop-idiom -memcpyopt -loop-vectorize -consthoist -coro-cleanup -loop-idiom -jump-threading -cross-dso-cfi -loop-reroll -separate-const-offset-from-gep -loop-load-elim -lower-constant-intrinsics -mem2reg -mergefunc -argpromotion -float2int -inject-tli-mappings -newgvn -scalarizer -pgo-memop-opt -lower-matrix-intrinsics -adce -indvars -sccp -globaldce -simplifycfg -globalsplit -lower-widenable-condition -lower-constant-intrinsics -slsr -dce -instcombine -called-value-propagation -jump-threading -loop-versioning -loop-versioning -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/lame,1.053404691414257,3609.5372927188873,opt -irce -lcssa -forceattrs -reg2mem -partially-inline-libcalls -consthoist -scalarizer -sancov -strip-dead-prototypes -sroa -loop-instsimplify -coro-cleanup -loop-distribute -pgo-memop-opt -separate-const-offset-from-gep -rpo-functionattrs -rewrite-statepoints-for-gc -instsimplify -loop-simplify -sancov -loop-deletion -lower-constant-intrinsics -loop-simplifycfg -loop-distribute -early-cse-memssa -simplifycfg -loop-simplify -loop-unswitch -loop-simplifycfg -coro-elide -instcombine -sancov -insert-gcov-profiling -coro-early -argpromotion -constmerge -reassociate -insert-gcov-profiling -slsr -gvn-hoist -sroa -bdce -loop-guard-widening -jump-threading -inject-tli-mappings -dse -loop-interchange -float2int -called-value-propagation -break-crit-edges -partially-inline-libcalls -newgvn -correlated-propagation -sroa -mem2reg -canonicalize-aliases -always-inline -loop-interchange -div-rem-pairs -adce -elim-avail-extern -licm -lcssa -forceattrs -inject-tli-mappings -always-inline -coro-cleanup -lower-widenable-condition -loop-simplifycfg -mem2reg -loop-simplifycfg -lower-guard-intrinsic -lcssa -always-inline -loop-versioning -alignment-from-assumptions -slp-vectorizer -instnamer -loop-versioning -simplifycfg -lower-constant-intrinsics -gvn -nary-reassociate -hotcoldsplit -inferattrs -instnamer -strip-debug-declare -aggressive-instcombine -div-rem-pairs -partially-inline-libcalls -loop-instsimplify -flattencfg -slp-vectorizer -instsimplify -loop-simplify -constprop -gvn-hoist -mem2reg -sancov -forceattrs -post-inline-ee-instrument -speculative-execution -indvars -gvn -lcssa -prune-eh -simplifycfg -loop-unroll-and-jam -instsimplify -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/patricia,1.0055617352614012,3602.584586620331,opt -irce -simplifycfg -loweratomic -adce -attributor -called-value-propagation -load-store-vectorizer -correlated-propagation -callsite-splitting -name-anon-globals -hotcoldsplit -loop-simplifycfg -lowerswitch -load-store-vectorizer -prune-eh -prune-eh -loop-guard-widening -scalarizer -infer-address-spaces -add-discriminators -loop-fusion -lower-guard-intrinsic -memcpyopt -coro-early -globalsplit -lowerswitch -functionattrs -functionattrs -name-anon-globals -functionattrs -coro-early -loop-distribute -lower-guard-intrinsic -consthoist -barrier -consthoist -loop-simplifycfg -callsite-splitting -reassociate -licm -coro-split -loop-versioning-licm -inject-tli-mappings -loop-vectorize -loop-sink -correlated-propagation -add-discriminators -lower-matrix-intrinsics -loop-fusion -deadargelim -loop-simplifycfg -loop-versioning-licm -licm -pgo-memop-opt -inferattrs -sroa -loop-simplify -alignment-from-assumptions -mem2reg -instsimplify -loop-simplify -lower-expect -separate-const-offset-from-gep -slp-vectorizer -lower-matrix-intrinsics -strip -inject-tli-mappings -inferattrs -inferattrs -rewrite-statepoints-for-gc -sancov -globalsplit -deadargelim -instcombine -licm -callsite-splitting -lowerinvoke -canonicalize-aliases -mergefunc -ee-instrument -die -indvars -lower-guard-intrinsic -lower-widenable-condition -lower-expect -inferattrs -loop-simplifycfg -scalarizer -mldst-motion -consthoist -insert-gcov-profiling -loop-load-elim -ee-instrument -mergereturn -gvn -loop-fusion -separate-const-offset-from-gep -lowerswitch -forceattrs -elim-avail-extern -callsite-splitting -loop-predication -loop-guard-widening -instcombine -simplifycfg -correlated-propagation -reassociate input.bc -o output.bc -benchmark://cBench-v1/qsort,1.1331269349845199,3601.513120651245,opt -callsite-splitting -simple-loop-unswitch -lowerswitch -loop-data-prefetch -licm -speculative-execution -guard-widening -argpromotion -loop-instsimplify -reassociate -gvn -sink -globalsplit -load-store-vectorizer -redundant-dbg-inst-elim -separate-const-offset-from-gep -forceattrs -strip-debug-declare -called-value-propagation -mldst-motion -loop-load-elim -mergefunc -elim-avail-extern -ipconstprop -loop-reroll -lowerswitch -reg2mem -sccp -hotcoldsplit -constmerge -globaldce -guard-widening -scalarizer -lowerswitch -dce -loop-unroll -constmerge -reg2mem -separate-const-offset-from-gep -lower-constant-intrinsics -dce -argpromotion -break-crit-edges -lower-guard-intrinsic -insert-gcov-profiling -loop-data-prefetch -mldst-motion -redundant-dbg-inst-elim -deadargelim -always-inline -instsimplify -inline -licm -loop-simplifycfg -bdce -dce -aggressive-instcombine -loop-idiom -newgvn -gvn -rpo-functionattrs -sroa -sancov -die -post-inline-ee-instrument -loop-reroll -loop-instsimplify -bdce -loop-interchange -separate-const-offset-from-gep -rpo-functionattrs -rpo-functionattrs -consthoist -insert-gcov-profiling -loop-idiom -strip-dead-prototypes -instcombine -pgo-memop-opt -nary-reassociate -mem2reg -mergereturn -inferattrs -sink -correlated-propagation -ipconstprop -coro-cleanup -simplifycfg -float2int -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.1054043694902262,3602.2013919353485,opt -reassociate -mergefunc -mem2reg -bdce -newgvn -coro-elide -mergereturn -break-crit-edges -strip-nondebug -loop-reroll -functionattrs -sccp -correlated-propagation -strip-dead-prototypes -globaldce -loop-instsimplify -strip-nondebug -simplifycfg -instcombine -early-cse-memssa -sink -argpromotion -lower-expect -partially-inline-libcalls -reassociate -memcpyopt -adce -sroa -deadargelim -loop-data-prefetch -lower-widenable-condition -dce -hotcoldsplit -mergefunc -mergereturn -rewrite-statepoints-for-gc -separate-const-offset-from-gep -jump-threading input.bc -o output.bc -benchmark://cBench-v1/sha,1.5183946488294313,3601.795018196106,opt -break-crit-edges -simplifycfg -barrier -newgvn -lcssa -canonicalize-aliases -gvn -scalarizer -nary-reassociate -float2int -loop-vectorize -loop-interchange -loop-unroll -jump-threading -loop-unroll-and-jam -lower-guard-intrinsic -instcombine -loop-deletion -reassociate -loop-simplifycfg -constmerge -indvars -forceattrs -ipconstprop -lower-constant-intrinsics -loop-data-prefetch -globalopt -load-store-vectorizer -mldst-motion -slsr -insert-gcov-profiling -instcombine -instnamer -loop-predication -lower-matrix-intrinsics -coro-split -loop-reroll -loop-vectorize -elim-avail-extern -instnamer -partial-inliner -loop-rotate -adce -mergefunc -strip -sancov -pgo-memop-opt -mldst-motion -break-crit-edges -constmerge -prune-eh -loop-deletion -jump-threading -lower-constant-intrinsics -partial-inliner -coro-early -lowerinvoke -bdce -deadargelim -loop-simplifycfg -called-value-propagation -lower-widenable-condition -loop-deletion -sancov -sroa -instnamer -insert-gcov-profiling -loweratomic -slp-vectorizer -strip -nary-reassociate -loop-guard-widening -forceattrs -adce -loop-simplifycfg -separate-const-offset-from-gep -lower-expect -inferattrs -strip -simple-loop-unswitch -lower-guard-intrinsic -coro-elide -jump-threading -ipsccp -instcombine -break-crit-edges -slp-vectorizer -ipsccp -simplifycfg -name-anon-globals -partially-inline-libcalls -newgvn input.bc -o output.bc -benchmark://cBench-v1/stringsearch,1.0163934426229506,3601.6986713409424,opt -indvars -deadargelim -sccp -bdce -loop-simplifycfg -lower-expect -coro-split -strip-debug-declare -early-cse-memssa -coro-elide -float2int -die -simplifycfg -break-crit-edges -strip-debug-declare -loop-simplifycfg -mem2reg -float2int -globalopt -instnamer -inferattrs -loop-distribute -break-crit-edges -post-inline-ee-instrument -strip -flattencfg -coro-early -irce -aggressive-instcombine -rpo-functionattrs -gvn-hoist -globalopt -instnamer -adce -coro-early -partial-inliner -loop-unroll-and-jam -sink -lower-constant-intrinsics -sink -flattencfg -correlated-propagation -lcssa -mldst-motion -tailcallelim -sccp -post-inline-ee-instrument -mergereturn -loop-unroll -coro-cleanup -mldst-motion -insert-gcov-profiling -indvars -strip-nondebug -partially-inline-libcalls -strip-dead-prototypes -elim-avail-extern -globaldce -gvn-hoist -coro-elide -jump-threading -mergeicmps -instcombine -memcpyopt -rpo-functionattrs -loop-load-elim -globalopt -reassociate -gvn-hoist -argpromotion -newgvn -sink -alignment-from-assumptions -lowerinvoke -sancov -adce -pgo-memop-opt -loop-data-prefetch -ee-instrument -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9962686567164181,3601.807757139206,opt -constmerge -sancov -lowerswitch -consthoist -load-store-vectorizer -break-crit-edges -loop-versioning -ipsccp -loweratomic -slsr -ipsccp -lcssa -gvn-hoist -loop-predication -partially-inline-libcalls -rpo-functionattrs -correlated-propagation -loop-predication -globalsplit -inject-tli-mappings -loop-interchange -inferattrs -coro-early -name-anon-globals -sroa -lowerinvoke -deadargelim -sccp -canonicalize-aliases -lowerswitch -loop-unroll -canonicalize-aliases -constprop -partial-inliner -loop-simplify -loop-interchange -coro-cleanup -gvn-hoist -break-crit-edges -loop-unroll -loop-unswitch -lower-constant-intrinsics -guard-widening -sroa -always-inline -separate-const-offset-from-gep -loop-deletion -elim-avail-extern -ipsccp -scalarizer -strip-debug-declare -slp-vectorizer -slp-vectorizer -prune-eh -lower-constant-intrinsics -flattencfg -jump-threading -globaldce -slsr -coro-elide -consthoist -prune-eh -loop-sink -scalarizer -tailcallelim -instnamer -ipconstprop -loop-deletion -inject-tli-mappings -pgo-memop-opt -loop-reroll -guard-widening -speculative-execution -simple-loop-unswitch -loop-unroll -early-cse-memssa -jump-threading -loop-data-prefetch -redundant-dbg-inst-elim -sroa -mem2reg -loop-data-prefetch -flattencfg -lower-constant-intrinsics -simplifycfg -strip-debug-declare -always-inline -gvn-hoist -jump-threading -deadargelim -simplifycfg -jump-threading -loop-predication -load-store-vectorizer -instnamer -gvn -flattencfg -loop-interchange -indvars -gvn -cross-dso-cfi -gvn-hoist -die -newgvn -loop-unswitch -gvn -sccp -always-inline -alignment-from-assumptions -argpromotion -pgo-memop-opt -inferattrs -infer-address-spaces -redundant-dbg-inst-elim -partial-inliner -gvn-hoist -loop-fusion -partially-inline-libcalls -lowerswitch -instcombine -guard-widening -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/susan,1.0552853852060406,3603.660972595215,opt -break-crit-edges -lowerinvoke -reg2mem -bdce -loop-predication -newgvn -constprop -loop-interchange -load-store-vectorizer -globalopt -inferattrs -deadargelim -loop-versioning -inline -aggressive-instcombine -gvn -instcombine -strip-nondebug -loop-sink -partially-inline-libcalls -mergefunc -forceattrs -mldst-motion -irce -speculative-execution -strip-debug-declare -bdce -loop-unroll-and-jam -simple-loop-unswitch -inject-tli-mappings -slsr -loop-distribute -lower-guard-intrinsic -lower-widenable-condition -loop-reroll -coro-cleanup -sccp -gvn-hoist -functionattrs -adce -adce -inferattrs -instcombine -strip-debug-declare -scalarizer -sccp -newgvn -mergeicmps -mergeicmps -consthoist -dce -name-anon-globals -gvn -separate-const-offset-from-gep -simplifycfg -loop-instsimplify -name-anon-globals -mem2reg -redundant-dbg-inst-elim -rewrite-statepoints-for-gc -coro-elide -coro-cleanup -consthoist -early-cse-memssa -loop-idiom -constprop -adce -guard-widening -reg2mem -lower-guard-intrinsic -globaldce -gvn -globalsplit -float2int -mergeicmps -coro-elide -loop-guard-widening -functionattrs -constprop -slp-vectorizer -simple-loop-unswitch -loop-sink -mldst-motion -loop-predication -instcombine -callsite-splitting -loop-data-prefetch -sccp -alignment-from-assumptions -cross-dso-cfi -instnamer -inferattrs -mldst-motion -guard-widening -loop-simplify -loop-data-prefetch -die -constprop -strip -sccp -slsr -newgvn -sroa -loop-simplifycfg -loop-instsimplify -elim-avail-extern -mergefunc -loop-interchange -div-rem-pairs -loop-interchange -mergereturn -lower-guard-intrinsic -libcalls-shrinkwrap -nary-reassociate -lower-matrix-intrinsics -aggressive-instcombine -ee-instrument -globaldce -prune-eh -jump-threading -mergereturn -functionattrs -lower-matrix-intrinsics -correlated-propagation -separate-const-offset-from-gep -div-rem-pairs -hotcoldsplit -loop-data-prefetch -mergereturn -insert-gcov-profiling -die -instsimplify -lower-matrix-intrinsics -partially-inline-libcalls -prune-eh -canonicalize-aliases -strip-debug-declare -strip-dead-prototypes -always-inline -strip -jump-threading -coro-split -inferattrs -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.0392564203588952,3631.8315482139587,opt -deadargelim -loop-reduce -loop-interchange -always-inline -ipconstprop -ipsccp -break-crit-edges -cross-dso-cfi -bdce -elim-avail-extern -loop-vectorize -ee-instrument -load-store-vectorizer -consthoist -lowerinvoke -loop-load-elim -nary-reassociate -coro-cleanup -prune-eh -insert-gcov-profiling -ee-instrument -lower-expect -mem2reg -partial-inliner -globalsplit -loop-unroll-and-jam -loop-load-elim -ipconstprop -flattencfg -loop-vectorize -pgo-memop-opt -add-discriminators -lower-matrix-intrinsics -lower-widenable-condition -redundant-dbg-inst-elim -reassociate -ee-instrument -newgvn -loop-data-prefetch -add-discriminators -attributor -slp-vectorizer -lcssa -partial-inliner -rpo-functionattrs -coro-cleanup -mergefunc -separate-const-offset-from-gep -elim-avail-extern -speculative-execution -instcombine -mergeicmps -newgvn -simplifycfg -argpromotion -mldst-motion -lower-constant-intrinsics -irce -loop-simplify -reassociate -redundant-dbg-inst-elim -loop-idiom -guard-widening -indvars -functionattrs -slsr -partially-inline-libcalls -sancov -instcombine -argpromotion -strip-debug-declare -instsimplify -loop-sink -gvn-hoist -globaldce -newgvn -always-inline -speculative-execution -bdce -functionattrs -loop-sink -rewrite-statepoints-for-gc -mergefunc -early-cse-memssa -loop-predication -licm -sccp -alignment-from-assumptions -early-cse-memssa -loop-predication -sccp -name-anon-globals -loop-versioning -ee-instrument -scalarizer -infer-address-spaces -reg2mem -cross-dso-cfi -loop-versioning-licm -sroa -tailcallelim -coro-cleanup -instcombine -loop-data-prefetch -loop-deletion -ipsccp -lcssa -sink -inferattrs -bdce -slp-vectorizer -dse -lowerinvoke -slp-vectorizer -functionattrs -elim-avail-extern -strip-dead-prototypes -loop-guard-widening -gvn -die -add-discriminators -rpo-functionattrs -insert-gcov-profiling -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.0389200057446502,3612.9188113212585,opt -loop-interchange -strip -deadargelim -nary-reassociate -early-cse-memssa -mem2reg -dse -div-rem-pairs -loop-reroll -sancov -constmerge -loop-unroll -loweratomic -loop-simplifycfg -guard-widening -gvn-hoist -instsimplify -loop-instsimplify -mergeicmps -pgo-memop-opt -jump-threading -constmerge -coro-split -licm -loop-unroll -newgvn -gvn-hoist -add-discriminators -indvars -jump-threading -globalsplit -lowerinvoke -loop-sink -loop-unroll-and-jam -called-value-propagation -instcombine -float2int -loop-load-elim -load-store-vectorizer -div-rem-pairs -separate-const-offset-from-gep -loop-unroll-and-jam -mldst-motion -coro-early -cross-dso-cfi -lower-widenable-condition -reassociate -lower-expect -callsite-splitting -loop-instsimplify -dse -newgvn -slsr -mergeicmps -sccp -mldst-motion -dce -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.0374855824682814,3850.3293058872223,opt -strip-nondebug -rpo-functionattrs -loop-unroll-and-jam -strip-nondebug -coro-elide -inferattrs -loop-instsimplify -bdce -irce -loop-simplifycfg -memcpyopt -hotcoldsplit -indvars -deadargelim -loop-unswitch -simplifycfg -loop-simplify -correlated-propagation -loop-simplify -coro-elide -strip-debug-declare -separate-const-offset-from-gep -jump-threading -callsite-splitting -canonicalize-aliases -mergereturn -ipconstprop -argpromotion -libcalls-shrinkwrap -deadargelim -cross-dso-cfi -canonicalize-aliases -mem2reg -correlated-propagation -adce -simplifycfg -slp-vectorizer -gvn-hoist -cross-dso-cfi -scalarizer -hotcoldsplit -insert-gcov-profiling -gvn -pgo-memop-opt -loop-idiom -rpo-functionattrs -memcpyopt -float2int -barrier -constmerge -consthoist -div-rem-pairs -adce -loop-sink -licm -loop-instsimplify -instcombine -loop-predication -loop-unroll-and-jam -coro-early -nary-reassociate -irce -scalarizer -constmerge -slp-vectorizer -loop-simplifycfg -callsite-splitting -loop-sink -loop-unroll -post-inline-ee-instrument -coro-elide -strip -lower-matrix-intrinsics -mergeicmps -argpromotion -lower-expect -mergefunc -lower-guard-intrinsic -inferattrs -break-crit-edges -sancov -coro-split -simplifycfg -hotcoldsplit -inject-tli-mappings -constprop -inferattrs -mergeicmps -loop-guard-widening -loop-versioning -argpromotion -memcpyopt -libcalls-shrinkwrap -strip-nondebug -gvn-hoist -lower-expect -loop-distribute -globalsplit -sink -nary-reassociate -name-anon-globals -coro-cleanup -always-inline -jump-threading -loop-unroll -loop-unroll-and-jam -globaldce -strip-nondebug -alignment-from-assumptions -simplifycfg -coro-cleanup -guard-widening -lower-widenable-condition -lower-widenable-condition -lcssa -coro-elide -strip-dead-prototypes -ipconstprop -elim-avail-extern -gvn input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.035927734708514,3610.76429438591,opt -mldst-motion -loop-data-prefetch -lower-expect -separate-const-offset-from-gep -rewrite-statepoints-for-gc -loop-simplifycfg -deadargelim -dce -ee-instrument -coro-elide -mem2reg -inferattrs -speculative-execution -loop-simplify -early-cse-memssa -rewrite-statepoints-for-gc -loop-unroll -newgvn -instcombine -prune-eh -dse -gvn-hoist -instsimplify -cross-dso-cfi -coro-cleanup -globaldce -newgvn -flattencfg -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/adpcm,1.0083798882681565,3601.6958680152893,opt -loop-deletion -nary-reassociate -alignment-from-assumptions -add-discriminators -loop-idiom -mem2reg -scalarizer -ee-instrument -globalopt -partial-inliner -loop-reroll -reassociate -loop-data-prefetch -strip -globalopt -float2int -add-discriminators -deadargelim -inject-tli-mappings -guard-widening -sroa -insert-gcov-profiling -loop-unroll-and-jam -alignment-from-assumptions -deadargelim -loop-deletion -prune-eh -constprop -infer-address-spaces -loop-simplify -loop-interchange -correlated-propagation -attributor -memcpyopt -div-rem-pairs -loop-interchange -ee-instrument -elim-avail-extern -dse -div-rem-pairs -prune-eh -argpromotion -libcalls-shrinkwrap -mergeicmps -infer-address-spaces -loop-distribute -globalopt -loop-sink -correlated-propagation -loop-versioning-licm -lower-matrix-intrinsics -constmerge -forceattrs -alignment-from-assumptions -jump-threading -inferattrs -called-value-propagation -mergeicmps -load-store-vectorizer -simplifycfg -strip-dead-prototypes -add-discriminators -mergeicmps -memcpyopt -strip -lower-expect -loop-reroll -loop-load-elim -instcombine -attributor -loop-reroll -inline -mergereturn -globalopt -div-rem-pairs -partial-inliner -inferattrs -adce -mergefunc -mldst-motion -coro-split -loop-reduce -deadargelim -reassociate -adce -lower-expect -always-inline -mergefunc -instsimplify -attributor -slp-vectorizer -speculative-execution -constmerge -consthoist -barrier -strip-dead-prototypes -gvn-hoist -early-cse-memssa -inferattrs -coro-split -flattencfg -newgvn -coro-elide -reassociate -separate-const-offset-from-gep -loop-idiom -constprop -functionattrs -jump-threading -insert-gcov-profiling -simplifycfg -sancov -dse -instcombine input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0154867256637168,3601.5673730373383,opt -loop-instsimplify -inferattrs -indvars -tailcallelim -adce -lower-expect -loop-guard-widening -hotcoldsplit -loop-versioning -memcpyopt -loop-instsimplify -loop-load-elim -sink -canonicalize-aliases -float2int -barrier -reg2mem -always-inline -div-rem-pairs -loop-data-prefetch -attributor -loop-idiom -alignment-from-assumptions -globalsplit -scalarizer -div-rem-pairs -add-discriminators -strip -flattencfg -elim-avail-extern -strip-dead-prototypes -reassociate -lower-guard-intrinsic -separate-const-offset-from-gep -div-rem-pairs -lowerswitch -sroa -elim-avail-extern -indvars -adce -irce -lower-guard-intrinsic -ipconstprop -called-value-propagation -strip-debug-declare -gvn-hoist -lowerinvoke -mergereturn -lower-expect -reassociate -barrier -ipconstprop -libcalls-shrinkwrap -early-cse-memssa -infer-address-spaces -globalopt -simple-loop-unswitch -partially-inline-libcalls -tailcallelim -loop-fusion -simplifycfg -mergefunc -loop-unroll-and-jam -separate-const-offset-from-gep -infer-address-spaces -loop-data-prefetch -ipsccp -deadargelim -indvars -jump-threading -loop-reduce -licm -loop-reduce -instcombine -flattencfg -inject-tli-mappings -constmerge -add-discriminators -alignment-from-assumptions -ee-instrument -speculative-execution -loop-interchange -mldst-motion -instnamer -mem2reg -argpromotion -memcpyopt -pgo-memop-opt -early-cse-memssa -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0814249363867694,3601.9053058624268,opt -licm -sroa -post-inline-ee-instrument -float2int -instsimplify -pgo-memop-opt -dce -early-cse-memssa -inferattrs -strip-nondebug -flattencfg -loop-interchange -float2int -add-discriminators -loop-vectorize -aggressive-instcombine -prune-eh -gvn-hoist -loop-predication -irce -instcombine -globalsplit -pgo-memop-opt -lcssa -loop-guard-widening -mldst-motion -loop-simplifycfg -hotcoldsplit -loop-vectorize -forceattrs -rewrite-statepoints-for-gc -coro-elide -forceattrs -deadargelim -infer-address-spaces -float2int -deadargelim -coro-early -libcalls-shrinkwrap -loop-fusion -prune-eh -aggressive-instcombine -coro-early -loop-load-elim -elim-avail-extern -flattencfg -ipconstprop -lower-matrix-intrinsics -aggressive-instcombine -strip -memcpyopt -lcssa -irce -scalarizer -lcssa -add-discriminators -coro-cleanup -coro-elide -sink -tailcallelim -barrier -lower-guard-intrinsic -bdce -deadargelim -load-store-vectorizer -die -reassociate -post-inline-ee-instrument -attributor -simple-loop-unswitch -loop-guard-widening -canonicalize-aliases -sink -pgo-memop-opt -bdce -ee-instrument -tailcallelim -loop-versioning -alignment-from-assumptions -instsimplify -simplifycfg -add-discriminators -pgo-memop-opt -dce -loop-simplifycfg -inject-tli-mappings -licm -strip-dead-prototypes -irce -globaldce -pgo-memop-opt -lower-widenable-condition -alignment-from-assumptions -globaldce -slp-vectorizer -globaldce -alignment-from-assumptions -loop-sink -barrier -instcombine -correlated-propagation -ipsccp -loop-instsimplify -sccp -alignment-from-assumptions -partial-inliner -forceattrs -loop-distribute -loop-interchange -separate-const-offset-from-gep -newgvn -loop-instsimplify -globaldce -indvars -deadargelim -instsimplify -redundant-dbg-inst-elim -loop-idiom -licm -loop-unroll-and-jam -hotcoldsplit -mergereturn -partially-inline-libcalls -div-rem-pairs -sink -strip-debug-declare -infer-address-spaces -instnamer -inline -gvn -functionattrs -nary-reassociate -loop-reroll -barrier -prune-eh -loop-unroll-and-jam -functionattrs -post-inline-ee-instrument -partial-inliner -simple-loop-unswitch -mergefunc -rewrite-statepoints-for-gc -loop-distribute -instnamer -memcpyopt -loop-load-elim -strip-debug-declare -ee-instrument -insert-gcov-profiling -ee-instrument -sink -simplifycfg -memcpyopt -die -deadargelim -newgvn -loop-idiom -lowerinvoke -scalarizer -loop-simplifycfg -early-cse-memssa -partial-inliner -globalsplit -lower-matrix-intrinsics -loop-data-prefetch -coro-cleanup -nary-reassociate -dce -forceattrs -always-inline -strip-nondebug -lower-expect -callsite-splitting -prune-eh -bdce -loop-versioning-licm -always-inline -post-inline-ee-instrument -insert-gcov-profiling -loop-data-prefetch -sancov -loop-guard-widening -alignment-from-assumptions -functionattrs -sroa -strip-nondebug -consthoist -jump-threading -guard-widening -consthoist -speculative-execution -die -reassociate -forceattrs -adce -loop-data-prefetch -float2int -forceattrs -loop-distribute -bdce -loop-load-elim -indvars -sancov -slp-vectorizer -tailcallelim -lower-guard-intrinsic -irce -float2int -consthoist -strip-debug-declare -sancov -loop-simplify -memcpyopt -loop-simplify -guard-widening -ipconstprop -coro-cleanup -hotcoldsplit -strip-debug-declare -instcombine -dse -strip-debug-declare -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.1955944383690047,3768.8419275283813,opt -consthoist -jump-threading -hotcoldsplit -dce -correlated-propagation -partially-inline-libcalls -coro-split -adce -loop-instsimplify -loop-versioning -globalsplit -mergereturn -guard-widening -dse -ee-instrument -aggressive-instcombine -simplifycfg -coro-cleanup -early-cse-memssa -sroa -inject-tli-mappings -rpo-functionattrs -simplifycfg -loop-interchange -loop-distribute -sccp -name-anon-globals -loop-idiom -loop-predication -name-anon-globals -sink -barrier -functionattrs -loop-idiom -newgvn -mem2reg -mergeicmps -licm -loop-versioning -loop-versioning -loop-versioning-licm -constmerge -die -ee-instrument -loop-versioning-licm -mergefunc -jump-threading -instcombine -name-anon-globals -forceattrs -nary-reassociate -deadargelim -sink -gvn -pgo-memop-opt -inject-tli-mappings -loop-deletion -strip-debug-declare -jump-threading -div-rem-pairs -gvn input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,3601.8237340450287,opt -gvn -instcombine -constprop -slsr -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.9948979591836737,3601.5456669330597,opt -loop-vectorize -scalarizer -loop-unswitch -canonicalize-aliases -instnamer -dce -early-cse-memssa -prune-eh -loop-reduce -post-inline-ee-instrument -loop-unroll -ipconstprop -reg2mem -mem2reg -ee-instrument -globalsplit -simplifycfg -div-rem-pairs -always-inline -simplifycfg -newgvn -early-cse-memssa -lowerswitch -inferattrs -scalarizer -sancov -loop-interchange -reassociate -dse -libcalls-shrinkwrap -sccp -loop-sink -globaldce -loop-deletion -functionattrs -licm -adce -simple-loop-unswitch -rewrite-statepoints-for-gc -mergefunc -post-inline-ee-instrument -coro-split -argpromotion -load-store-vectorizer -lower-matrix-intrinsics -early-cse-memssa -sroa -called-value-propagation -sancov -canonicalize-aliases -reassociate -elim-avail-extern -jump-threading -gvn-hoist -loop-vectorize -loop-data-prefetch -callsite-splitting -loop-sink -irce -attributor -load-store-vectorizer -coro-elide -gvn-hoist -elim-avail-extern -deadargelim -coro-early -callsite-splitting -loop-vectorize -load-store-vectorizer -loop-idiom -instcombine -elim-avail-extern -post-inline-ee-instrument -callsite-splitting -jump-threading -elim-avail-extern -insert-gcov-profiling -partially-inline-libcalls -slp-vectorizer -float2int -inferattrs -reassociate -slsr -prune-eh -tailcallelim -canonicalize-aliases -ipconstprop -indvars -redundant-dbg-inst-elim -prune-eh -lower-matrix-intrinsics -loop-vectorize -coro-elide -strip-debug-declare -canonicalize-aliases -coro-elide -adce -lower-expect -mergereturn -instsimplify -infer-address-spaces -mergeicmps -lower-guard-intrinsic -lower-constant-intrinsics -redundant-dbg-inst-elim -barrier -mldst-motion -loop-distribute -guard-widening -loop-simplifycfg -lower-expect -lowerswitch -dce -jump-threading -lowerinvoke -tailcallelim -lower-widenable-condition -coro-split -cross-dso-cfi -reg2mem -loop-reroll -sroa -loop-simplifycfg -partially-inline-libcalls -slp-vectorizer -dce -break-crit-edges -loop-instsimplify -correlated-propagation -insert-gcov-profiling -early-cse-memssa -loop-unroll-and-jam -tailcallelim -jump-threading -infer-address-spaces -coro-early -pgo-memop-opt -pgo-memop-opt -canonicalize-aliases -irce -loop-idiom -rpo-functionattrs -loop-unroll-and-jam -instcombine -redundant-dbg-inst-elim -loop-vectorize -speculative-execution -simplifycfg -sccp -partially-inline-libcalls -correlated-propagation input.bc -o output.bc +benchmark://cbench-v1/ghostscript,1.0082655103985454,3718.0952739715576,opt -name-anon-globals -coro-cleanup -forceattrs -argpromotion -coro-elide -slp-vectorizer -scalarizer -inject-tli-mappings -loop-deletion -elim-avail-extern -partially-inline-libcalls -loop-fusion -infer-address-spaces -sroa -mergefunc -reg2mem -sroa -irce -lcssa -float2int -loop-simplifycfg -dse -adce -float2int -argpromotion -sroa -loop-idiom -reassociate -lower-guard-intrinsic -loop-distribute -lowerinvoke -break-crit-edges -lower-guard-intrinsic -memcpyopt -gvn-hoist -loop-sink -attributor -jump-threading -loop-unroll-and-jam -attributor -irce -flattencfg -indvars -instsimplify -ipsccp -loop-guard-widening -slp-vectorizer -lower-expect -guard-widening -loop-instsimplify -inject-tli-mappings -slsr -coro-elide -strip-dead-prototypes -ipsccp -mldst-motion -nary-reassociate -alignment-from-assumptions -callsite-splitting -lowerinvoke -rewrite-statepoints-for-gc -argpromotion -consthoist -coro-cleanup -early-cse-memssa -redundant-dbg-inst-elim -loop-versioning-licm -loop-deletion -deadargelim -coro-elide -lower-guard-intrinsic -inject-tli-mappings -strip -always-inline -instcombine -ee-instrument -globalsplit -float2int -canonicalize-aliases -coro-cleanup -barrier -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/gsm,1.086030876494024,3625.1922268867493,opt -instnamer -post-inline-ee-instrument -sroa -loop-guard-widening -ipconstprop -newgvn -loop-versioning -flattencfg -functionattrs -barrier -insert-gcov-profiling -loop-guard-widening -barrier -inferattrs -pgo-memop-opt -mldst-motion -loop-vectorize -mergefunc -libcalls-shrinkwrap -loop-fusion -canonicalize-aliases -irce -attributor -barrier -dce -instcombine -adce -simplifycfg -instsimplify -consthoist -instcombine -loop-distribute -loop-data-prefetch -inject-tli-mappings -strip-nondebug -ipconstprop -mldst-motion -load-store-vectorizer -instcombine -mergefunc -inject-tli-mappings -loop-deletion -called-value-propagation -libcalls-shrinkwrap -die -indvars -globalsplit -alignment-from-assumptions -jump-threading -loweratomic -loop-guard-widening -loop-unswitch -loop-deletion -lowerinvoke -slsr -rpo-functionattrs -alignment-from-assumptions -strip-debug-declare -constmerge -strip-dead-prototypes -adce -always-inline -prune-eh -dce -ee-instrument -slsr -loop-data-prefetch -post-inline-ee-instrument -loop-distribute -jump-threading -rpo-functionattrs -loop-simplify -consthoist -separate-const-offset-from-gep -licm -aggressive-instcombine -adce -slp-vectorizer -indvars -loop-fusion -attributor -indvars -gvn -redundant-dbg-inst-elim -globalopt -loop-simplify -insert-gcov-profiling -forceattrs -loop-load-elim -canonicalize-aliases -inject-tli-mappings -mldst-motion -mergereturn -sink -lower-widenable-condition -load-store-vectorizer -early-cse-memssa -attributor -newgvn -redundant-dbg-inst-elim -lower-constant-intrinsics -die -mergefunc -globaldce -strip-debug-declare -ipsccp -float2int -rewrite-statepoints-for-gc -ipconstprop -instcombine input.bc -o output.bc +benchmark://cbench-v1/ispell,1.0108374384236454,3604.3012421131134,opt -loop-idiom -loop-unroll -sancov -loop-versioning -infer-address-spaces -early-cse-memssa -sccp -called-value-propagation -lcssa -separate-const-offset-from-gep -constmerge -newgvn -constprop -forceattrs -coro-split -globalopt -partially-inline-libcalls -lower-constant-intrinsics -ipsccp -redundant-dbg-inst-elim -barrier -constprop -hotcoldsplit -adce -prune-eh -strip-nondebug -constmerge -constprop -globalopt -gvn-hoist -loop-guard-widening -instsimplify -loop-interchange -break-crit-edges -loop-simplifycfg -irce -loop-deletion -lower-widenable-condition -rpo-functionattrs -functionattrs -guard-widening -strip-debug-declare -loop-sink -flattencfg -inject-tli-mappings -adce -argpromotion -loop-interchange -lower-constant-intrinsics -sccp -loop-reduce -mem2reg -simplifycfg -loop-data-prefetch -indvars -mem2reg -nary-reassociate -canonicalize-aliases -partially-inline-libcalls -loop-instsimplify -irce -hotcoldsplit -loop-simplify -always-inline -attributor -globalopt -lowerinvoke -rpo-functionattrs -loop-interchange -slsr -flattencfg -coro-early -deadargelim -instcombine -loop-data-prefetch -lower-constant-intrinsics -always-inline -add-discriminators -nary-reassociate -coro-early -memcpyopt -coro-split -div-rem-pairs -loop-vectorize -coro-early -loop-unroll -mldst-motion -functionattrs -mergereturn -simplifycfg -cross-dso-cfi -slsr -ipconstprop -loweratomic -canonicalize-aliases -globalopt -correlated-propagation -irce -break-crit-edges -lower-expect -bdce -redundant-dbg-inst-elim -bdce -pgo-memop-opt -globalsplit -loop-unroll-and-jam -instcombine -early-cse-memssa -cross-dso-cfi -mem2reg -globalsplit -loop-simplifycfg -correlated-propagation -mergeicmps -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0321790619090427,3613.718739748001,opt -newgvn -insert-gcov-profiling -canonicalize-aliases -die -consthoist -scalarizer -consthoist -coro-early -loop-simplifycfg -always-inline -loop-unroll-and-jam -sroa -die -lowerinvoke -sink -loop-predication -reg2mem -scalarizer -lcssa -early-cse-memssa -inject-tli-mappings -constprop -always-inline -reg2mem -loop-fusion -speculative-execution -insert-gcov-profiling -prune-eh -loop-data-prefetch -newgvn -canonicalize-aliases -loop-vectorize -loop-simplifycfg -argpromotion -constmerge -prune-eh -rpo-functionattrs -loop-reduce -strip-dead-prototypes -loop-unroll-and-jam -loop-distribute -always-inline -loop-versioning -loop-simplify -partially-inline-libcalls -loop-data-prefetch -aggressive-instcombine -loop-simplify -dce -ipsccp -mem2reg -ipconstprop -memcpyopt -loop-interchange -loop-load-elim -mergeicmps -inject-tli-mappings -alignment-from-assumptions -insert-gcov-profiling -loop-fusion -partial-inliner -early-cse-memssa -elim-avail-extern -insert-gcov-profiling -rpo-functionattrs -separate-const-offset-from-gep -inject-tli-mappings -deadargelim -consthoist -loop-interchange -instcombine -nary-reassociate -licm -libcalls-shrinkwrap -simplifycfg -partially-inline-libcalls -infer-address-spaces -forceattrs -slp-vectorizer -die -mldst-motion -instsimplify -sccp -newgvn -infer-address-spaces -simple-loop-unswitch -dce -nary-reassociate -loop-distribute -callsite-splitting -loop-sink -loop-fusion -mergefunc -gvn -canonicalize-aliases -jump-threading -loop-versioning -newgvn -loop-sink -float2int -gvn -strip-debug-declare -inferattrs -simplifycfg -prune-eh -nary-reassociate -loop-versioning -consthoist -dce input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0331948871502625,3639.5563414096832,opt -constmerge -loop-distribute -sink -separate-const-offset-from-gep -loop-idiom -loop-unroll-and-jam -load-store-vectorizer -aggressive-instcombine -load-store-vectorizer -licm -slp-vectorizer -flattencfg -loweratomic -licm -elim-avail-extern -elim-avail-extern -redundant-dbg-inst-elim -irce -partially-inline-libcalls -deadargelim -loop-idiom -memcpyopt -loop-vectorize -consthoist -coro-cleanup -loop-idiom -jump-threading -cross-dso-cfi -loop-reroll -separate-const-offset-from-gep -loop-load-elim -lower-constant-intrinsics -mem2reg -mergefunc -argpromotion -float2int -inject-tli-mappings -newgvn -scalarizer -pgo-memop-opt -lower-matrix-intrinsics -adce -indvars -sccp -globaldce -simplifycfg -globalsplit -lower-widenable-condition -lower-constant-intrinsics -slsr -dce -instcombine -called-value-propagation -jump-threading -loop-versioning -loop-versioning -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/lame,1.053404691414257,3609.5372927188873,opt -irce -lcssa -forceattrs -reg2mem -partially-inline-libcalls -consthoist -scalarizer -sancov -strip-dead-prototypes -sroa -loop-instsimplify -coro-cleanup -loop-distribute -pgo-memop-opt -separate-const-offset-from-gep -rpo-functionattrs -rewrite-statepoints-for-gc -instsimplify -loop-simplify -sancov -loop-deletion -lower-constant-intrinsics -loop-simplifycfg -loop-distribute -early-cse-memssa -simplifycfg -loop-simplify -loop-unswitch -loop-simplifycfg -coro-elide -instcombine -sancov -insert-gcov-profiling -coro-early -argpromotion -constmerge -reassociate -insert-gcov-profiling -slsr -gvn-hoist -sroa -bdce -loop-guard-widening -jump-threading -inject-tli-mappings -dse -loop-interchange -float2int -called-value-propagation -break-crit-edges -partially-inline-libcalls -newgvn -correlated-propagation -sroa -mem2reg -canonicalize-aliases -always-inline -loop-interchange -div-rem-pairs -adce -elim-avail-extern -licm -lcssa -forceattrs -inject-tli-mappings -always-inline -coro-cleanup -lower-widenable-condition -loop-simplifycfg -mem2reg -loop-simplifycfg -lower-guard-intrinsic -lcssa -always-inline -loop-versioning -alignment-from-assumptions -slp-vectorizer -instnamer -loop-versioning -simplifycfg -lower-constant-intrinsics -gvn -nary-reassociate -hotcoldsplit -inferattrs -instnamer -strip-debug-declare -aggressive-instcombine -div-rem-pairs -partially-inline-libcalls -loop-instsimplify -flattencfg -slp-vectorizer -instsimplify -loop-simplify -constprop -gvn-hoist -mem2reg -sancov -forceattrs -post-inline-ee-instrument -speculative-execution -indvars -gvn -lcssa -prune-eh -simplifycfg -loop-unroll-and-jam -instsimplify -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/patricia,1.0055617352614012,3602.584586620331,opt -irce -simplifycfg -loweratomic -adce -attributor -called-value-propagation -load-store-vectorizer -correlated-propagation -callsite-splitting -name-anon-globals -hotcoldsplit -loop-simplifycfg -lowerswitch -load-store-vectorizer -prune-eh -prune-eh -loop-guard-widening -scalarizer -infer-address-spaces -add-discriminators -loop-fusion -lower-guard-intrinsic -memcpyopt -coro-early -globalsplit -lowerswitch -functionattrs -functionattrs -name-anon-globals -functionattrs -coro-early -loop-distribute -lower-guard-intrinsic -consthoist -barrier -consthoist -loop-simplifycfg -callsite-splitting -reassociate -licm -coro-split -loop-versioning-licm -inject-tli-mappings -loop-vectorize -loop-sink -correlated-propagation -add-discriminators -lower-matrix-intrinsics -loop-fusion -deadargelim -loop-simplifycfg -loop-versioning-licm -licm -pgo-memop-opt -inferattrs -sroa -loop-simplify -alignment-from-assumptions -mem2reg -instsimplify -loop-simplify -lower-expect -separate-const-offset-from-gep -slp-vectorizer -lower-matrix-intrinsics -strip -inject-tli-mappings -inferattrs -inferattrs -rewrite-statepoints-for-gc -sancov -globalsplit -deadargelim -instcombine -licm -callsite-splitting -lowerinvoke -canonicalize-aliases -mergefunc -ee-instrument -die -indvars -lower-guard-intrinsic -lower-widenable-condition -lower-expect -inferattrs -loop-simplifycfg -scalarizer -mldst-motion -consthoist -insert-gcov-profiling -loop-load-elim -ee-instrument -mergereturn -gvn -loop-fusion -separate-const-offset-from-gep -lowerswitch -forceattrs -elim-avail-extern -callsite-splitting -loop-predication -loop-guard-widening -instcombine -simplifycfg -correlated-propagation -reassociate input.bc -o output.bc +benchmark://cbench-v1/qsort,1.1331269349845199,3601.513120651245,opt -callsite-splitting -simple-loop-unswitch -lowerswitch -loop-data-prefetch -licm -speculative-execution -guard-widening -argpromotion -loop-instsimplify -reassociate -gvn -sink -globalsplit -load-store-vectorizer -redundant-dbg-inst-elim -separate-const-offset-from-gep -forceattrs -strip-debug-declare -called-value-propagation -mldst-motion -loop-load-elim -mergefunc -elim-avail-extern -ipconstprop -loop-reroll -lowerswitch -reg2mem -sccp -hotcoldsplit -constmerge -globaldce -guard-widening -scalarizer -lowerswitch -dce -loop-unroll -constmerge -reg2mem -separate-const-offset-from-gep -lower-constant-intrinsics -dce -argpromotion -break-crit-edges -lower-guard-intrinsic -insert-gcov-profiling -loop-data-prefetch -mldst-motion -redundant-dbg-inst-elim -deadargelim -always-inline -instsimplify -inline -licm -loop-simplifycfg -bdce -dce -aggressive-instcombine -loop-idiom -newgvn -gvn -rpo-functionattrs -sroa -sancov -die -post-inline-ee-instrument -loop-reroll -loop-instsimplify -bdce -loop-interchange -separate-const-offset-from-gep -rpo-functionattrs -rpo-functionattrs -consthoist -insert-gcov-profiling -loop-idiom -strip-dead-prototypes -instcombine -pgo-memop-opt -nary-reassociate -mem2reg -mergereturn -inferattrs -sink -correlated-propagation -ipconstprop -coro-cleanup -simplifycfg -float2int -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1054043694902262,3602.2013919353485,opt -reassociate -mergefunc -mem2reg -bdce -newgvn -coro-elide -mergereturn -break-crit-edges -strip-nondebug -loop-reroll -functionattrs -sccp -correlated-propagation -strip-dead-prototypes -globaldce -loop-instsimplify -strip-nondebug -simplifycfg -instcombine -early-cse-memssa -sink -argpromotion -lower-expect -partially-inline-libcalls -reassociate -memcpyopt -adce -sroa -deadargelim -loop-data-prefetch -lower-widenable-condition -dce -hotcoldsplit -mergefunc -mergereturn -rewrite-statepoints-for-gc -separate-const-offset-from-gep -jump-threading input.bc -o output.bc +benchmark://cbench-v1/sha,1.5183946488294313,3601.795018196106,opt -break-crit-edges -simplifycfg -barrier -newgvn -lcssa -canonicalize-aliases -gvn -scalarizer -nary-reassociate -float2int -loop-vectorize -loop-interchange -loop-unroll -jump-threading -loop-unroll-and-jam -lower-guard-intrinsic -instcombine -loop-deletion -reassociate -loop-simplifycfg -constmerge -indvars -forceattrs -ipconstprop -lower-constant-intrinsics -loop-data-prefetch -globalopt -load-store-vectorizer -mldst-motion -slsr -insert-gcov-profiling -instcombine -instnamer -loop-predication -lower-matrix-intrinsics -coro-split -loop-reroll -loop-vectorize -elim-avail-extern -instnamer -partial-inliner -loop-rotate -adce -mergefunc -strip -sancov -pgo-memop-opt -mldst-motion -break-crit-edges -constmerge -prune-eh -loop-deletion -jump-threading -lower-constant-intrinsics -partial-inliner -coro-early -lowerinvoke -bdce -deadargelim -loop-simplifycfg -called-value-propagation -lower-widenable-condition -loop-deletion -sancov -sroa -instnamer -insert-gcov-profiling -loweratomic -slp-vectorizer -strip -nary-reassociate -loop-guard-widening -forceattrs -adce -loop-simplifycfg -separate-const-offset-from-gep -lower-expect -inferattrs -strip -simple-loop-unswitch -lower-guard-intrinsic -coro-elide -jump-threading -ipsccp -instcombine -break-crit-edges -slp-vectorizer -ipsccp -simplifycfg -name-anon-globals -partially-inline-libcalls -newgvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0163934426229506,3601.6986713409424,opt -indvars -deadargelim -sccp -bdce -loop-simplifycfg -lower-expect -coro-split -strip-debug-declare -early-cse-memssa -coro-elide -float2int -die -simplifycfg -break-crit-edges -strip-debug-declare -loop-simplifycfg -mem2reg -float2int -globalopt -instnamer -inferattrs -loop-distribute -break-crit-edges -post-inline-ee-instrument -strip -flattencfg -coro-early -irce -aggressive-instcombine -rpo-functionattrs -gvn-hoist -globalopt -instnamer -adce -coro-early -partial-inliner -loop-unroll-and-jam -sink -lower-constant-intrinsics -sink -flattencfg -correlated-propagation -lcssa -mldst-motion -tailcallelim -sccp -post-inline-ee-instrument -mergereturn -loop-unroll -coro-cleanup -mldst-motion -insert-gcov-profiling -indvars -strip-nondebug -partially-inline-libcalls -strip-dead-prototypes -elim-avail-extern -globaldce -gvn-hoist -coro-elide -jump-threading -mergeicmps -instcombine -memcpyopt -rpo-functionattrs -loop-load-elim -globalopt -reassociate -gvn-hoist -argpromotion -newgvn -sink -alignment-from-assumptions -lowerinvoke -sancov -adce -pgo-memop-opt -loop-data-prefetch -ee-instrument -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9962686567164181,3601.807757139206,opt -constmerge -sancov -lowerswitch -consthoist -load-store-vectorizer -break-crit-edges -loop-versioning -ipsccp -loweratomic -slsr -ipsccp -lcssa -gvn-hoist -loop-predication -partially-inline-libcalls -rpo-functionattrs -correlated-propagation -loop-predication -globalsplit -inject-tli-mappings -loop-interchange -inferattrs -coro-early -name-anon-globals -sroa -lowerinvoke -deadargelim -sccp -canonicalize-aliases -lowerswitch -loop-unroll -canonicalize-aliases -constprop -partial-inliner -loop-simplify -loop-interchange -coro-cleanup -gvn-hoist -break-crit-edges -loop-unroll -loop-unswitch -lower-constant-intrinsics -guard-widening -sroa -always-inline -separate-const-offset-from-gep -loop-deletion -elim-avail-extern -ipsccp -scalarizer -strip-debug-declare -slp-vectorizer -slp-vectorizer -prune-eh -lower-constant-intrinsics -flattencfg -jump-threading -globaldce -slsr -coro-elide -consthoist -prune-eh -loop-sink -scalarizer -tailcallelim -instnamer -ipconstprop -loop-deletion -inject-tli-mappings -pgo-memop-opt -loop-reroll -guard-widening -speculative-execution -simple-loop-unswitch -loop-unroll -early-cse-memssa -jump-threading -loop-data-prefetch -redundant-dbg-inst-elim -sroa -mem2reg -loop-data-prefetch -flattencfg -lower-constant-intrinsics -simplifycfg -strip-debug-declare -always-inline -gvn-hoist -jump-threading -deadargelim -simplifycfg -jump-threading -loop-predication -load-store-vectorizer -instnamer -gvn -flattencfg -loop-interchange -indvars -gvn -cross-dso-cfi -gvn-hoist -die -newgvn -loop-unswitch -gvn -sccp -always-inline -alignment-from-assumptions -argpromotion -pgo-memop-opt -inferattrs -infer-address-spaces -redundant-dbg-inst-elim -partial-inliner -gvn-hoist -loop-fusion -partially-inline-libcalls -lowerswitch -instcombine -guard-widening -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/susan,1.0552853852060406,3603.660972595215,opt -break-crit-edges -lowerinvoke -reg2mem -bdce -loop-predication -newgvn -constprop -loop-interchange -load-store-vectorizer -globalopt -inferattrs -deadargelim -loop-versioning -inline -aggressive-instcombine -gvn -instcombine -strip-nondebug -loop-sink -partially-inline-libcalls -mergefunc -forceattrs -mldst-motion -irce -speculative-execution -strip-debug-declare -bdce -loop-unroll-and-jam -simple-loop-unswitch -inject-tli-mappings -slsr -loop-distribute -lower-guard-intrinsic -lower-widenable-condition -loop-reroll -coro-cleanup -sccp -gvn-hoist -functionattrs -adce -adce -inferattrs -instcombine -strip-debug-declare -scalarizer -sccp -newgvn -mergeicmps -mergeicmps -consthoist -dce -name-anon-globals -gvn -separate-const-offset-from-gep -simplifycfg -loop-instsimplify -name-anon-globals -mem2reg -redundant-dbg-inst-elim -rewrite-statepoints-for-gc -coro-elide -coro-cleanup -consthoist -early-cse-memssa -loop-idiom -constprop -adce -guard-widening -reg2mem -lower-guard-intrinsic -globaldce -gvn -globalsplit -float2int -mergeicmps -coro-elide -loop-guard-widening -functionattrs -constprop -slp-vectorizer -simple-loop-unswitch -loop-sink -mldst-motion -loop-predication -instcombine -callsite-splitting -loop-data-prefetch -sccp -alignment-from-assumptions -cross-dso-cfi -instnamer -inferattrs -mldst-motion -guard-widening -loop-simplify -loop-data-prefetch -die -constprop -strip -sccp -slsr -newgvn -sroa -loop-simplifycfg -loop-instsimplify -elim-avail-extern -mergefunc -loop-interchange -div-rem-pairs -loop-interchange -mergereturn -lower-guard-intrinsic -libcalls-shrinkwrap -nary-reassociate -lower-matrix-intrinsics -aggressive-instcombine -ee-instrument -globaldce -prune-eh -jump-threading -mergereturn -functionattrs -lower-matrix-intrinsics -correlated-propagation -separate-const-offset-from-gep -div-rem-pairs -hotcoldsplit -loop-data-prefetch -mergereturn -insert-gcov-profiling -die -instsimplify -lower-matrix-intrinsics -partially-inline-libcalls -prune-eh -canonicalize-aliases -strip-debug-declare -strip-dead-prototypes -always-inline -strip -jump-threading -coro-split -inferattrs -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0392564203588952,3631.8315482139587,opt -deadargelim -loop-reduce -loop-interchange -always-inline -ipconstprop -ipsccp -break-crit-edges -cross-dso-cfi -bdce -elim-avail-extern -loop-vectorize -ee-instrument -load-store-vectorizer -consthoist -lowerinvoke -loop-load-elim -nary-reassociate -coro-cleanup -prune-eh -insert-gcov-profiling -ee-instrument -lower-expect -mem2reg -partial-inliner -globalsplit -loop-unroll-and-jam -loop-load-elim -ipconstprop -flattencfg -loop-vectorize -pgo-memop-opt -add-discriminators -lower-matrix-intrinsics -lower-widenable-condition -redundant-dbg-inst-elim -reassociate -ee-instrument -newgvn -loop-data-prefetch -add-discriminators -attributor -slp-vectorizer -lcssa -partial-inliner -rpo-functionattrs -coro-cleanup -mergefunc -separate-const-offset-from-gep -elim-avail-extern -speculative-execution -instcombine -mergeicmps -newgvn -simplifycfg -argpromotion -mldst-motion -lower-constant-intrinsics -irce -loop-simplify -reassociate -redundant-dbg-inst-elim -loop-idiom -guard-widening -indvars -functionattrs -slsr -partially-inline-libcalls -sancov -instcombine -argpromotion -strip-debug-declare -instsimplify -loop-sink -gvn-hoist -globaldce -newgvn -always-inline -speculative-execution -bdce -functionattrs -loop-sink -rewrite-statepoints-for-gc -mergefunc -early-cse-memssa -loop-predication -licm -sccp -alignment-from-assumptions -early-cse-memssa -loop-predication -sccp -name-anon-globals -loop-versioning -ee-instrument -scalarizer -infer-address-spaces -reg2mem -cross-dso-cfi -loop-versioning-licm -sroa -tailcallelim -coro-cleanup -instcombine -loop-data-prefetch -loop-deletion -ipsccp -lcssa -sink -inferattrs -bdce -slp-vectorizer -dse -lowerinvoke -slp-vectorizer -functionattrs -elim-avail-extern -strip-dead-prototypes -loop-guard-widening -gvn -die -add-discriminators -rpo-functionattrs -insert-gcov-profiling -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0389200057446502,3612.9188113212585,opt -loop-interchange -strip -deadargelim -nary-reassociate -early-cse-memssa -mem2reg -dse -div-rem-pairs -loop-reroll -sancov -constmerge -loop-unroll -loweratomic -loop-simplifycfg -guard-widening -gvn-hoist -instsimplify -loop-instsimplify -mergeicmps -pgo-memop-opt -jump-threading -constmerge -coro-split -licm -loop-unroll -newgvn -gvn-hoist -add-discriminators -indvars -jump-threading -globalsplit -lowerinvoke -loop-sink -loop-unroll-and-jam -called-value-propagation -instcombine -float2int -loop-load-elim -load-store-vectorizer -div-rem-pairs -separate-const-offset-from-gep -loop-unroll-and-jam -mldst-motion -coro-early -cross-dso-cfi -lower-widenable-condition -reassociate -lower-expect -callsite-splitting -loop-instsimplify -dse -newgvn -slsr -mergeicmps -sccp -mldst-motion -dce -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.0374855824682814,3850.3293058872223,opt -strip-nondebug -rpo-functionattrs -loop-unroll-and-jam -strip-nondebug -coro-elide -inferattrs -loop-instsimplify -bdce -irce -loop-simplifycfg -memcpyopt -hotcoldsplit -indvars -deadargelim -loop-unswitch -simplifycfg -loop-simplify -correlated-propagation -loop-simplify -coro-elide -strip-debug-declare -separate-const-offset-from-gep -jump-threading -callsite-splitting -canonicalize-aliases -mergereturn -ipconstprop -argpromotion -libcalls-shrinkwrap -deadargelim -cross-dso-cfi -canonicalize-aliases -mem2reg -correlated-propagation -adce -simplifycfg -slp-vectorizer -gvn-hoist -cross-dso-cfi -scalarizer -hotcoldsplit -insert-gcov-profiling -gvn -pgo-memop-opt -loop-idiom -rpo-functionattrs -memcpyopt -float2int -barrier -constmerge -consthoist -div-rem-pairs -adce -loop-sink -licm -loop-instsimplify -instcombine -loop-predication -loop-unroll-and-jam -coro-early -nary-reassociate -irce -scalarizer -constmerge -slp-vectorizer -loop-simplifycfg -callsite-splitting -loop-sink -loop-unroll -post-inline-ee-instrument -coro-elide -strip -lower-matrix-intrinsics -mergeicmps -argpromotion -lower-expect -mergefunc -lower-guard-intrinsic -inferattrs -break-crit-edges -sancov -coro-split -simplifycfg -hotcoldsplit -inject-tli-mappings -constprop -inferattrs -mergeicmps -loop-guard-widening -loop-versioning -argpromotion -memcpyopt -libcalls-shrinkwrap -strip-nondebug -gvn-hoist -lower-expect -loop-distribute -globalsplit -sink -nary-reassociate -name-anon-globals -coro-cleanup -always-inline -jump-threading -loop-unroll -loop-unroll-and-jam -globaldce -strip-nondebug -alignment-from-assumptions -simplifycfg -coro-cleanup -guard-widening -lower-widenable-condition -lower-widenable-condition -lcssa -coro-elide -strip-dead-prototypes -ipconstprop -elim-avail-extern -gvn input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.035927734708514,3610.76429438591,opt -mldst-motion -loop-data-prefetch -lower-expect -separate-const-offset-from-gep -rewrite-statepoints-for-gc -loop-simplifycfg -deadargelim -dce -ee-instrument -coro-elide -mem2reg -inferattrs -speculative-execution -loop-simplify -early-cse-memssa -rewrite-statepoints-for-gc -loop-unroll -newgvn -instcombine -prune-eh -dse -gvn-hoist -instsimplify -cross-dso-cfi -coro-cleanup -globaldce -newgvn -flattencfg -simplifycfg input.bc -o output.bc diff --git a/leaderboard/llvm_instcount/random_search/results_p125_t60.csv b/leaderboard/llvm_instcount/random_search/results_p125_t60.csv index cd400446d..2f5d81e0c 100644 --- a/leaderboard/llvm_instcount/random_search/results_p125_t60.csv +++ b/leaderboard/llvm_instcount/random_search/results_p125_t60.csv @@ -1,231 +1,231 @@ benchmark,reward,walltime,commandline -benchmark://cBench-v1/adpcm,1.0000000000000002,62.01178193092346,opt -strip-debug-declare -sroa -add-discriminators -speculative-execution -loop-versioning -loop-fusion -post-inline-ee-instrument -deadargelim -loop-unroll -instcombine -memcpyopt -loop-reduce -forceattrs -loop-vectorize -gvn -coro-elide -libcalls-shrinkwrap -loop-predication -loop-versioning-licm -instsimplify -dce -simplifycfg -pgo-memop-opt -scalarizer -loop-unroll-and-jam -break-crit-edges -loop-predication -instcombine -jump-threading -lower-matrix-intrinsics -sroa -instcombine -lower-constant-intrinsics -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/adpcm,1.0027932960893853,61.84229135513306,opt -loop-versioning-licm -lower-widenable-condition -lowerswitch -die -loop-unroll-and-jam -barrier -ipconstprop -mergereturn -gvn-hoist -instsimplify -argpromotion -mergeicmps -licm -pgo-memop-opt -sink -load-store-vectorizer -simplifycfg -loop-distribute -callsite-splitting -instnamer -globaldce -coro-early -deadargelim -strip-dead-prototypes -cross-dso-cfi -loweratomic -die -inline -rewrite-statepoints-for-gc -instcombine -consthoist -lower-matrix-intrinsics -lcssa -irce -loop-data-prefetch -loop-idiom -flattencfg -ipsccp -coro-cleanup -pgo-memop-opt -flattencfg -globalopt -loop-deletion -constprop -post-inline-ee-instrument -constprop -rpo-functionattrs -adce -coro-elide -loop-sink -gvn -inject-tli-mappings -mem2reg -sroa -load-store-vectorizer -loop-reroll -instnamer -post-inline-ee-instrument -lower-constant-intrinsics -rewrite-statepoints-for-gc -called-value-propagation -sink -loop-unswitch -loop-predication -aggressive-instcombine -lower-matrix-intrinsics -simple-loop-unswitch -licm -early-cse-memssa -loop-data-prefetch -loweratomic -loop-unroll-and-jam -coro-cleanup -tailcallelim -loop-predication -post-inline-ee-instrument -add-discriminators -dse -jump-threading -strip-debug-declare -mergefunc -nary-reassociate -lowerswitch -coro-cleanup -post-inline-ee-instrument -loop-interchange -inject-tli-mappings -nary-reassociate -loop-distribute -lower-constant-intrinsics -loop-versioning-licm -instsimplify input.bc -o output.bc -benchmark://cBench-v1/adpcm,1.0027932960893857,61.92401933670044,opt -pgo-memop-opt -functionattrs -sroa -loop-load-elim -memcpyopt -alignment-from-assumptions -speculative-execution -reassociate -ipconstprop -globaldce -lower-constant-intrinsics -indvars -loop-versioning -bdce -loop-deletion -post-inline-ee-instrument -reassociate -simplifycfg -cross-dso-cfi -memcpyopt -reassociate -dse -loop-unroll-and-jam -memcpyopt -tailcallelim -instcombine -sccp -div-rem-pairs -coro-elide -loop-guard-widening -loop-predication -sroa -nary-reassociate -loop-instsimplify -separate-const-offset-from-gep -name-anon-globals -flattencfg -partially-inline-libcalls -licm -lcssa -lower-constant-intrinsics -instsimplify -inline -coro-split -indvars -deadargelim -mldst-motion -loop-data-prefetch -loop-simplifycfg -pgo-memop-opt -coro-cleanup -loop-idiom -mergeicmps -name-anon-globals -gvn -rewrite-statepoints-for-gc -ipconstprop -always-inline -libcalls-shrinkwrap -lowerinvoke -name-anon-globals -dse -loop-unroll -loop-guard-widening -loop-vectorize -strip-debug-declare -strip-debug-declare -die -die -loop-fusion -lower-widenable-condition -attributor -coro-elide -libcalls-shrinkwrap -loop-predication -rewrite-statepoints-for-gc -redundant-dbg-inst-elim -correlated-propagation -globaldce -loop-data-prefetch -redundant-dbg-inst-elim -instsimplify -inject-tli-mappings -slsr -correlated-propagation -ipsccp -strip-dead-prototypes -slsr -inject-tli-mappings -sroa -loweratomic -adce -constprop -simple-loop-unswitch -inferattrs -constprop -rpo-functionattrs -loop-data-prefetch -lower-guard-intrinsic -mergereturn -scalarizer -reassociate -simplifycfg -add-discriminators -insert-gcov-profiling -correlated-propagation input.bc -o output.bc -benchmark://cBench-v1/adpcm,1.0027932960893857,61.99663496017456,opt -sink -globalopt -gvn-hoist -hotcoldsplit -sroa -add-discriminators -forceattrs -redundant-dbg-inst-elim -flattencfg -forceattrs -loop-idiom -loop-reduce -speculative-execution -memcpyopt -sccp -sancov -ipsccp -sancov -loop-load-elim -loop-fusion -coro-cleanup -strip-dead-prototypes -sink -coro-elide -loop-predication -loop-predication -constmerge -mergeicmps -constmerge -ipconstprop -libcalls-shrinkwrap -canonicalize-aliases -loweratomic -prune-eh -memcpyopt -loop-vectorize -adce -strip-debug-declare -argpromotion -lower-widenable-condition -lowerswitch -called-value-propagation -loop-instsimplify -libcalls-shrinkwrap -post-inline-ee-instrument -mldst-motion -instsimplify -sccp -flattencfg -mergeicmps -tailcallelim -simplifycfg -inline -name-anon-globals -instnamer -scalarizer -dce -insert-gcov-profiling -nary-reassociate -sccp -mergereturn -globaldce -coro-split -nary-reassociate -add-discriminators -inferattrs -div-rem-pairs -break-crit-edges -strip-nondebug -licm -simple-loop-unswitch -ipconstprop -slp-vectorizer -gvn-hoist -partial-inliner -adce -float2int -strip-debug-declare -speculative-execution -alignment-from-assumptions -flattencfg -rewrite-statepoints-for-gc -loop-unroll -callsite-splitting -constprop -mem2reg -partial-inliner -called-value-propagation -post-inline-ee-instrument -redundant-dbg-inst-elim -instcombine -memcpyopt -prune-eh -newgvn -constmerge -add-discriminators -libcalls-shrinkwrap -strip-nondebug -deadargelim -callsite-splitting -irce -gvn -loweratomic -lowerinvoke -slsr -globalopt -coro-split -loop-guard-widening -irce -argpromotion -break-crit-edges -coro-elide -mergefunc -loweratomic -jump-threading -consthoist -loop-versioning -ee-instrument -sccp -loop-vectorize -instnamer -guard-widening -loop-deletion -loop-instsimplify -div-rem-pairs -inject-tli-mappings -newgvn -loop-sink -licm -loop-unroll-and-jam -loop-unroll -lower-widenable-condition -correlated-propagation -nary-reassociate -nary-reassociate -aggressive-instcombine -ee-instrument -aggressive-instcombine -loop-sink -prune-eh -loweratomic -loop-versioning -early-cse-memssa -inferattrs -sccp -loweratomic -loop-fusion -memcpyopt -globalopt -die -inferattrs -partial-inliner -globaldce -loop-load-elim -mergereturn -mergeicmps -slp-vectorizer -strip-debug-declare -elim-avail-extern -partial-inliner -bdce -loweratomic -dce -constprop -load-store-vectorizer -insert-gcov-profiling -jump-threading -die -consthoist -lowerinvoke -indvars -loop-unroll-and-jam -loop-predication -simple-loop-unswitch -globalopt -lowerswitch -jump-threading -coro-early -cross-dso-cfi -inline -irce -loop-versioning -aggressive-instcombine -libcalls-shrinkwrap -lowerinvoke -pgo-memop-opt -instcombine input.bc -o output.bc -benchmark://cBench-v1/adpcm,1.005586592178771,61.88795065879822,opt -name-anon-globals -infer-address-spaces -lower-guard-intrinsic -reassociate -constmerge -separate-const-offset-from-gep -strip-debug-declare -coro-cleanup -loop-unroll-and-jam -add-discriminators -globaldce -barrier -name-anon-globals -reg2mem -infer-address-spaces -loop-versioning-licm -sancov -slsr -loop-unroll -loop-distribute -adce -argpromotion -lcssa -break-crit-edges -instnamer -coro-early -barrier -callsite-splitting -functionattrs -redundant-dbg-inst-elim -loop-idiom -loop-guard-widening -flattencfg -mem2reg -consthoist -called-value-propagation -mergeicmps -lower-matrix-intrinsics -indvars -lower-expect -simplifycfg -name-anon-globals -redundant-dbg-inst-elim -strip-debug-declare -inject-tli-mappings -indvars -separate-const-offset-from-gep -loop-interchange -infer-address-spaces -strip-nondebug -rewrite-statepoints-for-gc -loop-unswitch -separate-const-offset-from-gep -strip-nondebug -libcalls-shrinkwrap -deadargelim -gvn-hoist -barrier -barrier -guard-widening -loop-versioning-licm -lowerinvoke -argpromotion -mem2reg -instcombine -strip-dead-prototypes -loop-idiom -globalopt -attributor -aggressive-instcombine -bdce -consthoist -partially-inline-libcalls -loop-data-prefetch -mem2reg -loop-reduce -loop-versioning-licm -instcombine -slsr -lower-expect -inline -loop-load-elim -simple-loop-unswitch -simplifycfg -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/adpcm,1.005586592178771,61.90937900543213,opt -instcombine -loop-fusion -ipsccp -slsr -functionattrs -aggressive-instcombine -tailcallelim -nary-reassociate -guard-widening -loop-interchange -die -aggressive-instcombine -lower-widenable-condition -ee-instrument -dse -rpo-functionattrs -jump-threading -loop-simplify -canonicalize-aliases -alignment-from-assumptions -alignment-from-assumptions -constprop -libcalls-shrinkwrap -irce -load-store-vectorizer -separate-const-offset-from-gep -ee-instrument -loop-reduce -post-inline-ee-instrument -lower-widenable-condition -loop-deletion -licm -post-inline-ee-instrument -scalarizer -globalsplit -mergereturn -mem2reg -loop-sink -dce -licm -memcpyopt -load-store-vectorizer -barrier -called-value-propagation -memcpyopt -mergereturn -early-cse-memssa -mldst-motion -lower-guard-intrinsic -loop-load-elim -ee-instrument -load-store-vectorizer -loop-distribute -ipconstprop -deadargelim -gvn-hoist -inject-tli-mappings -deadargelim -mergeicmps -newgvn -loop-predication -loop-unroll-and-jam -guard-widening -ipconstprop -loop-reroll -loop-simplify -lower-constant-intrinsics -break-crit-edges -speculative-execution -break-crit-edges -loop-idiom -lower-expect -lowerswitch -scalarizer -ipconstprop -aggressive-instcombine -mldst-motion -mergefunc -ee-instrument -loop-reduce -always-inline -inferattrs -loop-instsimplify -barrier -tailcallelim -loop-guard-widening -gvn-hoist -ee-instrument -lcssa -tailcallelim -simplifycfg -irce -loop-predication -slsr -indvars -loweratomic -slsr -mergereturn -ipconstprop -sink -mem2reg -loop-load-elim -cross-dso-cfi -inferattrs -dse -loop-simplifycfg -loop-instsimplify -dse -inline -newgvn -lcssa -loop-unroll -loop-simplify -loop-data-prefetch -loop-unroll-and-jam -guard-widening -insert-gcov-profiling -licm -canonicalize-aliases -sancov -instsimplify -lower-matrix-intrinsics -name-anon-globals -newgvn -rpo-functionattrs -licm -coro-split -redundant-dbg-inst-elim -instnamer -loop-interchange -loop-interchange -lower-constant-intrinsics -loop-predication -loop-versioning-licm -gvn -alignment-from-assumptions -instcombine -name-anon-globals -insert-gcov-profiling -lowerswitch -forceattrs -lower-constant-intrinsics -speculative-execution -bdce -sroa -mergeicmps -tailcallelim -coro-elide -coro-elide -simplifycfg -mldst-motion -break-crit-edges -gvn-hoist -tailcallelim -loop-predication -lower-expect -loop-fusion -globaldce -irce -coro-early -pgo-memop-opt -simple-loop-unswitch -loop-unswitch -instnamer -loop-unroll-and-jam -bdce -loop-interchange -lower-constant-intrinsics -loop-simplifycfg -forceattrs -globalopt -globaldce -memcpyopt -loop-sink -sancov -loop-sink -loop-idiom -gvn -newgvn -tailcallelim -argpromotion -redundant-dbg-inst-elim -loop-distribute -inject-tli-mappings -jump-threading input.bc -o output.bc -benchmark://cBench-v1/adpcm,1.005586592178771,62.016544580459595,opt -mem2reg -newgvn -loop-unroll -ipconstprop -adce -strip-dead-prototypes -loop-deletion -inferattrs -strip-dead-prototypes -speculative-execution -reg2mem -forceattrs -aggressive-instcombine -mldst-motion -lower-expect -loop-versioning-licm -lower-matrix-intrinsics -pgo-memop-opt -loop-predication -irce -loop-interchange -loop-deletion -loop-distribute -coro-early -post-inline-ee-instrument -partial-inliner -forceattrs -loop-unswitch -loop-reduce -coro-elide -loop-idiom -correlated-propagation -post-inline-ee-instrument -slsr -loop-unroll -strip-nondebug -loop-deletion -lower-matrix-intrinsics -loop-versioning -alignment-from-assumptions -inject-tli-mappings -inject-tli-mappings -alignment-from-assumptions -lower-constant-intrinsics -rewrite-statepoints-for-gc -nary-reassociate -instnamer -flattencfg -hotcoldsplit -lower-expect -slp-vectorizer -always-inline -pgo-memop-opt -loop-sink -loop-sink -loop-load-elim -loop-reroll -insert-gcov-profiling -elim-avail-extern -memcpyopt -sroa -constmerge -instsimplify -reassociate -strip-nondebug -lcssa -globalsplit -ipconstprop -inject-tli-mappings -constprop -prune-eh -loop-vectorize -coro-early -ipconstprop -hotcoldsplit -strip-nondebug -lowerswitch -die -lower-matrix-intrinsics -aggressive-instcombine -lowerswitch -loop-simplifycfg -prune-eh -slp-vectorizer -called-value-propagation -correlated-propagation -rpo-functionattrs -functionattrs -loop-deletion -slsr -ee-instrument -loop-simplifycfg -early-cse-memssa -slsr -loop-unroll -simplifycfg -guard-widening -ee-instrument -slp-vectorizer -irce -strip -instsimplify -loop-interchange -load-store-vectorizer -ipsccp -globaldce -loop-predication -separate-const-offset-from-gep -gvn -loop-simplifycfg -loop-predication -mldst-motion -strip -early-cse-memssa -lower-widenable-condition -loop-predication -sink -instcombine -consthoist -instnamer -loop-interchange -loop-unswitch -loop-fusion -scalarizer -mldst-motion -coro-split -loop-data-prefetch -loweratomic -loop-unroll -sroa -loop-predication -alignment-from-assumptions -mergefunc -separate-const-offset-from-gep -simple-loop-unswitch -gvn -dce -consthoist -lowerswitch -reassociate -loop-instsimplify -partially-inline-libcalls -loop-reduce -barrier -lower-matrix-intrinsics -sink -sccp -tailcallelim -aggressive-instcombine -newgvn -slsr -redundant-dbg-inst-elim -lower-widenable-condition -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/adpcm,1.0055865921787712,61.891133546829224,opt -callsite-splitting -loop-unswitch -loop-interchange -gvn-hoist -deadargelim -mergefunc -barrier -attributor -loop-data-prefetch -inline -hotcoldsplit -sroa -callsite-splitting -jump-threading -separate-const-offset-from-gep -loop-simplifycfg -callsite-splitting -loop-instsimplify -lcssa -dse -barrier -loop-data-prefetch -lower-expect -lowerinvoke -name-anon-globals -rewrite-statepoints-for-gc -name-anon-globals -loop-simplifycfg -forceattrs -mergefunc -pgo-memop-opt -sccp -loop-unroll-and-jam -lower-expect -lowerinvoke -reassociate -loop-predication -gvn-hoist -loop-reroll -break-crit-edges -nary-reassociate -jump-threading -slsr -simplifycfg -globaldce -globalopt -loop-vectorize -forceattrs -loop-versioning -reassociate -loop-data-prefetch -loop-vectorize -prune-eh -lower-widenable-condition -coro-split -sancov -loop-versioning-licm -instsimplify -alignment-from-assumptions -lower-guard-intrinsic -constprop -sroa -elim-avail-extern -constmerge -elim-avail-extern -break-crit-edges -coro-cleanup -sroa -coro-early -sccp -load-store-vectorizer -add-discriminators -instcombine -name-anon-globals -scalarizer -loop-sink -bdce -insert-gcov-profiling -loop-vectorize -loop-deletion -post-inline-ee-instrument -loop-predication -infer-address-spaces -libcalls-shrinkwrap -prune-eh -dce -die -slp-vectorizer -loop-interchange -instcombine -always-inline -partial-inliner -loop-unroll -correlated-propagation -inject-tli-mappings -consthoist -lcssa -redundant-dbg-inst-elim -mergeicmps -insert-gcov-profiling -constprop -constprop -lower-widenable-condition -barrier -globalsplit -globalopt -canonicalize-aliases -float2int -loop-unroll -float2int -adce -dse -lowerinvoke -partial-inliner -inline -sink -redundant-dbg-inst-elim -die -loop-unswitch -div-rem-pairs -die -gvn-hoist -redundant-dbg-inst-elim -globaldce -lower-widenable-condition -newgvn -globaldce -lowerswitch -lower-expect -post-inline-ee-instrument -canonicalize-aliases -gvn-hoist -loop-idiom -lowerinvoke -div-rem-pairs -canonicalize-aliases -alignment-from-assumptions -elim-avail-extern -canonicalize-aliases -called-value-propagation -simplifycfg -rpo-functionattrs -lower-guard-intrinsic -loop-distribute -adce -nary-reassociate -loop-vectorize -separate-const-offset-from-gep -loop-versioning-licm -loop-simplifycfg -newgvn -name-anon-globals -strip-dead-prototypes -constprop -dse -cross-dso-cfi -lowerinvoke -deadargelim -loop-versioning -prune-eh -loop-guard-widening -separate-const-offset-from-gep -loop-predication -simple-loop-unswitch -rewrite-statepoints-for-gc -alignment-from-assumptions -sink -loop-versioning -loop-simplifycfg -licm -float2int -ee-instrument -inferattrs -elim-avail-extern -coro-elide -redundant-dbg-inst-elim -loop-reroll -instnamer -correlated-propagation -instcombine input.bc -o output.bc -benchmark://cBench-v1/adpcm,1.0055865921787712,61.928428411483765,opt -instsimplify -functionattrs -loop-unswitch -loop-simplifycfg -name-anon-globals -name-anon-globals -barrier -loop-distribute -sroa -loop-unswitch -insert-gcov-profiling -loop-unroll-and-jam -insert-gcov-profiling -callsite-splitting -rpo-functionattrs -called-value-propagation -instsimplify -memcpyopt -dce -globaldce -loop-deletion -loop-guard-widening -simple-loop-unswitch -die -instsimplify -alignment-from-assumptions -argpromotion -ipsccp -callsite-splitting -slsr -add-discriminators -lower-expect -loweratomic -memcpyopt -strip-nondebug -ee-instrument -newgvn -strip -constmerge -loop-load-elim -lower-guard-intrinsic -redundant-dbg-inst-elim -consthoist -partially-inline-libcalls -instnamer -reassociate -sancov -inline -alignment-from-assumptions -cross-dso-cfi -bdce -globalsplit -deadargelim -libcalls-shrinkwrap -strip-nondebug -speculative-execution -pgo-memop-opt -nary-reassociate -partial-inliner -loop-versioning-licm -memcpyopt -globalopt -loop-reroll -mem2reg -lcssa -instnamer -coro-elide -rpo-functionattrs -memcpyopt -alignment-from-assumptions -jump-threading -constprop -dce -sroa -lowerinvoke -always-inline -slp-vectorizer -strip -loop-sink -mergefunc -constmerge -consthoist -mergefunc -break-crit-edges -functionattrs -loop-guard-widening -loop-fusion -attributor -jump-threading -partially-inline-libcalls -mergeicmps -prune-eh -reassociate -loop-guard-widening -adce -simplifycfg -tailcallelim -flattencfg -called-value-propagation -forceattrs -memcpyopt -jump-threading -aggressive-instcombine -mldst-motion -hotcoldsplit -forceattrs -constmerge -libcalls-shrinkwrap -flattencfg -break-crit-edges -loop-unroll -sroa -loop-predication -ipsccp -loop-reroll -infer-address-spaces -slp-vectorizer -called-value-propagation -loop-simplifycfg -scalarizer -inline -loop-deletion -reg2mem -loop-instsimplify -sroa -redundant-dbg-inst-elim -early-cse-memssa -inline -prune-eh -scalarizer -simplifycfg -loop-versioning -bdce -correlated-propagation -alignment-from-assumptions -irce -elim-avail-extern -prune-eh -alignment-from-assumptions -nary-reassociate -inline -barrier -loop-instsimplify -strip-nondebug -loop-versioning-licm -rewrite-statepoints-for-gc -gvn -loop-deletion -lower-guard-intrinsic -early-cse-memssa -loop-interchange -loop-unswitch -elim-avail-extern -simplifycfg -loop-reroll -loop-reroll -loop-simplify -slsr -add-discriminators -loop-versioning-licm -instcombine -sink -ipsccp -mergeicmps -mergeicmps -barrier -always-inline -break-crit-edges -sink -lower-guard-intrinsic -prune-eh -loop-unroll -deadargelim -insert-gcov-profiling -globaldce -early-cse-memssa -tailcallelim -dce -loop-fusion -loop-simplify -reg2mem -globalsplit -loop-data-prefetch -loop-vectorize -jump-threading -rewrite-statepoints-for-gc -loop-idiom -prune-eh -loop-unroll -loop-simplifycfg -early-cse-memssa -gvn-hoist -loop-unroll-and-jam -loop-simplify -slp-vectorizer -lowerinvoke -partial-inliner -gvn-hoist -float2int -strip-debug-declare -load-store-vectorizer -sroa -break-crit-edges -rewrite-statepoints-for-gc -pgo-memop-opt -newgvn -memcpyopt -separate-const-offset-from-gep -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/adpcm,1.0055865921787712,61.9604275226593,opt -add-discriminators -indvars -speculative-execution -memcpyopt -coro-cleanup -licm -inject-tli-mappings -constmerge -slp-vectorizer -alignment-from-assumptions -barrier -deadargelim -loop-guard-widening -loop-unswitch -barrier -loop-fusion -strip -loop-unroll -loop-sink -simplifycfg -barrier -lowerinvoke -partial-inliner -loop-distribute -ee-instrument -pgo-memop-opt -coro-elide -inline -mergeicmps -strip-dead-prototypes -lcssa -globalopt -inferattrs -sroa -speculative-execution -memcpyopt -loop-unroll-and-jam -dce -ipsccp -loop-distribute -lowerinvoke -loop-interchange -correlated-propagation -inject-tli-mappings -inline -loop-data-prefetch -partial-inliner -loop-vectorize -ee-instrument -cross-dso-cfi -constprop -strip-dead-prototypes -separate-const-offset-from-gep -infer-address-spaces -div-rem-pairs -constmerge -load-store-vectorizer -called-value-propagation -rewrite-statepoints-for-gc -flattencfg -instcombine -libcalls-shrinkwrap -partially-inline-libcalls -slsr -always-inline -sancov -gvn-hoist -loop-vectorize -flattencfg -sccp -ee-instrument -callsite-splitting -licm -nary-reassociate -barrier -strip-debug-declare -deadargelim -irce -coro-cleanup -lower-matrix-intrinsics -alignment-from-assumptions -alignment-from-assumptions -loop-load-elim -dse -lowerswitch -inline -mldst-motion -coro-cleanup -always-inline -loop-reduce -loop-sink -globalopt -strip-dead-prototypes -bdce -functionattrs -jump-threading -correlated-propagation -barrier -sccp -load-store-vectorizer -loop-guard-widening -loop-reroll -lower-widenable-condition -insert-gcov-profiling -mem2reg -coro-split -loop-deletion -loop-guard-widening -coro-early -loop-reduce -speculative-execution -lower-matrix-intrinsics -correlated-propagation -reassociate -loweratomic -guard-widening -pgo-memop-opt -separate-const-offset-from-gep -argpromotion -slp-vectorizer -aggressive-instcombine -loop-interchange -attributor -speculative-execution -coro-split -tailcallelim -loop-simplifycfg -barrier -scalarizer -lower-constant-intrinsics -coro-cleanup -die -inferattrs -instsimplify -loop-simplifycfg -irce -loweratomic -slsr -gvn input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.0044247787610618,61.726380825042725,opt -reassociate -lowerswitch -reg2mem -instnamer -guard-widening -loop-versioning -elim-avail-extern -indvars -rewrite-statepoints-for-gc -dse -reassociate -hotcoldsplit -dse -div-rem-pairs -loop-deletion -functionattrs -sccp -sccp -separate-const-offset-from-gep -lowerswitch -always-inline -dse -slsr -dse -name-anon-globals -strip -strip-debug-declare -indvars -post-inline-ee-instrument -sancov -load-store-vectorizer -cross-dso-cfi -correlated-propagation -post-inline-ee-instrument -newgvn -flattencfg -deadargelim -dse -flattencfg -instsimplify -sroa -adce -globaldce -constprop -indvars -nary-reassociate -lower-expect -instcombine -rpo-functionattrs -ipconstprop -dce -loop-simplifycfg -flattencfg -memcpyopt -tailcallelim -loop-distribute -loop-reduce -attributor -jump-threading -slp-vectorizer -lower-widenable-condition -early-cse-memssa -ee-instrument -loop-deletion -lcssa -add-discriminators -globalsplit -strip-dead-prototypes -die -mem2reg -simple-loop-unswitch -gvn-hoist -aggressive-instcombine -loop-instsimplify -guard-widening -inline -strip-dead-prototypes -loweratomic -partially-inline-libcalls -instsimplify -lower-expect -mem2reg -slsr -correlated-propagation -loop-versioning-licm -name-anon-globals -div-rem-pairs -mergefunc -gvn -loop-interchange -loop-unroll-and-jam -separate-const-offset-from-gep -loop-simplify -lower-guard-intrinsic -rewrite-statepoints-for-gc -libcalls-shrinkwrap -instcombine -forceattrs -newgvn -constprop -strip-nondebug -early-cse-memssa -loop-vectorize -dce -insert-gcov-profiling -always-inline -gvn -loop-guard-widening -loop-load-elim -loop-vectorize -instsimplify -ipsccp -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.0066371681415929,61.671980142593384,opt -insert-gcov-profiling -gvn-hoist -callsite-splitting -partially-inline-libcalls -loop-idiom -ipconstprop -loop-load-elim -memcpyopt -partially-inline-libcalls -ee-instrument -argpromotion -reassociate -loop-unroll-and-jam -loop-instsimplify -loop-simplify -forceattrs -ipsccp -elim-avail-extern -dse -jump-threading -ipsccp -ipsccp -irce -lower-expect -argpromotion -irce -insert-gcov-profiling -die -sroa -newgvn -loop-versioning-licm -correlated-propagation -loop-deletion -early-cse-memssa -loop-data-prefetch -loop-unroll-and-jam -strip-nondebug -newgvn -lcssa -constprop -strip-dead-prototypes -lower-guard-intrinsic -always-inline -rpo-functionattrs -dse -loop-vectorize -name-anon-globals -slp-vectorizer -sink -globaldce -loop-versioning -flattencfg -sccp -nary-reassociate -loop-instsimplify -sccp -called-value-propagation -libcalls-shrinkwrap -gvn-hoist -nary-reassociate -loop-sink -dce -called-value-propagation -speculative-execution -globalopt -mergereturn -early-cse-memssa -pgo-memop-opt -hotcoldsplit -mldst-motion -constmerge -name-anon-globals -rewrite-statepoints-for-gc -loop-unroll -lowerinvoke -mldst-motion -rpo-functionattrs -correlated-propagation -irce -lower-expect -early-cse-memssa -rpo-functionattrs -instcombine -dce -argpromotion -sancov -attributor -ipconstprop -partial-inliner -mergefunc -add-discriminators -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.0066371681415929,61.696775674819946,opt -lowerswitch -early-cse-memssa -lower-widenable-condition -lower-widenable-condition -aggressive-instcombine -div-rem-pairs -globalopt -loop-reduce -loop-idiom -bdce -float2int -elim-avail-extern -called-value-propagation -tailcallelim -inline -globalopt -bdce -loop-simplify -speculative-execution -redundant-dbg-inst-elim -lowerswitch -strip -loop-unroll-and-jam -globalopt -instcombine -constprop -strip-nondebug -argpromotion -indvars -ipconstprop -ipsccp -loop-reduce -globalsplit -libcalls-shrinkwrap -strip-dead-prototypes -loop-distribute -canonicalize-aliases -nary-reassociate -sroa -nary-reassociate -newgvn -sink -memcpyopt -loop-interchange -coro-elide -memcpyopt -attributor -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.0088495575221237,61.81148862838745,opt -partially-inline-libcalls -rpo-functionattrs -mergereturn -rpo-functionattrs -globaldce -name-anon-globals -slp-vectorizer -partially-inline-libcalls -reassociate -lower-expect -dse -break-crit-edges -loop-simplify -inject-tli-mappings -loop-simplify -strip-nondebug -lower-widenable-condition -constprop -globalopt -indvars -lcssa -loop-versioning-licm -globalsplit -strip-nondebug -loop-fusion -strip-nondebug -rpo-functionattrs -loop-versioning -loop-simplify -reg2mem -break-crit-edges -dce -attributor -loop-versioning-licm -strip-debug-declare -instsimplify -rewrite-statepoints-for-gc -constmerge -slp-vectorizer -loop-distribute -aggressive-instcombine -strip-nondebug -strip-debug-declare -partial-inliner -mergeicmps -lower-expect -rewrite-statepoints-for-gc -simplifycfg -mergeicmps -flattencfg -redundant-dbg-inst-elim -adce -loop-guard-widening -early-cse-memssa -sroa -loop-deletion -loop-simplify -gvn-hoist -lower-guard-intrinsic -loop-reroll -loop-fusion -constmerge -coro-early -pgo-memop-opt -instcombine -coro-cleanup -coro-split -pgo-memop-opt -tailcallelim -prune-eh -lower-constant-intrinsics -instnamer -loop-reroll -jump-threading -tailcallelim -alignment-from-assumptions -partially-inline-libcalls -coro-split -lcssa -strip-nondebug -deadargelim -adce -alignment-from-assumptions -slp-vectorizer -globalopt -always-inline -elim-avail-extern -gvn -simplifycfg -name-anon-globals -jump-threading -loop-sink -lower-expect -loop-versioning -pgo-memop-opt -irce -flattencfg -argpromotion -post-inline-ee-instrument -loop-fusion -loop-simplify -simplifycfg -sink -die -nary-reassociate -lower-matrix-intrinsics -sroa -partially-inline-libcalls -functionattrs -newgvn input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.008849557522124,61.73530960083008,opt -sccp -licm -reg2mem -coro-split -simplifycfg -loop-unroll -dse -lowerswitch -elim-avail-extern -globalopt -post-inline-ee-instrument -simplifycfg -argpromotion -slsr -forceattrs -constmerge -guard-widening -loop-data-prefetch -loop-instsimplify -simplifycfg -nary-reassociate -speculative-execution -always-inline -speculative-execution -inject-tli-mappings -sancov -simplifycfg -consthoist -rpo-functionattrs -callsite-splitting -lower-guard-intrinsic -loop-sink -coro-split -constmerge -loop-interchange -guard-widening -lcssa -loop-interchange -simplifycfg -strip-nondebug -loop-predication -deadargelim -newgvn -add-discriminators -attributor -loop-guard-widening -coro-cleanup -inferattrs -globalopt -partial-inliner -coro-cleanup -alignment-from-assumptions -insert-gcov-profiling -strip -simplifycfg -loop-guard-widening -loop-instsimplify -name-anon-globals -deadargelim -lcssa -mergeicmps -hotcoldsplit -mem2reg -forceattrs -rewrite-statepoints-for-gc -indvars -infer-address-spaces -callsite-splitting -sccp -called-value-propagation -globaldce -coro-cleanup -dse -elim-avail-extern -name-anon-globals -lower-matrix-intrinsics -inject-tli-mappings -flattencfg -attributor -hotcoldsplit -guard-widening -strip-nondebug -coro-split -cross-dso-cfi -loop-versioning-licm -loop-simplifycfg -sink -float2int -loop-sink -loop-unroll-and-jam -insert-gcov-profiling -licm -reg2mem -loop-deletion -gvn-hoist -sancov -loop-vectorize -strip-dead-prototypes -post-inline-ee-instrument -simplifycfg -loop-unroll-and-jam -lower-guard-intrinsic -licm -callsite-splitting -partial-inliner -bdce -instsimplify -loop-deletion -correlated-propagation -lowerswitch -mem2reg -post-inline-ee-instrument -inject-tli-mappings -loop-idiom -loop-unroll-and-jam -reg2mem -lowerinvoke -barrier -break-crit-edges -scalarizer -slp-vectorizer -callsite-splitting -memcpyopt -loop-unroll-and-jam -forceattrs -guard-widening -globalsplit -globalsplit -loop-simplify -guard-widening -gvn-hoist -instsimplify -insert-gcov-profiling -loop-fusion -loop-data-prefetch -inject-tli-mappings -loop-fusion -loop-versioning -rewrite-statepoints-for-gc -loop-interchange -aggressive-instcombine -strip-nondebug -correlated-propagation -mem2reg -reassociate -name-anon-globals -sancov -add-discriminators -slp-vectorizer -libcalls-shrinkwrap -instcombine -prune-eh -loop-data-prefetch -consthoist -mergereturn -barrier -mergeicmps -name-anon-globals -jump-threading -sroa -instnamer -loop-predication -lowerswitch -mergefunc -separate-const-offset-from-gep -constprop -loop-guard-widening -barrier -gvn-hoist -loop-idiom -loop-data-prefetch -aggressive-instcombine -elim-avail-extern -insert-gcov-profiling -coro-split -slsr -name-anon-globals -constmerge -lower-matrix-intrinsics -instsimplify -slsr -sink -inferattrs -rpo-functionattrs -instcombine -post-inline-ee-instrument -loop-idiom -loop-reroll -mergeicmps -loop-vectorize -forceattrs -float2int -loop-data-prefetch -instcombine -speculative-execution -pgo-memop-opt -globaldce -always-inline -functionattrs -loop-fusion -partial-inliner -ipsccp -dce -called-value-propagation -deadargelim -slsr -jump-threading -lower-expect -instnamer -lowerswitch -loop-fusion -adce -forceattrs -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.008849557522124,61.8548686504364,opt -lower-widenable-condition -flattencfg -strip-nondebug -loop-distribute -lowerswitch -rewrite-statepoints-for-gc -loop-load-elim -loop-predication -inject-tli-mappings -partial-inliner -div-rem-pairs -constmerge -coro-early -insert-gcov-profiling -name-anon-globals -callsite-splitting -gvn-hoist -lowerinvoke -early-cse-memssa -jump-threading -strip-dead-prototypes -mergereturn -adce -attributor -consthoist -coro-elide -coro-elide -loop-distribute -memcpyopt -strip-dead-prototypes -constmerge -name-anon-globals -callsite-splitting -always-inline -canonicalize-aliases -loop-sink -dse -adce -mergeicmps -loop-predication -lower-expect -loop-data-prefetch -break-crit-edges -barrier -libcalls-shrinkwrap -consthoist -loop-idiom -forceattrs -inline -adce -coro-elide -mergeicmps -aggressive-instcombine -lowerswitch -early-cse-memssa -inferattrs -simplifycfg -float2int -mergeicmps -early-cse-memssa -coro-early -constmerge -lower-constant-intrinsics -aggressive-instcombine -separate-const-offset-from-gep -strip-dead-prototypes -lower-constant-intrinsics -jump-threading -memcpyopt -strip-nondebug -loop-reduce -loop-deletion -mergeicmps -mldst-motion -sroa -strip-nondebug -pgo-memop-opt -indvars -lower-guard-intrinsic -canonicalize-aliases -constprop -rewrite-statepoints-for-gc -irce -indvars -licm -pgo-memop-opt -separate-const-offset-from-gep -rewrite-statepoints-for-gc -instcombine -coro-early -cross-dso-cfi -div-rem-pairs -loop-vectorize -instcombine -die -attributor -loop-unroll-and-jam -always-inline -jump-threading -licm -loop-simplify -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.008849557522124,61.99087977409363,opt -constmerge -die -licm -pgo-memop-opt -loop-distribute -scalarizer -infer-address-spaces -libcalls-shrinkwrap -alignment-from-assumptions -callsite-splitting -post-inline-ee-instrument -newgvn -globalsplit -barrier -reassociate -elim-avail-extern -ipconstprop -licm -prune-eh -globaldce -partial-inliner -deadargelim -constmerge -functionattrs -inferattrs -coro-early -loop-simplify -irce -indvars -strip-dead-prototypes -mldst-motion -float2int -aggressive-instcombine -called-value-propagation -argpromotion -loop-predication -coro-early -redundant-dbg-inst-elim -loop-unroll -loop-instsimplify -sink -hotcoldsplit -bdce -canonicalize-aliases -insert-gcov-profiling -coro-cleanup -globaldce -guard-widening -callsite-splitting -slsr -loop-unroll-and-jam -loop-predication -constprop -loop-predication -loop-versioning -deadargelim -slsr -loop-simplifycfg -guard-widening -guard-widening -jump-threading -loop-deletion -slp-vectorizer -ee-instrument -speculative-execution -loop-versioning -mergeicmps -coro-split -consthoist -coro-early -functionattrs -lower-expect -loop-simplifycfg -sroa -loop-load-elim -speculative-execution -instcombine -bdce -redundant-dbg-inst-elim -simplifycfg -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.0110619469026547,61.65555500984192,opt -early-cse-memssa -coro-early -elim-avail-extern -rpo-functionattrs -coro-early -separate-const-offset-from-gep -globalopt -loop-reroll -mergeicmps -globalopt -loop-predication -loop-interchange -mem2reg -strip-debug-declare -simple-loop-unswitch -mergeicmps -early-cse-memssa -ipsccp -jump-threading -nary-reassociate -canonicalize-aliases -insert-gcov-profiling -instsimplify -callsite-splitting -loop-idiom -strip -loop-deletion -strip-debug-declare -aggressive-instcombine -bdce -float2int -inject-tli-mappings -alignment-from-assumptions -redundant-dbg-inst-elim -pgo-memop-opt -separate-const-offset-from-gep -rewrite-statepoints-for-gc -guard-widening -indvars -insert-gcov-profiling -jump-threading -mergereturn -dse -globaldce -loop-unroll -canonicalize-aliases -gvn -rpo-functionattrs -loop-fusion -partially-inline-libcalls -partial-inliner -lower-guard-intrinsic -tailcallelim -loop-versioning -insert-gcov-profiling -attributor -coro-elide -name-anon-globals -mergefunc -pgo-memop-opt -adce -speculative-execution -instnamer -canonicalize-aliases -loop-deletion -instcombine -canonicalize-aliases -strip-dead-prototypes -lowerswitch -redundant-dbg-inst-elim -loop-fusion -dse -coro-split -tailcallelim -slsr -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.011061946902655,61.76593828201294,opt -inline -partial-inliner -memcpyopt -strip-dead-prototypes -lowerinvoke -correlated-propagation -lcssa -memcpyopt -globalopt -sink -simplifycfg -sancov -globalsplit -callsite-splitting -loop-reduce -deadargelim -sink -constmerge -break-crit-edges -lower-matrix-intrinsics -cross-dso-cfi -adce -sroa -deadargelim -consthoist -tailcallelim -mergeicmps -slp-vectorizer -loop-guard-widening -lower-guard-intrinsic -instcombine -loop-unroll -dse -coro-elide -globaldce -globalopt -correlated-propagation -memcpyopt -globaldce -early-cse-memssa -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/bitcount,1.0176991150442478,61.881062746047974,opt -loop-simplifycfg -strip-debug-declare -cross-dso-cfi -mem2reg -loop-guard-widening -canonicalize-aliases -loop-data-prefetch -loop-interchange -inferattrs -ipconstprop -loop-versioning-licm -loop-unswitch -lower-constant-intrinsics -simplifycfg -bdce -loop-reduce -partially-inline-libcalls -mem2reg -jump-threading -lcssa -loop-interchange -scalarizer -coro-split -alignment-from-assumptions -mergereturn -loop-unswitch -correlated-propagation -loop-vectorize -memcpyopt -mem2reg -post-inline-ee-instrument -coro-elide -mldst-motion -loop-unroll -prune-eh -tailcallelim -loop-simplify -argpromotion -indvars -scalarizer -sancov -partially-inline-libcalls -post-inline-ee-instrument -callsite-splitting -instcombine -deadargelim -ipsccp -loop-fusion -inline -bdce -libcalls-shrinkwrap -rewrite-statepoints-for-gc -partial-inliner -slsr -coro-early -barrier -jump-threading -mergefunc -partially-inline-libcalls -loop-idiom -adce -loop-predication -memcpyopt -correlated-propagation -early-cse-memssa -functionattrs -coro-elide -globaldce -rewrite-statepoints-for-gc -lower-constant-intrinsics -nary-reassociate -strip-debug-declare -callsite-splitting -instcombine -insert-gcov-profiling -globaldce -licm -loop-instsimplify -ipsccp -canonicalize-aliases -loop-reduce -instnamer -loop-simplify -instcombine -indvars -aggressive-instcombine -float2int -mem2reg -aggressive-instcombine -strip-debug-declare -attributor -irce -strip-debug-declare -loop-load-elim -loop-deletion -mldst-motion -lower-expect -strip-nondebug -simple-loop-unswitch -libcalls-shrinkwrap -loop-interchange -sancov -globalopt -sroa -lower-constant-intrinsics -globalopt -libcalls-shrinkwrap -globalopt -cross-dso-cfi -instcombine -sancov -instcombine -lower-matrix-intrinsics -loop-unroll -lowerinvoke -loop-simplify -aggressive-instcombine -nary-reassociate -ipsccp -loop-predication -partially-inline-libcalls -memcpyopt -loop-predication -post-inline-ee-instrument -loop-unswitch -consthoist -ipsccp -consthoist -coro-early -aggressive-instcombine -loop-deletion -licm -nary-reassociate -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0549618320610687,61.924893379211426,opt -loop-simplify -rewrite-statepoints-for-gc -coro-early -jump-threading -break-crit-edges -ipconstprop -globalopt -simple-loop-unswitch -prune-eh -mem2reg -barrier -loop-versioning-licm -rpo-functionattrs -loop-simplifycfg -newgvn -adce -mergeicmps -tailcallelim -redundant-dbg-inst-elim -post-inline-ee-instrument -constmerge -flattencfg -partially-inline-libcalls -attributor -lower-widenable-condition -loop-predication -nary-reassociate -loop-unroll -rpo-functionattrs -simple-loop-unswitch -callsite-splitting -constmerge -instcombine -newgvn -lower-constant-intrinsics -loop-sink -lower-guard-intrinsic -loop-sink -lower-expect -div-rem-pairs -loop-instsimplify -loop-reroll -post-inline-ee-instrument -flattencfg -loop-unroll-and-jam -break-crit-edges -consthoist -strip-dead-prototypes -name-anon-globals -sroa -elim-avail-extern -loop-data-prefetch -loop-vectorize -pgo-memop-opt -indvars -inline -insert-gcov-profiling -strip-nondebug -infer-address-spaces -loop-predication -partial-inliner -loop-predication -redundant-dbg-inst-elim -loop-reroll -coro-early -irce -strip -lower-expect -lower-constant-intrinsics -loop-interchange -speculative-execution -nary-reassociate -add-discriminators -load-store-vectorizer -loop-guard-widening -instnamer -callsite-splitting -name-anon-globals -loop-data-prefetch -coro-split -loop-load-elim -loop-reroll -post-inline-ee-instrument -attributor -always-inline -barrier -gvn-hoist -nary-reassociate -attributor -aggressive-instcombine -slp-vectorizer -mergefunc -libcalls-shrinkwrap -aggressive-instcombine -instcombine -lower-expect -add-discriminators -load-store-vectorizer -argpromotion -loop-unswitch -simple-loop-unswitch -loop-simplifycfg -canonicalize-aliases -gvn-hoist -lowerinvoke -loop-idiom -loop-predication -add-discriminators -loop-simplify -mergeicmps -indvars -coro-split -callsite-splitting -loop-simplify -libcalls-shrinkwrap -always-inline -argpromotion -div-rem-pairs -sancov -ee-instrument -loop-instsimplify -strip-nondebug -irce -load-store-vectorizer -deadargelim -reassociate -prune-eh -barrier -correlated-propagation -name-anon-globals -div-rem-pairs -redundant-dbg-inst-elim -load-store-vectorizer -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.055470737913486,61.863592863082886,opt -mldst-motion -argpromotion -libcalls-shrinkwrap -speculative-execution -lower-matrix-intrinsics -strip-dead-prototypes -redundant-dbg-inst-elim -loop-deletion -prune-eh -ipconstprop -pgo-memop-opt -simplifycfg -die -canonicalize-aliases -reassociate -scalarizer -mergeicmps -lower-guard-intrinsic -mem2reg -loop-fusion -rewrite-statepoints-for-gc -hotcoldsplit -loop-vectorize -strip-dead-prototypes -lowerinvoke -slp-vectorizer -lcssa -name-anon-globals -instnamer -guard-widening -reassociate -partial-inliner -rpo-functionattrs -barrier -inferattrs -strip -post-inline-ee-instrument -coro-early -ipconstprop -barrier -loop-reroll -instcombine -barrier -tailcallelim -ipconstprop -loop-data-prefetch -mem2reg -div-rem-pairs -lower-matrix-intrinsics -slp-vectorizer -mldst-motion -gvn-hoist -name-anon-globals -loop-fusion -dse -simple-loop-unswitch -lower-matrix-intrinsics -coro-elide -gvn -lower-widenable-condition -load-store-vectorizer -slp-vectorizer -tailcallelim -inferattrs -loop-unswitch -argpromotion -coro-early -loop-sink -reassociate -early-cse-memssa -loop-sink -add-discriminators -dse -ee-instrument -rewrite-statepoints-for-gc -strip -mergeicmps -early-cse-memssa -reassociate -loop-rotate -mergefunc -indvars -instnamer -elim-avail-extern -ipconstprop -tailcallelim -gvn-hoist -canonicalize-aliases -cross-dso-cfi -infer-address-spaces -constprop -nary-reassociate -aggressive-instcombine -mldst-motion -adce -instsimplify -sancov -loop-rotate -sancov -loop-vectorize -loop-unroll-and-jam -constmerge -partially-inline-libcalls -slsr -functionattrs -cross-dso-cfi -dse -loop-unswitch -loop-predication -separate-const-offset-from-gep -loop-rotate -coro-early -redundant-dbg-inst-elim -hotcoldsplit -simplifycfg -elim-avail-extern -lower-constant-intrinsics -lowerinvoke -argpromotion -slsr -loop-versioning-licm -redundant-dbg-inst-elim -nary-reassociate -loop-sink -lowerinvoke -ipconstprop -aggressive-instcombine -loop-reduce -post-inline-ee-instrument -indvars -add-discriminators -instcombine -indvars -instnamer -loop-interchange -loop-load-elim -globaldce -canonicalize-aliases -called-value-propagation -loop-unroll-and-jam -strip -div-rem-pairs -strip -jump-threading -hotcoldsplit -globalopt -inline -elim-avail-extern -cross-dso-cfi -early-cse-memssa -tailcallelim -coro-early -called-value-propagation -ee-instrument -instnamer -forceattrs -globaldce -adce -strip-debug-declare -mergefunc input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0569974554707382,62.10315656661987,opt -flattencfg -prune-eh -loweratomic -mem2reg -loop-distribute -instnamer -mergeicmps -argpromotion -loop-load-elim -lower-matrix-intrinsics -div-rem-pairs -loop-unroll-and-jam -instsimplify -constmerge -partial-inliner -coro-early -lower-expect -tailcallelim -globalopt -hotcoldsplit -instcombine -lower-expect -pgo-memop-opt -loop-sink -lowerswitch -guard-widening -indvars -inline -slp-vectorizer -licm -coro-elide -gvn-hoist -loop-interchange -lower-widenable-condition -loop-deletion -post-inline-ee-instrument -globalsplit -coro-elide -correlated-propagation -libcalls-shrinkwrap -coro-split -loop-deletion -load-store-vectorizer -nary-reassociate -mergereturn -float2int -float2int -dse -strip-debug-declare -loop-reroll -infer-address-spaces -die -loop-reduce -early-cse-memssa -constmerge -loop-versioning-licm -sink -div-rem-pairs -canonicalize-aliases -strip-nondebug -loop-versioning-licm -ee-instrument -loop-load-elim -forceattrs -irce -loop-idiom -lower-matrix-intrinsics -simplifycfg -cross-dso-cfi -scalarizer -lcssa -load-store-vectorizer -simplifycfg -forceattrs -lower-constant-intrinsics -loop-rotate -rewrite-statepoints-for-gc -loop-simplify -hotcoldsplit -deadargelim -guard-widening -lcssa -load-store-vectorizer -guard-widening -instnamer -licm -div-rem-pairs -slsr -newgvn -simple-loop-unswitch -gvn-hoist -elim-avail-extern -hotcoldsplit -slp-vectorizer -loop-vectorize -called-value-propagation -tailcallelim -partially-inline-libcalls -post-inline-ee-instrument -strip -post-inline-ee-instrument -aggressive-instcombine -dce -lowerinvoke -sink -loop-versioning-licm -loweratomic -ipsccp -attributor -lower-widenable-condition -lower-expect -dse -aggressive-instcombine -rewrite-statepoints-for-gc -lcssa -loop-fusion -loop-distribute -instsimplify -infer-address-spaces -lower-constant-intrinsics -canonicalize-aliases -instsimplify -flattencfg -hotcoldsplit -forceattrs -loop-data-prefetch -slp-vectorizer -dce -separate-const-offset-from-gep -globalopt -loop-versioning -reassociate -dce -elim-avail-extern -loweratomic -inferattrs -rewrite-statepoints-for-gc -lower-guard-intrinsic -lower-guard-intrinsic -constmerge -rewrite-statepoints-for-gc -pgo-memop-opt -coro-cleanup -lowerinvoke -memcpyopt -mergefunc -loop-predication -consthoist -libcalls-shrinkwrap -loop-simplify -early-cse-memssa -licm -sink -ipsccp -instcombine -rewrite-statepoints-for-gc -sink -forceattrs -loop-guard-widening -loop-sink -slsr -consthoist -partially-inline-libcalls -simple-loop-unswitch -separate-const-offset-from-gep -instnamer -loop-predication -libcalls-shrinkwrap -indvars -consthoist -nary-reassociate -ee-instrument -strip-nondebug -strip-dead-prototypes -add-discriminators -loop-sink -loop-load-elim -pgo-memop-opt -called-value-propagation -hotcoldsplit -early-cse-memssa -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0620865139949112,62.0668671131134,opt -mem2reg -mergefunc -reassociate -dse -loop-sink -infer-address-spaces -libcalls-shrinkwrap -instsimplify -simple-loop-unswitch -infer-address-spaces -tailcallelim -loop-guard-widening -deadargelim -callsite-splitting -pgo-memop-opt -sink -break-crit-edges -canonicalize-aliases -loop-instsimplify -strip -loop-predication -sccp -mldst-motion -div-rem-pairs -coro-cleanup -loop-distribute -loop-idiom -gvn -globalopt -attributor -loop-unroll-and-jam -loop-interchange -early-cse-memssa -break-crit-edges -loop-deletion -loop-guard-widening -loop-unroll-and-jam -lower-guard-intrinsic -sroa -loop-instsimplify -instnamer -memcpyopt -scalarizer -simple-loop-unswitch -callsite-splitting -sancov -argpromotion -add-discriminators -bdce -attributor -loop-unroll -loop-unroll -inferattrs -coro-cleanup -strip-dead-prototypes -instsimplify -loop-idiom -loop-fusion -always-inline -loweratomic -globalopt -loweratomic -float2int -loop-idiom -insert-gcov-profiling -gvn -lower-constant-intrinsics -callsite-splitting -coro-cleanup -lower-matrix-intrinsics -attributor -globalopt -loop-reroll -name-anon-globals -loop-reduce -sroa -constmerge -loop-unswitch -redundant-dbg-inst-elim -gvn -loop-simplify -aggressive-instcombine -flattencfg -inject-tli-mappings -cross-dso-cfi -simple-loop-unswitch -instcombine -ipsccp -argpromotion -correlated-propagation -sccp -barrier -hotcoldsplit -deadargelim -lower-guard-intrinsic -flattencfg -dse -lower-constant-intrinsics -elim-avail-extern -globaldce -aggressive-instcombine -reassociate -mldst-motion -instnamer -slsr -simplifycfg -sroa -lower-expect -argpromotion -dse -insert-gcov-profiling -loop-simplify -redundant-dbg-inst-elim -canonicalize-aliases -constmerge -rewrite-statepoints-for-gc -redundant-dbg-inst-elim -adce -pgo-memop-opt -strip -instcombine -ipconstprop -add-discriminators -aggressive-instcombine -partial-inliner -memcpyopt -canonicalize-aliases -constmerge -instnamer -loop-versioning -partially-inline-libcalls -sccp -inferattrs -gvn-hoist -loop-versioning-licm -sink -constprop -coro-elide -barrier -cross-dso-cfi -loop-idiom -speculative-execution -loop-deletion -lowerinvoke -loweratomic -gvn-hoist -coro-early -rewrite-statepoints-for-gc -loop-unswitch -loop-simplifycfg -loop-simplify -ipconstprop -mldst-motion -ipsccp -barrier -infer-address-spaces -ipsccp -sccp -alignment-from-assumptions -loop-load-elim -load-store-vectorizer -simplifycfg -loop-idiom -loop-idiom -irce -inferattrs -loop-vectorize -inject-tli-mappings -libcalls-shrinkwrap -instsimplify -loweratomic -simple-loop-unswitch -loop-reroll -separate-const-offset-from-gep -lower-guard-intrinsic -guard-widening -loop-sink -redundant-dbg-inst-elim -gvn -loop-instsimplify -mergefunc -deadargelim -hotcoldsplit -callsite-splitting -cross-dso-cfi -slp-vectorizer -licm -adce -slp-vectorizer -memcpyopt -sancov -ee-instrument -rewrite-statepoints-for-gc -rewrite-statepoints-for-gc -always-inline -loop-reroll -lcssa -jump-threading -called-value-propagation -loweratomic -lower-guard-intrinsic -lower-guard-intrinsic -lower-expect -libcalls-shrinkwrap -loop-reduce -slsr -argpromotion -loop-idiom -die -loop-reroll -dse -sancov -insert-gcov-profiling -jump-threading -loop-instsimplify -lowerinvoke -barrier -instcombine -loop-deletion -loop-unroll-and-jam -nary-reassociate -rpo-functionattrs -argpromotion -mldst-motion -partially-inline-libcalls -strip-dead-prototypes -strip-nondebug -hotcoldsplit -loop-reroll -loop-simplify -early-cse-memssa -lcssa -loop-reduce -always-inline -mergefunc -gvn -constprop -loop-distribute -gvn -coro-cleanup -loop-fusion -indvars -break-crit-edges -irce -separate-const-offset-from-gep -sccp -reg2mem -slsr -sroa -loop-deletion -barrier -die -newgvn -die -libcalls-shrinkwrap -partially-inline-libcalls -loop-simplify -loop-unroll-and-jam -called-value-propagation -newgvn -mldst-motion -jump-threading -redundant-dbg-inst-elim -newgvn -mergeicmps -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0641221374045802,62.110954999923706,opt -constmerge -name-anon-globals -cross-dso-cfi -elim-avail-extern -mergeicmps -lower-constant-intrinsics -mergeicmps -loop-versioning-licm -mem2reg -rpo-functionattrs -called-value-propagation -attributor -constmerge -instcombine -ipconstprop -loop-unroll-and-jam -coro-elide -coro-split -loop-unswitch -jump-threading -gvn -mldst-motion -loop-fusion -cross-dso-cfi -post-inline-ee-instrument -licm -indvars -early-cse-memssa -strip-debug-declare -strip -load-store-vectorizer -lower-guard-intrinsic -mergereturn -loop-deletion -slsr -indvars -ipsccp -loop-reroll -constprop -loop-predication -coro-early -bdce -loop-fusion -consthoist -globalopt -attributor -instcombine -name-anon-globals -scalarizer -newgvn -loop-data-prefetch -flattencfg -lcssa -rpo-functionattrs -instcombine -instcombine -strip-dead-prototypes -infer-address-spaces -indvars -sccp -coro-split -pgo-memop-opt -hotcoldsplit -coro-cleanup -argpromotion -simplifycfg -infer-address-spaces -irce -float2int -callsite-splitting -aggressive-instcombine -alignment-from-assumptions -mem2reg -consthoist -dse -loop-predication -load-store-vectorizer -always-inline -lower-constant-intrinsics -loop-guard-widening -mergereturn -mldst-motion -post-inline-ee-instrument -simplifycfg -inferattrs -strip -loop-sink -loop-predication -reg2mem -slsr -loop-data-prefetch -gvn-hoist -loop-deletion -gvn-hoist -coro-elide -indvars -loop-versioning-licm -flattencfg -name-anon-globals -flattencfg -simple-loop-unswitch -coro-early -float2int -coro-elide -aggressive-instcombine -reg2mem -prune-eh -ipsccp -flattencfg -loop-simplifycfg -loop-fusion -guard-widening -name-anon-globals -post-inline-ee-instrument -early-cse-memssa -break-crit-edges -globalsplit -dse -name-anon-globals -lower-matrix-intrinsics -loop-vectorize -prune-eh -nary-reassociate -lowerinvoke -loop-deletion -loop-load-elim -loop-predication -loweratomic -simplifycfg -strip-debug-declare -name-anon-globals -lowerinvoke -loweratomic -inline -loop-unswitch -slsr -newgvn -reg2mem -lower-constant-intrinsics -loop-versioning -licm -hotcoldsplit -alignment-from-assumptions -constprop -dse -functionattrs -loop-vectorize -slsr -called-value-propagation -loop-versioning -canonicalize-aliases -redundant-dbg-inst-elim -dce -consthoist -sink -add-discriminators -mergefunc -consthoist -rpo-functionattrs -always-inline -slsr -lower-widenable-condition -rpo-functionattrs -instnamer -loop-fusion -loop-idiom -barrier -bdce -loop-predication -elim-avail-extern -memcpyopt -gvn -strip -loop-versioning -separate-const-offset-from-gep -instsimplify -loop-data-prefetch -dse -loop-simplifycfg -separate-const-offset-from-gep -strip-debug-declare -reassociate -attributor -slp-vectorizer -gvn-hoist -instcombine -loop-reduce -loop-idiom -ee-instrument -inline -lower-guard-intrinsic -reassociate -instcombine -loop-vectorize -add-discriminators -elim-avail-extern -lowerinvoke -loop-rotate -sroa -reassociate -adce -coro-elide -consthoist -strip-nondebug -break-crit-edges -loop-load-elim -memcpyopt -strip -loop-fusion -loop-versioning -strip-debug-declare -adce -loop-simplify -name-anon-globals -loop-simplifycfg -newgvn -cross-dso-cfi -loop-versioning -globalopt -add-discriminators -deadargelim -load-store-vectorizer -forceattrs -cross-dso-cfi -lower-matrix-intrinsics -ipsccp -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0671755725190841,62.24016213417053,opt -constprop -lower-constant-intrinsics -lcssa -libcalls-shrinkwrap -deadargelim -always-inline -inferattrs -loop-unroll-and-jam -loop-fusion -prune-eh -loop-instsimplify -gvn -rewrite-statepoints-for-gc -strip-debug-declare -ee-instrument -loop-instsimplify -instcombine -mergefunc -name-anon-globals -reassociate -loop-unroll-and-jam -argpromotion -prune-eh -simple-loop-unswitch -instnamer -mem2reg -strip-dead-prototypes -coro-split -partially-inline-libcalls -reassociate -insert-gcov-profiling -loop-unswitch -break-crit-edges -flattencfg -aggressive-instcombine -barrier -slp-vectorizer -irce -libcalls-shrinkwrap -reassociate -name-anon-globals -inferattrs -canonicalize-aliases -simple-loop-unswitch -cross-dso-cfi -slp-vectorizer -loop-unroll-and-jam -add-discriminators -newgvn -loop-fusion -post-inline-ee-instrument -argpromotion -ipconstprop -slsr -mem2reg -irce -strip-dead-prototypes -globalsplit -loop-unroll -scalarizer -pgo-memop-opt -mem2reg -loop-simplifycfg -mergereturn -load-store-vectorizer -irce -libcalls-shrinkwrap -loop-instsimplify -simplifycfg -ipconstprop -partial-inliner -loop-guard-widening -canonicalize-aliases -aggressive-instcombine -inferattrs -mergefunc -gvn-hoist -consthoist -loop-reroll -sink -tailcallelim -float2int -loop-deletion -gvn -gvn -lcssa -post-inline-ee-instrument -load-store-vectorizer -loop-load-elim -loop-deletion -gvn-hoist -slsr -loop-simplify -aggressive-instcombine -memcpyopt -nary-reassociate -loop-unroll-and-jam -mergefunc -licm -alignment-from-assumptions -redundant-dbg-inst-elim -barrier -libcalls-shrinkwrap -sccp -mergeicmps -dce -prune-eh -callsite-splitting -ipconstprop -coro-split -partially-inline-libcalls -globalopt -div-rem-pairs -mergereturn -loop-unswitch -inferattrs -reassociate -barrier -licm -adce -infer-address-spaces -simplifycfg -ipsccp -libcalls-shrinkwrap -rewrite-statepoints-for-gc -loop-load-elim -loop-instsimplify -slsr -sccp -dce -ee-instrument -lower-widenable-condition -loop-load-elim -memcpyopt -loop-vectorize -alignment-from-assumptions -ipsccp -break-crit-edges -constprop -redundant-dbg-inst-elim -loop-unswitch -mldst-motion -slp-vectorizer -instsimplify -barrier -load-store-vectorizer -loop-sink -loop-instsimplify -strip-nondebug -loop-unroll-and-jam -loop-instsimplify -partial-inliner -strip -flattencfg -slsr -div-rem-pairs -partially-inline-libcalls -mergeicmps -loop-reroll -bdce -alignment-from-assumptions -simplifycfg -mem2reg -mem2reg -adce -cross-dso-cfi -tailcallelim -canonicalize-aliases -float2int -licm -globalsplit -mergeicmps -correlated-propagation -globaldce -lcssa -instcombine -globaldce -called-value-propagation -irce -strip-nondebug -instsimplify -early-cse-memssa -jump-threading input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0687022900763359,62.245200872421265,opt -loop-simplifycfg -simple-loop-unswitch -functionattrs -break-crit-edges -rpo-functionattrs -loop-fusion -dce -consthoist -die -loop-interchange -strip -licm -strip -lower-constant-intrinsics -functionattrs -lower-constant-intrinsics -speculative-execution -pgo-memop-opt -dce -strip -sroa -slp-vectorizer -early-cse-memssa -memcpyopt -instcombine -loop-interchange -loop-deletion -globalopt -loop-unroll -loop-versioning -instnamer -functionattrs -rewrite-statepoints-for-gc -loop-instsimplify -coro-split -sroa -loop-deletion -coro-early -instsimplify -simple-loop-unswitch -name-anon-globals -flattencfg -post-inline-ee-instrument -inline -bdce -load-store-vectorizer -load-store-vectorizer -loop-versioning -lower-constant-intrinsics -consthoist -load-store-vectorizer -instnamer -speculative-execution -loop-fusion -irce -irce -flattencfg -lower-guard-intrinsic -sroa -cross-dso-cfi -guard-widening -redundant-dbg-inst-elim -correlated-propagation -gvn-hoist -prune-eh -loop-data-prefetch -always-inline -irce -coro-early -newgvn -strip-dead-prototypes -coro-cleanup -infer-address-spaces -irce -adce -loop-simplify -globalsplit -dse -tailcallelim -loop-idiom -slp-vectorizer -tailcallelim -partial-inliner -mldst-motion -libcalls-shrinkwrap -load-store-vectorizer -strip-nondebug -gvn -loop-unswitch -always-inline -jump-threading -loweratomic -loop-sink -gvn-hoist -globalopt -flattencfg -simple-loop-unswitch -mldst-motion -mergefunc -globalsplit -deadargelim -loweratomic -loop-idiom -globaldce -separate-const-offset-from-gep -mergefunc -lcssa -add-discriminators -coro-cleanup -speculative-execution -infer-address-spaces -gvn -canonicalize-aliases -bdce -callsite-splitting -coro-elide -tailcallelim -lower-constant-intrinsics -loop-versioning -loop-sink -irce -argpromotion -loop-data-prefetch -attributor -simple-loop-unswitch -alignment-from-assumptions -barrier -early-cse-memssa -loop-idiom -simple-loop-unswitch -slp-vectorizer -loop-interchange -coro-early -loop-versioning -loop-simplify -rewrite-statepoints-for-gc -globalopt -alignment-from-assumptions -bdce -barrier -post-inline-ee-instrument -lowerinvoke -pgo-memop-opt -always-inline -newgvn -loweratomic -argpromotion -irce -sink -gvn -attributor -coro-cleanup -speculative-execution -lowerinvoke -aggressive-instcombine -loop-sink -early-cse-memssa -indvars -always-inline -add-discriminators -loop-unswitch -irce -attributor -early-cse-memssa -instcombine -bdce -die -loop-fusion -loop-distribute -ipsccp -lower-constant-intrinsics -slp-vectorizer input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.068702290076336,62.09459686279297,opt -strip-dead-prototypes -post-inline-ee-instrument -lowerinvoke -loop-deletion -lower-constant-intrinsics -ipconstprop -attributor -float2int -partially-inline-libcalls -elim-avail-extern -coro-cleanup -rewrite-statepoints-for-gc -prune-eh -lower-widenable-condition -div-rem-pairs -coro-elide -rpo-functionattrs -float2int -lower-guard-intrinsic -mergereturn -callsite-splitting -loop-predication -ipconstprop -globalsplit -lower-widenable-condition -barrier -partially-inline-libcalls -lower-expect -lower-expect -dce -ipsccp -lowerinvoke -inferattrs -bdce -loop-vectorize -add-discriminators -consthoist -argpromotion -lower-constant-intrinsics -mem2reg -dce -loop-instsimplify -constprop -lower-widenable-condition -reassociate -speculative-execution -rpo-functionattrs -libcalls-shrinkwrap -lower-guard-intrinsic -called-value-propagation -slsr -globalsplit -instcombine -mergeicmps -loop-reroll -loweratomic -hotcoldsplit -globalopt -globalsplit -loop-guard-widening -loop-versioning-licm -loop-sink -loop-versioning-licm -gvn -consthoist -canonicalize-aliases -lowerswitch -libcalls-shrinkwrap -irce -coro-cleanup -loop-versioning-licm -inline -inferattrs -irce -libcalls-shrinkwrap -coro-elide -loop-guard-widening -elim-avail-extern -alignment-from-assumptions -load-store-vectorizer -load-store-vectorizer -constprop -functionattrs -loop-idiom -loop-deletion -float2int -correlated-propagation -rpo-functionattrs -constprop -dce -coro-elide -load-store-vectorizer -lower-matrix-intrinsics -separate-const-offset-from-gep -aggressive-instcombine -tailcallelim -loweratomic -load-store-vectorizer -coro-early -argpromotion -alignment-from-assumptions -bdce -inferattrs -adce -sancov -globaldce -elim-avail-extern -loop-versioning-licm -adce -dce -reg2mem -name-anon-globals -load-store-vectorizer -loop-distribute -hotcoldsplit -always-inline -instsimplify -hotcoldsplit -loop-instsimplify -instsimplify -loop-interchange -loop-load-elim -newgvn -add-discriminators -jump-threading -loweratomic -prune-eh -tailcallelim -loop-load-elim -correlated-propagation -adce -tailcallelim -sccp -constprop -early-cse-memssa -prune-eh -alignment-from-assumptions -ipconstprop -loop-fusion -float2int -prune-eh -newgvn -gvn -early-cse-memssa -loop-versioning -loop-reroll -loop-vectorize -always-inline -redundant-dbg-inst-elim -newgvn -called-value-propagation -slp-vectorizer -alignment-from-assumptions -argpromotion -loop-data-prefetch -instcombine -redundant-dbg-inst-elim -break-crit-edges -jump-threading -loop-simplify -reassociate -sroa -simplifycfg -forceattrs -div-rem-pairs -loop-distribute -ee-instrument -gvn-hoist -prune-eh -tailcallelim -mergefunc -mergeicmps -instnamer -gvn input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0732824427480923,62.259055852890015,opt -forceattrs -jump-threading -forceattrs -dse -simple-loop-unswitch -consthoist -loop-interchange -alignment-from-assumptions -flattencfg -instsimplify -mergefunc -argpromotion -strip -flattencfg -lowerinvoke -simple-loop-unswitch -loop-simplifycfg -coro-elide -load-store-vectorizer -dse -loop-versioning-licm -pgo-memop-opt -cross-dso-cfi -slsr -nary-reassociate -coro-early -coro-elide -instsimplify -loop-vectorize -die -functionattrs -lower-constant-intrinsics -mldst-motion -consthoist -cross-dso-cfi -slsr -lcssa -float2int -globaldce -simplifycfg -licm -simple-loop-unswitch -post-inline-ee-instrument -loweratomic -alignment-from-assumptions -simplifycfg -strip-dead-prototypes -deadargelim -mldst-motion -coro-cleanup -instcombine -add-discriminators -ipsccp -loop-reroll -newgvn -canonicalize-aliases -ee-instrument -loop-versioning-licm -constprop -coro-cleanup -loop-reroll -always-inline -mem2reg -rpo-functionattrs -gvn -partial-inliner -strip -always-inline -sroa -prune-eh -loop-unswitch -slsr -lower-constant-intrinsics -sroa -irce -constprop -dse -slsr -lower-widenable-condition -loop-unroll-and-jam -lowerinvoke -speculative-execution -mldst-motion -loop-unroll -irce -early-cse-memssa -coro-split -argpromotion -loop-load-elim -mergeicmps -mem2reg -loop-interchange -separate-const-offset-from-gep -instcombine -forceattrs -globalopt -loop-idiom -globaldce -mem2reg -newgvn -called-value-propagation -strip-dead-prototypes -strip -name-anon-globals -newgvn -callsite-splitting -speculative-execution -ipsccp -coro-elide -barrier -slp-vectorizer -cross-dso-cfi -loop-sink -die -instcombine -hotcoldsplit -memcpyopt -inline -strip-nondebug -loop-versioning-licm -gvn-hoist -memcpyopt -inline -tailcallelim -loop-instsimplify -barrier -mergefunc -mergeicmps -loop-instsimplify -load-store-vectorizer -inferattrs -constmerge -div-rem-pairs -gvn-hoist -prune-eh -deadargelim -hotcoldsplit -memcpyopt -tailcallelim -loop-sink -loop-fusion -loop-deletion -name-anon-globals -coro-elide -newgvn -ipsccp -strip-dead-prototypes -die -redundant-dbg-inst-elim -ipconstprop -instcombine -called-value-propagation -coro-elide -slp-vectorizer -inferattrs -aggressive-instcombine -float2int -reassociate -newgvn -early-cse-memssa -loop-load-elim -slsr -dce -gvn-hoist -irce -jump-threading -rpo-functionattrs -nary-reassociate -loop-versioning -lowerinvoke -elim-avail-extern -loop-load-elim -bdce -memcpyopt -flattencfg -instcombine -coro-early -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/blowfish,1.0793893129770993,61.71475172042847,opt -slp-vectorizer -loop-reduce -post-inline-ee-instrument -cross-dso-cfi -elim-avail-extern -sroa -callsite-splitting -div-rem-pairs -constmerge -mergeicmps -lcssa -insert-gcov-profiling -mergefunc -tailcallelim -strip-debug-declare -loop-versioning-licm -add-discriminators -loop-distribute -strip -insert-gcov-profiling -prune-eh -coro-split -instcombine -coro-early -loop-interchange -jump-threading -lowerinvoke -prune-eh -loop-unswitch -attributor -called-value-propagation -lower-expect -mem2reg -speculative-execution -partially-inline-libcalls -dce -separate-const-offset-from-gep -jump-threading -ipsccp -sink -flattencfg -mergeicmps -ee-instrument -sink -consthoist -indvars -loop-vectorize -load-store-vectorizer -correlated-propagation -slp-vectorizer -loop-versioning-licm -guard-widening -simplifycfg -consthoist -aggressive-instcombine -called-value-propagation -barrier -loop-idiom -coro-early -ee-instrument -add-discriminators -mldst-motion -forceattrs -newgvn -always-inline -instsimplify -simplifycfg -adce -loop-unswitch -reassociate -strip-debug-declare -irce -div-rem-pairs -deadargelim -instcombine -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.1545071082643337,67.68773531913757,opt -loop-reduce -adce -coro-early -indvars -called-value-propagation -strip-debug-declare -pgo-memop-opt -licm -lcssa -bdce -loop-guard-widening -attributor -mergereturn -loop-idiom -loop-sink -forceattrs -instsimplify -strip -sancov -loop-vectorize -ipsccp -mergefunc -lower-matrix-intrinsics -sroa -loop-versioning-licm -lcssa -elim-avail-extern -lcssa -speculative-execution -bdce -hotcoldsplit -mldst-motion -called-value-propagation -globaldce -newgvn -load-store-vectorizer -break-crit-edges -sink -loop-vectorize -redundant-dbg-inst-elim -reg2mem -aggressive-instcombine -cross-dso-cfi -globalopt -strip-debug-declare -canonicalize-aliases -coro-elide -reassociate -loop-guard-widening -loop-predication -flattencfg -nary-reassociate -loop-fusion -memcpyopt -loop-instsimplify -coro-cleanup -mem2reg -ipsccp -simple-loop-unswitch -loop-data-prefetch -licm -globalopt -coro-early -slp-vectorizer -redundant-dbg-inst-elim -loop-predication -loop-unroll-and-jam -coro-cleanup -loop-fusion -pgo-memop-opt -simplifycfg -loop-unswitch -dce -aggressive-instcombine -simplifycfg -always-inline -loop-fusion -instcombine input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.160287455085143,322.17351841926575,opt -flattencfg -loweratomic -simplifycfg -constmerge -loop-versioning -reg2mem -globalsplit -mem2reg -loop-vectorize -canonicalize-aliases -mergeicmps -indvars -instnamer -correlated-propagation -loop-guard-widening -correlated-propagation -instcombine -alignment-from-assumptions -barrier -newgvn -strip-nondebug -reassociate -loop-fusion -simplifycfg -alignment-from-assumptions -ipsccp -instcombine input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.161927823777535,69.08962750434875,opt -loweratomic -lcssa -dce -called-value-propagation -loop-guard-widening -inferattrs -elim-avail-extern -consthoist -coro-early -globalsplit -add-discriminators -loop-unswitch -coro-cleanup -lowerinvoke -instnamer -aggressive-instcombine -simplifycfg -lower-matrix-intrinsics -called-value-propagation -globalopt -inject-tli-mappings -reg2mem -callsite-splitting -div-rem-pairs -irce -die -lower-guard-intrinsic -rewrite-statepoints-for-gc -nary-reassociate -functionattrs -ee-instrument -loop-data-prefetch -always-inline -elim-avail-extern -separate-const-offset-from-gep -globaldce -always-inline -called-value-propagation -prune-eh -licm -loop-unroll-and-jam -lcssa -mergeicmps -loop-reroll -mergeicmps -div-rem-pairs -elim-avail-extern -lcssa -dse -break-crit-edges -coro-cleanup -inject-tli-mappings -instsimplify -loop-simplifycfg -div-rem-pairs -functionattrs -strip -forceattrs -ipconstprop -loop-versioning-licm -mldst-motion -simple-loop-unswitch -loop-guard-widening -memcpyopt -sroa -functionattrs -insert-gcov-profiling -mldst-motion -loop-idiom -instnamer -add-discriminators -globalsplit -called-value-propagation -lower-constant-intrinsics -globaldce -slsr -redundant-dbg-inst-elim -coro-split -loop-load-elim -partially-inline-libcalls -globaldce -called-value-propagation -jump-threading -argpromotion -loop-fusion -mergereturn -nary-reassociate -constprop -early-cse-memssa -irce -sroa -canonicalize-aliases -loop-idiom -strip-nondebug -reassociate -inferattrs -instcombine -cross-dso-cfi -coro-split -partially-inline-libcalls -partially-inline-libcalls -licm -lowerswitch -aggressive-instcombine -loop-unroll-and-jam -lowerinvoke -bdce -lower-widenable-condition -lower-matrix-intrinsics -redundant-dbg-inst-elim -post-inline-ee-instrument -ee-instrument -coro-split -lower-matrix-intrinsics -functionattrs -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.1643493204186848,67.1374294757843,opt -aggressive-instcombine -lowerinvoke -memcpyopt -loop-sink -always-inline -lower-matrix-intrinsics -gvn-hoist -slsr -separate-const-offset-from-gep -speculative-execution -sroa -newgvn -lcssa -forceattrs -coro-split -hotcoldsplit -dse -memcpyopt -lowerinvoke -dce -reassociate -functionattrs -forceattrs -loop-unroll-and-jam -loop-interchange -coro-split -lower-widenable-condition -loop-vectorize -always-inline -load-store-vectorizer -slsr -post-inline-ee-instrument -partially-inline-libcalls -irce -instcombine -memcpyopt -consthoist -loop-load-elim -pgo-memop-opt -barrier -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.1674738322137166,69.87810277938843,opt -loop-versioning -loop-simplifycfg -loop-fusion -strip-debug-declare -ipsccp -simple-loop-unswitch -strip-dead-prototypes -gvn-hoist -simplifycfg -loop-sink -div-rem-pairs -prune-eh -post-inline-ee-instrument -loop-guard-widening -sink -speculative-execution -ee-instrument -lcssa -mldst-motion -lower-expect -sroa -dse -tailcallelim -loop-unroll-and-jam -flattencfg -loop-distribute -globalsplit -loop-reroll -loop-reroll -gvn -lower-constant-intrinsics -loop-predication -mergereturn -coro-split -loop-unswitch -simple-loop-unswitch -libcalls-shrinkwrap -sccp -loop-interchange -lowerinvoke -constprop -coro-elide -pgo-memop-opt -name-anon-globals -forceattrs -break-crit-edges -separate-const-offset-from-gep -lower-expect -prune-eh -bdce -attributor -scalarizer -loop-reroll -loweratomic -rewrite-statepoints-for-gc -cross-dso-cfi -scalarizer -nary-reassociate -jump-threading -insert-gcov-profiling -flattencfg -instcombine input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.1680206217778468,68.25625967979431,opt -flattencfg -mldst-motion -newgvn -attributor -canonicalize-aliases -coro-elide -canonicalize-aliases -ipconstprop -licm -loop-instsimplify -loop-load-elim -attributor -instsimplify -loop-distribute -lower-widenable-condition -strip-dead-prototypes -elim-avail-extern -loop-versioning-licm -mergefunc -loop-unroll -callsite-splitting -irce -flattencfg -lowerswitch -load-store-vectorizer -globalsplit -reassociate -lowerswitch -lcssa -lower-widenable-condition -strip -gvn-hoist -strip -guard-widening -tailcallelim -instnamer -partially-inline-libcalls -strip-debug-declare -cross-dso-cfi -jump-threading -irce -jump-threading -prune-eh -reassociate -load-store-vectorizer -loop-reroll -loop-distribute -loop-versioning -newgvn -loop-simplify -mem2reg -alignment-from-assumptions -mergeicmps -lower-guard-intrinsic -functionattrs -simplifycfg -barrier -coro-early -constprop -globalsplit -loop-versioning -loop-guard-widening -lowerinvoke -libcalls-shrinkwrap -inject-tli-mappings -consthoist -ee-instrument -slp-vectorizer -nary-reassociate -lower-guard-intrinsic -speculative-execution -name-anon-globals -adce -callsite-splitting -dse -instcombine -sancov -lower-widenable-condition -gvn -simplifycfg -memcpyopt input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.1706764568036248,68.34867286682129,opt -mergeicmps -newgvn -loop-versioning-licm -dce -partial-inliner -load-store-vectorizer -mem2reg -functionattrs -sccp -functionattrs -strip-debug-declare -dce -mldst-motion -mergeicmps -float2int -infer-address-spaces -jump-threading -mem2reg -break-crit-edges -constprop -always-inline -div-rem-pairs -mergereturn -cross-dso-cfi -gvn -coro-elide -loop-interchange -float2int -loop-idiom -die -dce -instcombine -loop-vectorize -load-store-vectorizer -simplifycfg -attributor -sancov -nary-reassociate -guard-widening -loop-deletion -callsite-splitting -instnamer -coro-early -nary-reassociate -coro-cleanup -newgvn -loop-unroll-and-jam -simplifycfg -simplifycfg -strip -lcssa -jump-threading -lower-guard-intrinsic -slsr -redundant-dbg-inst-elim -correlated-propagation -slsr -load-store-vectorizer -loop-simplify -instnamer -globaldce -adce -redundant-dbg-inst-elim -early-cse-memssa -slp-vectorizer -slsr -irce -loop-data-prefetch -nary-reassociate -deadargelim -licm -separate-const-offset-from-gep -strip-nondebug -prune-eh -loop-deletion -mldst-motion -gvn -alignment-from-assumptions -ipsccp -jump-threading input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.172473051085768,70.48168897628784,opt -mergefunc -scalarizer -deadargelim -alignment-from-assumptions -loweratomic -loop-distribute -lower-matrix-intrinsics -nary-reassociate -loop-versioning -slp-vectorizer -name-anon-globals -constprop -scalarizer -deadargelim -gvn -strip-dead-prototypes -float2int -break-crit-edges -lower-constant-intrinsics -ee-instrument -add-discriminators -globalopt -slp-vectorizer -constmerge -lcssa -cross-dso-cfi -alignment-from-assumptions -early-cse-memssa -dce -loop-unroll-and-jam -cross-dso-cfi -simple-loop-unswitch -guard-widening -loop-sink -loop-fusion -coro-early -guard-widening -scalarizer -pgo-memop-opt -loop-interchange -mergereturn -mergefunc -break-crit-edges -aggressive-instcombine -strip-dead-prototypes -div-rem-pairs -mergereturn -name-anon-globals -always-inline -loweratomic -loop-data-prefetch -newgvn -coro-elide -strip-nondebug -globalopt -lower-matrix-intrinsics -pgo-memop-opt -die -slp-vectorizer -loop-sink -barrier -elim-avail-extern -attributor -loop-load-elim -slsr -ee-instrument -globaldce -early-cse-memssa -pgo-memop-opt -gvn-hoist -loweratomic -rewrite-statepoints-for-gc -canonicalize-aliases -partially-inline-libcalls -instnamer -simplifycfg -barrier -reassociate -insert-gcov-profiling -libcalls-shrinkwrap -loop-vectorize -add-discriminators -correlated-propagation -prune-eh -sroa -redundant-dbg-inst-elim -add-discriminators -simple-loop-unswitch -separate-const-offset-from-gep -strip-nondebug -nary-reassociate -globalsplit -name-anon-globals -strip-debug-declare -loop-deletion -loop-predication -loop-load-elim -called-value-propagation -lower-widenable-condition -loop-distribute -alignment-from-assumptions -coro-early -simplifycfg -div-rem-pairs -newgvn -simple-loop-unswitch -ee-instrument -loop-reroll -strip -aggressive-instcombine -flattencfg -called-value-propagation -inferattrs -tailcallelim -gvn -mergeicmps -strip-debug-declare -slp-vectorizer -loop-simplifycfg -lower-constant-intrinsics -functionattrs -instcombine -gvn-hoist -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.1809092329323547,365.934752702713,opt -pgo-memop-opt -loop-versioning-licm -inferattrs -functionattrs -guard-widening -functionattrs -tailcallelim -lower-matrix-intrinsics -barrier -rewrite-statepoints-for-gc -lcssa -inject-tli-mappings -lower-widenable-condition -mem2reg -scalarizer -mergereturn -partially-inline-libcalls -globalopt -dse -break-crit-edges -alignment-from-assumptions -bdce -loop-sink -hotcoldsplit -alignment-from-assumptions -flattencfg -partial-inliner -adce -float2int -callsite-splitting -div-rem-pairs -gvn-hoist -forceattrs -elim-avail-extern -infer-address-spaces -loop-versioning -newgvn -strip-nondebug -flattencfg -mem2reg -loop-load-elim -instcombine -globaldce -inferattrs -loop-distribute -mergereturn -constmerge -consthoist -dse -prune-eh -rpo-functionattrs -scalarizer -load-store-vectorizer -flattencfg -loop-interchange -ipconstprop -canonicalize-aliases -attributor -lower-matrix-intrinsics -mldst-motion -inferattrs -always-inline -mem2reg -loop-instsimplify -sccp -memcpyopt -strip-nondebug -nary-reassociate -lower-constant-intrinsics -die -mergereturn -infer-address-spaces -loop-versioning-licm -called-value-propagation -early-cse-memssa -lower-guard-intrinsic -ipsccp -sink -early-cse-memssa -strip -loop-idiom -instcombine -loop-vectorize -lowerinvoke -callsite-splitting -ipconstprop -libcalls-shrinkwrap -die -loop-interchange -ipconstprop -add-discriminators -alignment-from-assumptions -indvars -lower-widenable-condition -dce -simplifycfg -guard-widening -argpromotion -dce -ipsccp -dse -early-cse-memssa -float2int -newgvn input.bc -o output.bc -benchmark://cBench-v1/bzip2,1.1948914232151224,68.35258197784424,opt -mem2reg -globaldce -loop-unroll-and-jam -correlated-propagation -scalarizer -rpo-functionattrs -licm -flattencfg -loweratomic -libcalls-shrinkwrap -irce -tailcallelim -loop-instsimplify -functionattrs -mergeicmps -coro-early -loop-instsimplify -strip-debug-declare -dce -loop-versioning-licm -loop-unswitch -prune-eh -rpo-functionattrs -loop-versioning-licm -constmerge -div-rem-pairs -loop-guard-widening -ipconstprop -prune-eh -libcalls-shrinkwrap -indvars -lower-matrix-intrinsics -globalopt -strip-nondebug -coro-split -loop-instsimplify -lower-matrix-intrinsics -libcalls-shrinkwrap -loop-idiom -loop-data-prefetch -loop-guard-widening -nary-reassociate -flattencfg -loop-sink -cross-dso-cfi -always-inline -indvars -dce -always-inline -guard-widening -memcpyopt -instnamer -lower-guard-intrinsic -loop-versioning-licm -nary-reassociate -deadargelim -irce -post-inline-ee-instrument -lowerinvoke -sroa -coro-cleanup -simplifycfg -newgvn -instcombine input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,61.635990619659424,opt -add-discriminators -loop-unroll-and-jam -lower-constant-intrinsics -mldst-motion -globaldce -add-discriminators -slp-vectorizer -mem2reg -mergereturn -infer-address-spaces -die -nary-reassociate -coro-split -redundant-dbg-inst-elim -barrier -loop-distribute -scalarizer -indvars -instcombine -separate-const-offset-from-gep -lower-constant-intrinsics -inferattrs -guard-widening -lower-widenable-condition -mergefunc -die -lcssa -strip -scalarizer -ipsccp -loop-unroll -loop-guard-widening -loop-instsimplify -coro-early -reassociate -tailcallelim -slp-vectorizer -gvn-hoist -flattencfg -gvn-hoist -forceattrs -mergeicmps -correlated-propagation -called-value-propagation -correlated-propagation -strip-debug-declare -pgo-memop-opt -rewrite-statepoints-for-gc -reassociate -gvn -guard-widening -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,61.67673325538635,opt -mldst-motion -aggressive-instcombine -loop-interchange -loop-idiom -gvn-hoist -simplifycfg -coro-split -speculative-execution -loop-idiom -load-store-vectorizer -separate-const-offset-from-gep -loop-fusion -inject-tli-mappings -coro-early -coro-early -loop-distribute -loop-load-elim -load-store-vectorizer -prune-eh -rpo-functionattrs -partially-inline-libcalls -ipconstprop -reg2mem -loop-versioning-licm -scalarizer -globalopt -loop-fusion -loop-unroll-and-jam -globalopt -adce -memcpyopt -libcalls-shrinkwrap -strip -coro-split -loop-simplifycfg -infer-address-spaces -partial-inliner -partial-inliner -early-cse-memssa -loop-deletion -licm -redundant-dbg-inst-elim -mergeicmps -ee-instrument -inferattrs -functionattrs -instcombine -indvars -sroa -die -newgvn -loop-distribute -scalarizer -pgo-memop-opt -instsimplify -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,61.70763802528381,opt -alignment-from-assumptions -mem2reg -dse -irce -loop-simplifycfg -adce -canonicalize-aliases -constprop -dse -newgvn -loop-unroll-and-jam -globalsplit -slp-vectorizer -loop-unroll -globalopt -scalarizer -mergeicmps -indvars -slsr -coro-cleanup -ee-instrument -partial-inliner -forceattrs -mergeicmps -indvars -simple-loop-unswitch -insert-gcov-profiling -simple-loop-unswitch -slsr -jump-threading -loop-sink -argpromotion -irce -lower-constant-intrinsics -loop-versioning -aggressive-instcombine -newgvn -lower-guard-intrinsic -cross-dso-cfi -ee-instrument -post-inline-ee-instrument -coro-elide -loop-fusion -forceattrs -coro-elide -adce -mergereturn -strip -lower-matrix-intrinsics -gvn-hoist -loop-unroll -rpo-functionattrs -mldst-motion -loweratomic -insert-gcov-profiling -simplifycfg -dse -instcombine input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,61.71832275390625,opt -prune-eh -partially-inline-libcalls -slp-vectorizer -redundant-dbg-inst-elim -simplifycfg -prune-eh -loop-unroll -lowerinvoke -coro-elide -licm -loweratomic -gvn-hoist -lowerswitch -dse -loop-idiom -callsite-splitting -name-anon-globals -slsr -gvn -loop-unroll-and-jam -memcpyopt -break-crit-edges -sroa -dce -lower-constant-intrinsics -loop-unroll -sccp -aggressive-instcombine -instcombine -slp-vectorizer -attributor -reassociate -scalarizer -lower-matrix-intrinsics -guard-widening -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,61.74629616737366,opt -simple-loop-unswitch -early-cse-memssa -insert-gcov-profiling -loop-simplifycfg -lowerswitch -speculative-execution -float2int -separate-const-offset-from-gep -loop-data-prefetch -argpromotion -rewrite-statepoints-for-gc -strip-debug-declare -coro-cleanup -instcombine -called-value-propagation -loop-interchange -dse -libcalls-shrinkwrap -instcombine -jump-threading -aggressive-instcombine -functionattrs -loop-predication -sink -rewrite-statepoints-for-gc -redundant-dbg-inst-elim -always-inline -lowerswitch -gvn -simplifycfg -nary-reassociate -mergefunc -adce -cross-dso-cfi -separate-const-offset-from-gep -infer-address-spaces -loop-versioning-licm -partial-inliner -reassociate -loop-versioning-licm -dse -loop-sink -strip-debug-declare -gvn -float2int -loop-sink -attributor -lcssa -sroa -early-cse-memssa -gvn-hoist -jump-threading -redundant-dbg-inst-elim -simple-loop-unswitch -attributor -elim-avail-extern -guard-widening -loop-data-prefetch -aggressive-instcombine -constprop -lower-matrix-intrinsics -break-crit-edges -mem2reg -functionattrs -constprop -ipconstprop -loop-reroll -inject-tli-mappings -loop-data-prefetch -simple-loop-unswitch -loop-unroll-and-jam -rewrite-statepoints-for-gc -always-inline -inferattrs -lower-widenable-condition -licm -lower-matrix-intrinsics -strip -loop-fusion -callsite-splitting -sancov -strip-dead-prototypes -memcpyopt -globaldce -ipconstprop -adce -add-discriminators -instnamer -lower-widenable-condition -globaldce -loop-versioning-licm -pgo-memop-opt -loop-versioning -loop-versioning-licm -jump-threading -reassociate -memcpyopt -always-inline -insert-gcov-profiling -sink -simplifycfg -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,61.75835990905762,opt -partial-inliner -mem2reg -argpromotion -die -newgvn -globaldce -instcombine -called-value-propagation -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,61.77911853790283,opt -loweratomic -bdce -hotcoldsplit -loop-simplify -constmerge -sccp -libcalls-shrinkwrap -lower-matrix-intrinsics -slp-vectorizer -post-inline-ee-instrument -mergefunc -adce -callsite-splitting -coro-elide -instcombine -instnamer -libcalls-shrinkwrap -coro-elide -loop-predication -constmerge -lcssa -loop-vectorize -coro-elide -speculative-execution -sroa -gvn -break-crit-edges -strip-debug-declare -memcpyopt -correlated-propagation -newgvn -loop-reroll -sroa -gvn -prune-eh -mergereturn -lower-guard-intrinsic -coro-cleanup -scalarizer -mergeicmps -loop-unroll -instsimplify -mem2reg -sancov -mergeicmps -bdce -lowerswitch -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,61.824644327163696,opt -correlated-propagation -lower-matrix-intrinsics -canonicalize-aliases -reassociate -lower-matrix-intrinsics -loop-reroll -simplifycfg -loop-versioning-licm -lower-expect -loop-vectorize -loop-distribute -loop-data-prefetch -instnamer -strip-dead-prototypes -globaldce -post-inline-ee-instrument -mergefunc -loop-idiom -instnamer -lower-expect -coro-elide -lowerswitch -canonicalize-aliases -lower-constant-intrinsics -newgvn -bdce -mergereturn -loop-interchange -globalsplit -pgo-memop-opt -load-store-vectorizer -sancov -instsimplify -globaldce -infer-address-spaces -aggressive-instcombine -mergereturn -flattencfg -sroa -dse -loop-unroll-and-jam -callsite-splitting -nary-reassociate -coro-early -sroa -strip-dead-prototypes -bdce -bdce -guard-widening -indvars -break-crit-edges -libcalls-shrinkwrap -simplifycfg -sccp -coro-early -deadargelim -sancov -instcombine input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,61.877750396728516,opt -globalsplit -bdce -adce -loop-unswitch -ee-instrument -coro-cleanup -strip -loop-instsimplify -add-discriminators -globaldce -attributor -argpromotion -lowerinvoke -loop-vectorize -coro-elide -gvn -adce -bdce -loop-unroll -libcalls-shrinkwrap -callsite-splitting -partial-inliner -constprop -break-crit-edges -jump-threading -consthoist -loop-idiom -loop-instsimplify -globaldce -break-crit-edges -cross-dso-cfi -inject-tli-mappings -lower-matrix-intrinsics -libcalls-shrinkwrap -argpromotion -loop-idiom -coro-early -loop-predication -loop-reduce -gvn-hoist -always-inline -lower-constant-intrinsics -dse -strip-dead-prototypes -ipconstprop -reassociate -flattencfg -inferattrs -simple-loop-unswitch -redundant-dbg-inst-elim -gvn-hoist -speculative-execution -guard-widening -simple-loop-unswitch -separate-const-offset-from-gep -loop-sink -cross-dso-cfi -add-discriminators -alignment-from-assumptions -reassociate -adce -sancov -licm -forceattrs -loop-reroll -sroa -loop-load-elim -lower-matrix-intrinsics -loop-deletion -inferattrs -loop-interchange -infer-address-spaces -adce -load-store-vectorizer -lcssa -constmerge -coro-cleanup -aggressive-instcombine -early-cse-memssa -instcombine -canonicalize-aliases -mergefunc -alignment-from-assumptions -irce -alignment-from-assumptions -loop-instsimplify -sink -div-rem-pairs -instsimplify -constmerge -die -mem2reg -callsite-splitting -add-discriminators -instsimplify -loop-distribute -loop-guard-widening -mldst-motion -globaldce -infer-address-spaces -dse -pgo-memop-opt -mergefunc -ee-instrument -loop-unroll -break-crit-edges -strip -inject-tli-mappings -nary-reassociate -lcssa -loop-instsimplify -die -gvn-hoist -loop-simplify -strip-nondebug -loop-simplifycfg -rewrite-statepoints-for-gc -callsite-splitting -gvn-hoist -elim-avail-extern -lower-constant-intrinsics -alignment-from-assumptions -loop-idiom -reg2mem -loop-distribute -early-cse-memssa -always-inline -div-rem-pairs -add-discriminators -lower-widenable-condition -mergereturn -loop-reduce -strip-dead-prototypes -mldst-motion -mem2reg -slp-vectorizer -sroa -dse -reg2mem -partially-inline-libcalls -loop-versioning-licm -loop-deletion -lower-guard-intrinsic -constmerge -float2int -adce -callsite-splitting -loop-reroll -constmerge -loop-simplifycfg -mergereturn -loop-simplifycfg -mergefunc -loop-versioning-licm -cross-dso-cfi -infer-address-spaces -tailcallelim -lowerinvoke -loop-simplify -redundant-dbg-inst-elim -pgo-memop-opt -guard-widening -loop-sink -loop-interchange -gvn-hoist -loop-simplify -jump-threading -sancov -gvn -globaldce -globaldce -jump-threading -globaldce -inline -inline -float2int -loop-interchange -constprop -inject-tli-mappings -barrier -always-inline -insert-gcov-profiling -infer-address-spaces -coro-elide -dce -called-value-propagation -loop-sink -name-anon-globals -globaldce -strip -instcombine -functionattrs -mergereturn -loop-load-elim -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/crc32,1.0,61.91339898109436,opt -lower-expect -mem2reg -inferattrs -lower-guard-intrinsic -name-anon-globals -instsimplify -post-inline-ee-instrument -newgvn -loop-sink -hotcoldsplit -simplifycfg -add-discriminators -instcombine input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.9795918367346942,61.754926919937134,opt -prune-eh -separate-const-offset-from-gep -rpo-functionattrs -dce -argpromotion -name-anon-globals -loop-versioning -correlated-propagation -mem2reg -loop-deletion -simplifycfg -canonicalize-aliases -loop-versioning -lower-widenable-condition -gvn -tailcallelim -elim-avail-extern -gvn-hoist -argpromotion -loop-unroll -globaldce -loop-reroll -bdce -loop-guard-widening -correlated-propagation -reg2mem -prune-eh -redundant-dbg-inst-elim -argpromotion -loop-predication -loop-guard-widening -name-anon-globals -loop-unswitch -always-inline -flattencfg -simplifycfg -nary-reassociate -ipconstprop -forceattrs -partially-inline-libcalls -rpo-functionattrs -indvars -elim-avail-extern -always-inline -functionattrs -mem2reg -flattencfg -reassociate -adce -argpromotion -early-cse-memssa -globalsplit -slsr -early-cse-memssa -break-crit-edges -globalsplit -loop-predication -memcpyopt -load-store-vectorizer -libcalls-shrinkwrap -tailcallelim -insert-gcov-profiling -slp-vectorizer -consthoist -ipconstprop -strip-dead-prototypes -partially-inline-libcalls -separate-const-offset-from-gep -early-cse-memssa -correlated-propagation -load-store-vectorizer -instcombine -loop-idiom -loop-guard-widening -loop-data-prefetch -strip-dead-prototypes -always-inline -mldst-motion -gvn-hoist -loop-unswitch -partially-inline-libcalls -tailcallelim -deadargelim -instsimplify -lcssa -mem2reg -flattencfg -div-rem-pairs -strip-dead-prototypes -globalsplit -memcpyopt -strip-dead-prototypes -loop-instsimplify -loop-instsimplify -deadargelim -mergereturn -lower-matrix-intrinsics -simplifycfg -deadargelim -dse -loop-versioning -loop-simplify -globaldce -tailcallelim -break-crit-edges -break-crit-edges -lower-guard-intrinsic -infer-address-spaces -lower-matrix-intrinsics -rpo-functionattrs -coro-elide -forceattrs -called-value-propagation -loop-load-elim -loop-reduce -correlated-propagation -coro-early -newgvn -callsite-splitting -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.9795918367346942,61.764912128448486,opt -sancov -inferattrs -adce -loop-load-elim -argpromotion -redundant-dbg-inst-elim -constprop -rewrite-statepoints-for-gc -libcalls-shrinkwrap -always-inline -nary-reassociate -forceattrs -loop-simplifycfg -reassociate -lower-expect -coro-early -lowerswitch -jump-threading -globalsplit -reassociate -loop-load-elim -loop-versioning-licm -strip-debug-declare -coro-elide -sancov -barrier -loop-guard-widening -callsite-splitting -loop-data-prefetch -mem2reg -tailcallelim -float2int -insert-gcov-profiling -slsr -called-value-propagation -sccp -float2int -sroa -div-rem-pairs -mergefunc -loop-fusion -mergeicmps -libcalls-shrinkwrap -loop-load-elim -gvn-hoist -loop-sink -constmerge -instsimplify -pgo-memop-opt -mem2reg -loop-sink -flattencfg -lower-widenable-condition -flattencfg -load-store-vectorizer -memcpyopt -inferattrs -constmerge -loop-interchange -loop-reduce -rewrite-statepoints-for-gc -attributor -rpo-functionattrs -lower-expect -sancov -loop-distribute -strip -strip-nondebug -loop-interchange -gvn -scalarizer -insert-gcov-profiling -add-discriminators -add-discriminators -infer-address-spaces -break-crit-edges -bdce -loop-reroll -rpo-functionattrs -sroa -instnamer -constmerge -lower-widenable-condition -name-anon-globals -functionattrs -called-value-propagation -sccp -prune-eh -instcombine -lower-widenable-condition -canonicalize-aliases -mem2reg -globalsplit -slsr -partially-inline-libcalls -post-inline-ee-instrument -sroa -early-cse-memssa -add-discriminators -instsimplify -insert-gcov-profiling -mergereturn -always-inline -adce -lcssa -mergereturn -loop-idiom -indvars -libcalls-shrinkwrap -globaldce -coro-cleanup -coro-cleanup -mergefunc -canonicalize-aliases -sccp -inject-tli-mappings -lower-expect -loop-reroll -instnamer -simplifycfg -correlated-propagation input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.9285714285714286,62.132272481918335,opt -loop-guard-widening -consthoist -lower-expect -indvars -loop-reduce -simplifycfg -callsite-splitting -lower-matrix-intrinsics -correlated-propagation -reassociate -mldst-motion -ipconstprop -irce -lower-matrix-intrinsics -mergeicmps -globalopt -lowerswitch -bdce -strip-nondebug -partially-inline-libcalls -div-rem-pairs -forceattrs -globalsplit -barrier -functionattrs -loop-predication -loop-versioning-licm -libcalls-shrinkwrap -strip-debug-declare -constmerge -ipsccp -alignment-from-assumptions -ee-instrument -sancov -jump-threading -coro-split -gvn-hoist -die -bdce -loweratomic -dse -instsimplify -name-anon-globals -dce -tailcallelim -mergeicmps -callsite-splitting -speculative-execution -callsite-splitting -consthoist -irce -coro-early -mergereturn -loop-versioning-licm -loop-idiom -add-discriminators -globalsplit -loop-deletion -guard-widening -lower-expect -rewrite-statepoints-for-gc -loop-guard-widening -irce -nary-reassociate -dse -lowerinvoke -gvn -lower-constant-intrinsics -load-store-vectorizer -loop-simplify -lower-guard-intrinsic -partially-inline-libcalls -deadargelim -functionattrs -lower-widenable-condition -always-inline -ipconstprop -loop-simplify -aggressive-instcombine -sroa -div-rem-pairs -lower-guard-intrinsic -coro-elide -forceattrs -mergereturn -called-value-propagation -consthoist -lower-expect -simple-loop-unswitch -break-crit-edges -scalarizer -instcombine -mergereturn -loop-instsimplify -lower-widenable-condition -constprop -strip-dead-prototypes -flattencfg -loop-rotate -elim-avail-extern -slsr -rpo-functionattrs -forceattrs -strip-nondebug -tailcallelim -attributor -barrier -argpromotion -loop-unroll -nary-reassociate -die -libcalls-shrinkwrap -loop-versioning-licm -break-crit-edges -early-cse-memssa -rpo-functionattrs -correlated-propagation -rewrite-statepoints-for-gc -guard-widening -infer-address-spaces -reassociate -loop-deletion -callsite-splitting -die -simplifycfg -cross-dso-cfi -ipconstprop -inject-tli-mappings -barrier -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.9846938775510204,61.58521580696106,opt -hotcoldsplit -correlated-propagation -die -loop-versioning -mem2reg -early-cse-memssa -loop-load-elim -cross-dso-cfi -strip -tailcallelim -coro-cleanup -inferattrs -infer-address-spaces -functionattrs -loop-deletion -lower-expect -forceattrs -sroa -loop-simplifycfg -rpo-functionattrs -loop-simplifycfg -loop-distribute -mldst-motion -strip-debug-declare -div-rem-pairs -indvars -simple-loop-unswitch -lowerinvoke -lower-guard-intrinsic -globalopt -loop-data-prefetch -globaldce -always-inline -adce -lower-constant-intrinsics -newgvn -coro-cleanup -sccp -coro-cleanup -always-inline -ee-instrument -separate-const-offset-from-gep -tailcallelim -loop-idiom -adce -bdce -mergereturn -lower-matrix-intrinsics -redundant-dbg-inst-elim -loop-interchange -loop-simplifycfg -early-cse-memssa -nary-reassociate -alignment-from-assumptions -loop-deletion -loop-vectorize -strip -reassociate -break-crit-edges -load-store-vectorizer -elim-avail-extern -sccp -called-value-propagation -slsr -flattencfg -instcombine -cross-dso-cfi -name-anon-globals -simple-loop-unswitch -float2int -adce -correlated-propagation -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.9846938775510204,61.78147768974304,opt -loop-unroll-and-jam -simplifycfg -lower-guard-intrinsic -consthoist -lower-matrix-intrinsics -div-rem-pairs -loop-sink -early-cse-memssa -attributor -loop-unroll-and-jam -instnamer -globalopt -div-rem-pairs -dse -coro-early -licm -lowerswitch -loop-interchange -irce -loop-unswitch -called-value-propagation -canonicalize-aliases -loop-distribute -globalsplit -strip-nondebug -mldst-motion -lower-matrix-intrinsics -licm -mldst-motion -attributor -prune-eh -ipconstprop -loop-predication -div-rem-pairs -argpromotion -tailcallelim -consthoist -prune-eh -licm -loop-simplifycfg -die -loop-guard-widening -reassociate -consthoist -die -tailcallelim -ee-instrument -strip-debug-declare -consthoist -nary-reassociate -forceattrs -simplifycfg -strip-debug-declare -jump-threading -dse -sancov -mem2reg -irce -loop-guard-widening -mldst-motion -loop-idiom -loop-sink -prune-eh -deadargelim -separate-const-offset-from-gep -lowerinvoke -newgvn -elim-avail-extern -aggressive-instcombine -load-store-vectorizer -sroa -mldst-motion -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.9846938775510204,61.819502115249634,opt -elim-avail-extern -tailcallelim -indvars -loop-reduce -loop-reduce -loop-fusion -scalarizer -coro-elide -load-store-vectorizer -ipsccp -loop-simplifycfg -lower-expect -loop-interchange -argpromotion -memcpyopt -aggressive-instcombine -alignment-from-assumptions -aggressive-instcombine -loop-reduce -barrier -speculative-execution -speculative-execution -lower-guard-intrinsic -canonicalize-aliases -pgo-memop-opt -barrier -scalarizer -adce -ipsccp -loop-distribute -die -break-crit-edges -attributor -infer-address-spaces -loop-vectorize -mldst-motion -simple-loop-unswitch -mergefunc -break-crit-edges -simple-loop-unswitch -strip-nondebug -loop-simplifycfg -sroa -infer-address-spaces -sccp -bdce -globalsplit -loop-unroll -bdce -guard-widening -loop-simplify -rpo-functionattrs -redundant-dbg-inst-elim -argpromotion -lowerswitch -coro-split -forceattrs -lower-matrix-intrinsics -functionattrs -lower-constant-intrinsics -loop-idiom -post-inline-ee-instrument -mergefunc -loop-guard-widening -post-inline-ee-instrument -constmerge -deadargelim -pgo-memop-opt -loop-simplify -loop-sink -globalsplit -coro-cleanup -load-store-vectorizer -attributor -functionattrs -forceattrs -dse -forceattrs -constprop -correlated-propagation -gvn-hoist -licm -instsimplify -newgvn -mldst-motion -coro-cleanup -div-rem-pairs -separate-const-offset-from-gep -functionattrs -coro-split -name-anon-globals -mergereturn -strip-nondebug -canonicalize-aliases -cross-dso-cfi -instcombine -memcpyopt -coro-cleanup -globalopt -loop-predication -early-cse-memssa -pgo-memop-opt -sccp -sancov -early-cse-memssa -canonicalize-aliases -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.9846938775510206,61.72368288040161,opt -redundant-dbg-inst-elim -strip-debug-declare -float2int -coro-elide -coro-early -ipsccp -memcpyopt -indvars -jump-threading -loop-instsimplify -loop-reduce -mergefunc -div-rem-pairs -sroa -speculative-execution -lower-expect -callsite-splitting -loop-simplifycfg -correlated-propagation -dse -lcssa -redundant-dbg-inst-elim -memcpyopt -libcalls-shrinkwrap -partially-inline-libcalls -memcpyopt -coro-elide -loop-idiom -constmerge -loop-load-elim -loop-instsimplify -constmerge -sink -loop-interchange -correlated-propagation -attributor -rpo-functionattrs -aggressive-instcombine -mldst-motion -sancov -break-crit-edges -loop-fusion -consthoist -redundant-dbg-inst-elim -sccp -lower-matrix-intrinsics -loop-versioning-licm -lowerinvoke -called-value-propagation -cross-dso-cfi -sink -correlated-propagation -loop-fusion -globalsplit -coro-split -globaldce -name-anon-globals -tailcallelim -lowerswitch -globaldce -lowerswitch -reassociate -slp-vectorizer -reg2mem -functionattrs -lowerinvoke -barrier -elim-avail-extern -dce -load-store-vectorizer -coro-early -infer-address-spaces -sroa -scalarizer -loop-reroll -lower-expect -loop-versioning-licm -slsr -loop-reduce -libcalls-shrinkwrap -consthoist -attributor -loop-simplifycfg -loop-deletion -adce -infer-address-spaces -loop-versioning -attributor -lower-constant-intrinsics -load-store-vectorizer -loop-unroll-and-jam -dse -instsimplify -lower-constant-intrinsics -loop-unroll-and-jam -irce -prune-eh -newgvn -simplifycfg -break-crit-edges -irce -dse -lower-constant-intrinsics -always-inline -die -sroa -instcombine -inferattrs -coro-early -loop-reroll -simplifycfg -constprop -rewrite-statepoints-for-gc -redundant-dbg-inst-elim -bdce -float2int -canonicalize-aliases -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.9948979591836733,61.600799798965454,opt -argpromotion -irce -post-inline-ee-instrument -canonicalize-aliases -pgo-memop-opt -rpo-functionattrs -lower-constant-intrinsics -deadargelim -slp-vectorizer -name-anon-globals -loop-simplify -loop-load-elim -canonicalize-aliases -lower-constant-intrinsics -attributor -loop-deletion -globaldce -coro-early -mem2reg -adce -redundant-dbg-inst-elim -loop-versioning-licm -loweratomic -loop-interchange -partially-inline-libcalls -simplifycfg -coro-elide -globalopt -jump-threading -lowerinvoke -post-inline-ee-instrument -callsite-splitting -partially-inline-libcalls -infer-address-spaces -loop-distribute -redundant-dbg-inst-elim -called-value-propagation -mldst-motion -div-rem-pairs -attributor -strip-debug-declare -loop-versioning-licm -sroa -barrier -early-cse-memssa -loop-deletion -guard-widening -gvn-hoist -loop-predication -post-inline-ee-instrument -loop-unroll-and-jam -break-crit-edges -strip-dead-prototypes -strip-debug-declare -ipsccp -loop-unroll-and-jam -loop-fusion -callsite-splitting -loop-reroll -sink -loop-fusion -loop-unroll -early-cse-memssa -strip-dead-prototypes -elim-avail-extern -instsimplify -globalopt -deadargelim -die -argpromotion -called-value-propagation -ipsccp -attributor -argpromotion -loop-versioning-licm -load-store-vectorizer -lowerinvoke -separate-const-offset-from-gep -libcalls-shrinkwrap -loop-unroll -partial-inliner -scalarizer -sccp -callsite-splitting -elim-avail-extern -sroa -die -memcpyopt -deadargelim -slp-vectorizer -ipconstprop -name-anon-globals -sroa -loop-vectorize -loop-versioning-licm -coro-early -loop-reduce -constmerge -sink -loop-versioning -memcpyopt -loop-versioning -elim-avail-extern -loop-data-prefetch -barrier -simple-loop-unswitch -name-anon-globals -ee-instrument -add-discriminators -guard-widening -loop-reroll -loop-instsimplify -forceattrs -guard-widening -mldst-motion -mergefunc -barrier -mem2reg -redundant-dbg-inst-elim -guard-widening -instnamer -loop-reroll -instcombine -irce -mergefunc -strip-debug-declare -partial-inliner -lower-constant-intrinsics -loop-vectorize -instsimplify -newgvn -strip -strip-dead-prototypes -reassociate -functionattrs -tailcallelim -rewrite-statepoints-for-gc -loop-distribute -add-discriminators -lower-constant-intrinsics -functionattrs -guard-widening -loop-versioning -loop-load-elim -mem2reg -lowerinvoke -div-rem-pairs -gvn-hoist -callsite-splitting -constmerge -argpromotion -pgo-memop-opt -tailcallelim -rpo-functionattrs -slp-vectorizer -break-crit-edges -lower-constant-intrinsics -guard-widening -lower-expect -deadargelim -libcalls-shrinkwrap -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.9948979591836736,61.76611328125,opt -loop-idiom -pgo-memop-opt -flattencfg -attributor -flattencfg -strip -loop-deletion -elim-avail-extern -jump-threading -loop-data-prefetch -lower-expect -load-store-vectorizer -strip-debug-declare -partially-inline-libcalls -consthoist -mem2reg -loop-deletion -licm -lowerswitch -gvn-hoist -loop-simplify -mergereturn -alignment-from-assumptions -loop-simplify -mergefunc -loop-fusion -strip-debug-declare -deadargelim -constmerge -strip-debug-declare -consthoist -libcalls-shrinkwrap -partially-inline-libcalls -early-cse-memssa -loop-sink -newgvn -constmerge -strip-nondebug -speculative-execution -load-store-vectorizer -lowerinvoke -adce -always-inline -bdce -always-inline -lower-constant-intrinsics -dce -constprop -coro-early -strip-debug-declare -constprop -pgo-memop-opt -strip-nondebug -loop-sink -memcpyopt -forceattrs -rewrite-statepoints-for-gc -strip-nondebug -loop-vectorize -load-store-vectorizer -coro-elide -coro-cleanup -simple-loop-unswitch -pgo-memop-opt -always-inline -lower-expect -loop-unroll -indvars -loop-data-prefetch -loop-data-prefetch -post-inline-ee-instrument -dce -lower-matrix-intrinsics -canonicalize-aliases -instcombine -loop-instsimplify -irce -loop-guard-widening -mem2reg -correlated-propagation -instsimplify -loop-predication -barrier -callsite-splitting -coro-split -mem2reg -reassociate -reassociate -bdce -loop-data-prefetch -loop-reroll -rpo-functionattrs -correlated-propagation -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/dijkstra,0.9948979591836736,61.780680894851685,opt -tailcallelim -pgo-memop-opt -loop-simplifycfg -loop-instsimplify -coro-elide -hotcoldsplit -correlated-propagation -newgvn -coro-cleanup -nary-reassociate -constprop -coro-early -always-inline -strip-nondebug -functionattrs -lowerswitch -separate-const-offset-from-gep -mergeicmps -simplifycfg -loop-instsimplify -die -ee-instrument -loop-simplifycfg -redundant-dbg-inst-elim -ipsccp -loop-unroll-and-jam -load-store-vectorizer -simple-loop-unswitch -licm -adce -callsite-splitting -prune-eh -flattencfg -inferattrs -ee-instrument -lower-constant-intrinsics -add-discriminators -simplifycfg -loop-reduce -lowerswitch -sancov -loop-reduce -newgvn -alignment-from-assumptions -elim-avail-extern -coro-early -indvars -sroa -speculative-execution -indvars -reassociate -licm -reassociate -constprop -loop-instsimplify -add-discriminators -attributor -called-value-propagation -insert-gcov-profiling -loop-unroll -rewrite-statepoints-for-gc -strip-dead-prototypes -adce -dse -licm -post-inline-ee-instrument -instcombine -simple-loop-unswitch -canonicalize-aliases -lower-widenable-condition -constmerge -newgvn -coro-cleanup -infer-address-spaces -loop-interchange -instsimplify -canonicalize-aliases -loop-versioning -separate-const-offset-from-gep -forceattrs -adce -always-inline -reg2mem -constmerge -sancov -aggressive-instcombine -scalarizer -forceattrs -ipsccp -ee-instrument -scalarizer -reg2mem -redundant-dbg-inst-elim -sroa -inject-tli-mappings -barrier -bdce -flattencfg -nary-reassociate -instnamer -loop-load-elim -reassociate -loop-vectorize -sccp -nary-reassociate -separate-const-offset-from-gep -correlated-propagation -instnamer -strip-debug-declare -barrier -div-rem-pairs -aggressive-instcombine -instsimplify -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/ghostscript,0.9683191859499436,742.1303203105927,opt -loweratomic -dse -add-discriminators -alignment-from-assumptions -attributor -memcpyopt -post-inline-ee-instrument -reg2mem -alignment-from-assumptions -guard-widening -coro-early -infer-address-spaces -elim-avail-extern -simplifycfg -globaldce -mergeicmps -loop-interchange -alignment-from-assumptions -ipsccp -rewrite-statepoints-for-gc -break-crit-edges -lower-matrix-intrinsics -reassociate -dse -loop-simplifycfg -infer-address-spaces -loop-unroll-and-jam -loop-versioning -loop-unswitch -indvars -barrier -flattencfg -newgvn -mergereturn -inject-tli-mappings -lower-matrix-intrinsics -loop-predication -slp-vectorizer -coro-split -gvn-hoist -dse -indvars -coro-split -called-value-propagation -newgvn -loop-unroll-and-jam -guard-widening -lower-expect -slp-vectorizer -sink -alignment-from-assumptions -lower-constant-intrinsics -lower-widenable-condition -loop-simplify -globaldce -attributor -mldst-motion -early-cse-memssa -inject-tli-mappings -strip-dead-prototypes -instnamer -dse -globalopt -ipsccp -float2int -coro-early -argpromotion -slp-vectorizer -correlated-propagation -licm -instnamer -coro-cleanup -mergereturn -irce -globaldce -mergeicmps -instsimplify -sancov -loop-reroll -lcssa -lowerswitch -jump-threading -constprop -die -dse -indvars -strip-dead-prototypes -always-inline -loop-distribute -slsr -mergereturn -lower-expect -loop-simplifycfg -mldst-motion -loop-simplify -strip-dead-prototypes -instsimplify -loop-reroll -separate-const-offset-from-gep -lowerinvoke -float2int -loop-data-prefetch -loop-versioning -mem2reg -gvn-hoist -sccp -functionattrs -loop-unswitch -loop-distribute -flattencfg -insert-gcov-profiling -prune-eh -tailcallelim -inferattrs -always-inline -indvars -dse -aggressive-instcombine -consthoist -post-inline-ee-instrument -ipsccp -lower-expect -globalsplit -globaldce -loop-vectorize -loop-reroll -loop-simplifycfg -loop-unroll -memcpyopt -instsimplify -coro-cleanup -coro-cleanup -loop-reroll -loweratomic -mldst-motion -lower-constant-intrinsics -add-discriminators -tailcallelim -strip -loop-data-prefetch -coro-cleanup -coro-cleanup -bdce -slp-vectorizer -newgvn -attributor -lower-expect -loop-versioning -callsite-splitting -libcalls-shrinkwrap -dse -irce -instcombine -ipconstprop -dse -strip-dead-prototypes -libcalls-shrinkwrap -coro-cleanup -guard-widening -inferattrs -barrier -early-cse-memssa -separate-const-offset-from-gep -lowerswitch -instsimplify -loop-distribute -lower-constant-intrinsics -prune-eh -partially-inline-libcalls -lower-matrix-intrinsics -insert-gcov-profiling -coro-elide -mem2reg -loop-versioning -scalarizer -alignment-from-assumptions -coro-cleanup -consthoist -elim-avail-extern -dce -loop-reduce -lowerswitch -strip-debug-declare -indvars -cross-dso-cfi -loop-instsimplify -globalsplit -loop-deletion -slp-vectorizer -sccp -break-crit-edges -add-discriminators -loop-reduce -indvars -coro-elide -loop-interchange -coro-split -strip-debug-declare -ipconstprop -loop-simplify -globalsplit -coro-elide -sroa -coro-cleanup -flattencfg -loop-data-prefetch -sccp -loweratomic -memcpyopt -loop-vectorize -functionattrs -loop-unroll -canonicalize-aliases -deadargelim -insert-gcov-profiling -irce -mergefunc -loop-interchange -lowerinvoke -ee-instrument -adce -constprop -lcssa -hotcoldsplit -aggressive-instcombine -mem2reg -called-value-propagation -lcssa -tailcallelim -inject-tli-mappings -bdce -sink -dse -inject-tli-mappings -constprop -forceattrs -functionattrs -hotcoldsplit -ipconstprop -consthoist -strip -lower-expect -infer-address-spaces -sroa -mergereturn -dse -newgvn -dse -slsr -loop-fusion -flattencfg -loop-versioning-licm -sancov -always-inline -partially-inline-libcalls -add-discriminators -elim-avail-extern -loop-interchange -sroa -slsr -lower-guard-intrinsic -dce -load-store-vectorizer -simplifycfg -rpo-functionattrs -name-anon-globals -elim-avail-extern -gvn-hoist -cross-dso-cfi -instsimplify -jump-threading input.bc -o output.bc -benchmark://cBench-v1/ghostscript,0.9694556389925783,492.34522247314453,opt -tailcallelim -loop-rotate -adce -constprop -loop-rotate -rewrite-statepoints-for-gc -elim-avail-extern -post-inline-ee-instrument -strip-debug-declare -constprop -functionattrs -sccp -gvn -flattencfg -constprop -loop-instsimplify -separate-const-offset-from-gep -sccp -die -attributor -canonicalize-aliases -indvars -constprop -sink -loop-reroll -elim-avail-extern -loop-instsimplify -rewrite-statepoints-for-gc -tailcallelim -lower-widenable-condition -irce -hotcoldsplit -float2int -coro-early -sancov -ipsccp -loop-deletion -simplifycfg -loop-guard-widening -strip -callsite-splitting -constmerge -loweratomic -loop-deletion -loop-simplifycfg -loop-predication -mergeicmps -post-inline-ee-instrument -sroa -ee-instrument -coro-split -loop-simplify -lcssa -correlated-propagation -mergeicmps -lowerinvoke -instcombine -loop-guard-widening -separate-const-offset-from-gep -lowerswitch -newgvn -instcombine -simplifycfg -deadargelim -inject-tli-mappings -mergeicmps -float2int -lower-matrix-intrinsics -instsimplify input.bc -o output.bc -benchmark://cBench-v1/ghostscript,0.9789275380056125,292.0016040802002,opt -forceattrs -separate-const-offset-from-gep -hotcoldsplit -attributor -indvars -loop-unroll -add-discriminators -licm -canonicalize-aliases -reg2mem -bdce -slp-vectorizer -lower-matrix-intrinsics -loop-reduce -loop-distribute -guard-widening -coro-early -early-cse-memssa -load-store-vectorizer -alignment-from-assumptions -name-anon-globals -argpromotion -loop-load-elim -always-inline -early-cse-memssa -licm -memcpyopt -gvn -name-anon-globals -callsite-splitting -gvn-hoist -loop-instsimplify -gvn-hoist -loop-versioning -mldst-motion -attributor -separate-const-offset-from-gep -loop-fusion -rewrite-statepoints-for-gc -dce -coro-early -forceattrs -loop-sink -dce -lower-expect -consthoist -newgvn -loop-unroll-and-jam -memcpyopt -reassociate -speculative-execution -nary-reassociate -mergefunc -loop-deletion -ipsccp -bdce -tailcallelim -rewrite-statepoints-for-gc -scalarizer -functionattrs -deadargelim -loop-simplify -irce -attributor -name-anon-globals -loop-versioning -loop-vectorize -flattencfg -globalopt -partially-inline-libcalls -coro-early -early-cse-memssa -coro-cleanup -strip-dead-prototypes -name-anon-globals -rpo-functionattrs -lower-constant-intrinsics -redundant-dbg-inst-elim -prune-eh -loop-reroll -separate-const-offset-from-gep -sroa -lowerinvoke -irce -loop-unroll-and-jam -rewrite-statepoints-for-gc -coro-split -inject-tli-mappings -name-anon-globals -cross-dso-cfi -mergeicmps -aggressive-instcombine -loop-vectorize -memcpyopt -globaldce -guard-widening -ipsccp -jump-threading -strip -loop-simplify -mergereturn -instcombine -gvn -loop-vectorize -bdce -nary-reassociate -barrier -dse input.bc -o output.bc -benchmark://cBench-v1/ghostscript,0.9792815868381253,275.35339760780334,opt -rewrite-statepoints-for-gc -loop-unroll-and-jam -partially-inline-libcalls -coro-elide -globalopt -alignment-from-assumptions -div-rem-pairs -lowerinvoke -inferattrs -lower-constant-intrinsics -loop-load-elim -instnamer -loweratomic -constmerge -loop-vectorize -post-inline-ee-instrument -loop-vectorize -loop-reroll -instnamer -loop-simplify -coro-elide -loop-unroll -loop-versioning -partial-inliner -loop-deletion -rpo-functionattrs -simplifycfg -loweratomic -jump-threading -reg2mem -loop-unroll-and-jam -indvars -instsimplify -ipconstprop -inject-tli-mappings -callsite-splitting -called-value-propagation -float2int -break-crit-edges -correlated-propagation -coro-early -infer-address-spaces -strip-dead-prototypes -loop-idiom -loop-interchange -memcpyopt -dce -loop-unroll -consthoist -lower-expect -mergereturn -dce -loop-fusion -rewrite-statepoints-for-gc -loop-idiom -loop-unroll -instsimplify -aggressive-instcombine -called-value-propagation -sroa -loop-idiom -loop-predication -slp-vectorizer -libcalls-shrinkwrap -strip -loop-versioning-licm -rewrite-statepoints-for-gc -barrier -instcombine -loop-unroll -lower-constant-intrinsics -partial-inliner -simple-loop-unswitch -mergeicmps -mergeicmps -insert-gcov-profiling -loweratomic -mem2reg -hotcoldsplit -lower-matrix-intrinsics -loop-interchange -constprop -simplifycfg -die -alignment-from-assumptions -rpo-functionattrs -newgvn input.bc -o output.bc -benchmark://cBench-v1/ghostscript,0.9801208137003785,266.2952723503113,opt -strip-debug-declare -simple-loop-unswitch -div-rem-pairs -rewrite-statepoints-for-gc -loop-sink -insert-gcov-profiling -simplifycfg -flattencfg -lower-widenable-condition -loop-simplifycfg -strip-nondebug -adce -partial-inliner -strip-dead-prototypes -add-discriminators -rewrite-statepoints-for-gc -lower-widenable-condition -loop-unroll-and-jam -coro-early -coro-split -reassociate -separate-const-offset-from-gep -hotcoldsplit -lowerinvoke -reassociate -strip-debug-declare -rpo-functionattrs -flattencfg -prune-eh -load-store-vectorizer -barrier -strip-debug-declare -sroa -coro-split -gvn -infer-address-spaces -aggressive-instcombine -sink -newgvn -bdce -loweratomic -dce -prune-eh -loop-vectorize -simple-loop-unswitch -redundant-dbg-inst-elim -strip -loop-interchange -rpo-functionattrs -nary-reassociate -ipsccp -rpo-functionattrs -loop-fusion -loop-vectorize -sancov -globaldce -instcombine -loop-unroll -partial-inliner -newgvn -instcombine -functionattrs -insert-gcov-profiling -coro-cleanup -loop-guard-widening -infer-address-spaces -loop-unroll-and-jam -jump-threading -called-value-propagation -loop-simplifycfg -aggressive-instcombine -constprop -loop-vectorize -strip-nondebug -lcssa -elim-avail-extern -alignment-from-assumptions -lower-guard-intrinsic -gvn -slsr -simple-loop-unswitch -redundant-dbg-inst-elim -scalarizer -lcssa -lowerinvoke -redundant-dbg-inst-elim -callsite-splitting -sink -constprop -tailcallelim -lower-guard-intrinsic -redundant-dbg-inst-elim -loop-load-elim -div-rem-pairs -libcalls-shrinkwrap -float2int -loop-vectorize -guard-widening -jump-threading -functionattrs -mldst-motion -gvn -mergereturn -constprop -dse -alignment-from-assumptions -infer-address-spaces -coro-early -simplifycfg -die input.bc -o output.bc -benchmark://cBench-v1/ghostscript,0.9816987350403442,358.9749844074249,opt -mem2reg -lower-expect -sccp -reassociate -mergereturn -correlated-propagation -barrier -attributor -simplifycfg -rpo-functionattrs -rewrite-statepoints-for-gc -aggressive-instcombine -slsr -loop-load-elim -constprop -instsimplify -add-discriminators -lowerinvoke -scalarizer -instsimplify -insert-gcov-profiling -coro-early -loop-sink -deadargelim -aggressive-instcombine -forceattrs -loop-unroll-and-jam -constprop -globalsplit -bdce -mergereturn -speculative-execution -strip-dead-prototypes -lower-matrix-intrinsics -sancov -nary-reassociate -callsite-splitting -ipconstprop -globaldce -simplifycfg -partially-inline-libcalls -redundant-dbg-inst-elim -ipconstprop -separate-const-offset-from-gep -licm -elim-avail-extern -scalarizer -alignment-from-assumptions -ee-instrument -lower-constant-intrinsics -partially-inline-libcalls -hotcoldsplit -instcombine -strip-nondebug -forceattrs -jump-threading -loop-distribute -lcssa -strip-debug-declare -loop-unroll -constmerge -deadargelim -globalopt -constmerge -lower-constant-intrinsics -inject-tli-mappings -mem2reg -sancov -always-inline -constmerge -deadargelim -globaldce -loop-sink -name-anon-globals -loop-instsimplify -post-inline-ee-instrument -loop-simplify -instsimplify -die -strip -mergereturn -mem2reg -elim-avail-extern -lower-matrix-intrinsics -indvars -break-crit-edges -scalarizer -alignment-from-assumptions -tailcallelim -loop-vectorize -speculative-execution -inject-tli-mappings -lowerswitch -instnamer -attributor -gvn-hoist -instcombine -die -coro-split -lower-guard-intrinsic -ee-instrument -sink -loop-versioning -reassociate -loop-versioning -dce -mergereturn -slsr -attributor -mergereturn -name-anon-globals -speculative-execution -constprop -speculative-execution -rpo-functionattrs -loop-vectorize -ipconstprop -canonicalize-aliases -mergeicmps -canonicalize-aliases -loop-simplify -loop-instsimplify -separate-const-offset-from-gep -lower-widenable-condition -newgvn -strip-nondebug -speculative-execution -coro-cleanup -globaldce -loop-sink -bdce -globaldce -dce -instsimplify -globaldce -instcombine -globalopt -callsite-splitting -jump-threading -bdce input.bc -o output.bc -benchmark://cBench-v1/ghostscript,0.985794336967069,404.01260805130005,opt -coro-cleanup -reassociate -called-value-propagation -break-crit-edges -pgo-memop-opt -loop-vectorize -loop-versioning-licm -mem2reg -indvars -mem2reg -sroa -strip-dead-prototypes -mldst-motion -add-discriminators -loop-unswitch -loop-distribute -loop-unroll-and-jam -strip -rewrite-statepoints-for-gc -forceattrs -reassociate -newgvn -jump-threading -attributor -flattencfg -loop-instsimplify -slsr -loop-deletion -loop-reroll -lower-expect -slp-vectorizer -reg2mem -loop-versioning -ipsccp -indvars -newgvn -globalsplit -tailcallelim -speculative-execution -sancov -strip-nondebug -licm -lower-expect -coro-split -globaldce -loop-load-elim -consthoist -loop-reroll -loop-versioning -constmerge -loop-guard-widening -strip -infer-address-spaces -lcssa -loop-versioning -break-crit-edges -ipsccp -loop-sink -post-inline-ee-instrument -loop-deletion -lowerinvoke -forceattrs -ipsccp -add-discriminators -ipconstprop -globaldce -add-discriminators -aggressive-instcombine -inject-tli-mappings -float2int -deadargelim -separate-const-offset-from-gep -strip-debug-declare -mergereturn -licm -name-anon-globals -add-discriminators -sroa -instcombine -strip-nondebug -libcalls-shrinkwrap -consthoist -mergereturn -loop-reroll -separate-const-offset-from-gep -aggressive-instcombine -loop-idiom -sancov -slsr -sink -mergereturn -gvn -rewrite-statepoints-for-gc -partially-inline-libcalls -loop-unroll -canonicalize-aliases -constprop -inject-tli-mappings -loop-unroll-and-jam -flattencfg -prune-eh -dse -licm -adce -loop-deletion -instnamer -div-rem-pairs -add-discriminators -early-cse-memssa -canonicalize-aliases -guard-widening -loop-idiom -lcssa -lowerinvoke -lower-constant-intrinsics -redundant-dbg-inst-elim -reassociate -loop-versioning-licm -name-anon-globals -div-rem-pairs -loop-data-prefetch -mem2reg -loop-sink -instcombine -loop-deletion -lower-widenable-condition -strip -loop-reroll -functionattrs -ipsccp -loop-load-elim -redundant-dbg-inst-elim -flattencfg -deadargelim -jump-threading -bdce -consthoist -nary-reassociate -newgvn input.bc -o output.bc -benchmark://cBench-v1/ghostscript,0.9872236452168439,293.0374753475189,opt -lowerswitch -name-anon-globals -constmerge -canonicalize-aliases -post-inline-ee-instrument -inject-tli-mappings -consthoist -sink -loop-versioning -strip-nondebug -alignment-from-assumptions -sancov -partially-inline-libcalls -correlated-propagation -globaldce -consthoist -aggressive-instcombine -dse -loop-vectorize -lower-expect -div-rem-pairs -loop-deletion -pgo-memop-opt -loop-simplify -memcpyopt -barrier -globalopt -flattencfg -sroa -memcpyopt -loop-deletion -mergereturn -prune-eh -div-rem-pairs -insert-gcov-profiling -break-crit-edges -lowerinvoke -float2int -elim-avail-extern -prune-eh -loop-reduce -loop-predication -tailcallelim -argpromotion -argpromotion -memcpyopt -guard-widening -partially-inline-libcalls -barrier -globaldce -indvars -strip-dead-prototypes -constprop -instcombine -jump-threading -redundant-dbg-inst-elim -float2int -memcpyopt -attributor -die -called-value-propagation -functionattrs -alignment-from-assumptions -speculative-execution -simplifycfg -gvn -lower-expect -add-discriminators -constmerge -loop-load-elim -break-crit-edges -ipsccp -globalsplit -jump-threading -strip -div-rem-pairs -functionattrs -pgo-memop-opt -dce -mem2reg -canonicalize-aliases -instsimplify -functionattrs -mem2reg -hotcoldsplit -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/ghostscript,0.9906854560236381,478.18332958221436,opt -ee-instrument -aggressive-instcombine -lower-constant-intrinsics -post-inline-ee-instrument -simplifycfg -licm -scalarizer -slsr -simple-loop-unswitch -add-discriminators -constmerge -elim-avail-extern -tailcallelim -rewrite-statepoints-for-gc -scalarizer -instsimplify -consthoist -correlated-propagation -mergereturn -callsite-splitting -reassociate -load-store-vectorizer -sroa -inferattrs -div-rem-pairs -die -loop-versioning -strip-nondebug -scalarizer -reassociate -attributor -loop-simplifycfg -loop-unroll-and-jam -flattencfg -argpromotion -instcombine -loop-simplify -loweratomic -speculative-execution -always-inline -strip-nondebug -gvn-hoist -strip -loop-interchange -canonicalize-aliases -load-store-vectorizer -newgvn -lcssa -canonicalize-aliases -break-crit-edges -jump-threading -infer-address-spaces -libcalls-shrinkwrap -correlated-propagation -jump-threading -inject-tli-mappings -name-anon-globals -always-inline -memcpyopt -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/ghostscript,1.001337517811716,288.97663617134094,opt -loop-interchange -lowerswitch -loop-fusion -mergeicmps -constprop -reassociate -attributor -mem2reg -lower-guard-intrinsic -argpromotion -mergefunc -hotcoldsplit -coro-split -name-anon-globals -newgvn -post-inline-ee-instrument -instcombine -always-inline -speculative-execution -coro-elide -prune-eh -nary-reassociate -licm -prune-eh -canonicalize-aliases -jump-threading -canonicalize-aliases -instsimplify -sink -dce -strip-dead-prototypes -strip -name-anon-globals -memcpyopt -forceattrs -gvn-hoist -post-inline-ee-instrument -canonicalize-aliases -redundant-dbg-inst-elim -prune-eh -sroa -simplifycfg -functionattrs -infer-address-spaces -lower-guard-intrinsic -add-discriminators -loop-instsimplify -mem2reg -irce -simple-loop-unswitch -flattencfg -newgvn -newgvn input.bc -o output.bc -benchmark://cBench-v1/gsm,1.049551792828685,62.63266634941101,opt -called-value-propagation -dce -gvn-hoist -irce -sroa -argpromotion -lcssa -barrier -adce -nary-reassociate -ipconstprop -loop-unroll-and-jam -licm -adce -bdce -lower-widenable-condition -cross-dso-cfi -aggressive-instcombine -loop-reroll -memcpyopt -mldst-motion -loop-unroll -loop-simplifycfg -guard-widening -loop-reroll -loop-distribute -globalsplit -loop-fusion -slsr -newgvn -argpromotion -loop-interchange -coro-cleanup -div-rem-pairs -adce -sink -canonicalize-aliases -strip-dead-prototypes -slp-vectorizer -simplifycfg -gvn-hoist -coro-split -functionattrs -loop-vectorize -loop-reroll -globalopt -coro-cleanup -lower-constant-intrinsics -loop-reroll -load-store-vectorizer -inferattrs -reassociate -instsimplify -coro-elide -strip-nondebug -instcombine -loop-instsimplify -lower-expect -pgo-memop-opt -loop-interchange -early-cse-memssa -loop-vectorize -elim-avail-extern -consthoist -consthoist -slsr -loop-unswitch -loop-distribute -guard-widening -loop-fusion -coro-split -gvn-hoist -lower-guard-intrinsic -canonicalize-aliases -lower-guard-intrinsic -simplifycfg -jump-threading input.bc -o output.bc -benchmark://cBench-v1/gsm,1.0515438247011952,64.79662609100342,opt -canonicalize-aliases -nary-reassociate -loop-load-elim -slp-vectorizer -globalsplit -loop-distribute -correlated-propagation -argpromotion -instcombine -sroa -ipsccp -loop-versioning -ipsccp -loop-unroll-and-jam -adce -always-inline -argpromotion -partially-inline-libcalls -dse -rpo-functionattrs -instcombine -sancov -loop-instsimplify -barrier -attributor -insert-gcov-profiling -div-rem-pairs -load-store-vectorizer -loop-versioning-licm -constmerge -coro-elide -loop-load-elim -consthoist -simplifycfg -separate-const-offset-from-gep -infer-address-spaces -lower-widenable-condition -loop-deletion -mergefunc -loop-instsimplify -load-store-vectorizer -consthoist -irce -post-inline-ee-instrument -callsite-splitting -cross-dso-cfi -pgo-memop-opt -strip -simplifycfg -guard-widening -strip-nondebug -load-store-vectorizer -loop-reduce -mergereturn -ipconstprop -mergereturn -loop-sink -flattencfg -float2int -lowerinvoke -infer-address-spaces -simple-loop-unswitch -gvn -constmerge -mem2reg -mergereturn -sccp -guard-widening -name-anon-globals -loop-reduce -slp-vectorizer -indvars -sancov -loop-unswitch -slsr -mldst-motion -loop-instsimplify -always-inline -attributor -instcombine input.bc -o output.bc -benchmark://cBench-v1/gsm,1.052290836653386,63.34988474845886,opt -coro-elide -speculative-execution -mergeicmps -globaldce -speculative-execution -gvn -slp-vectorizer -div-rem-pairs -ipsccp -coro-cleanup -constprop -attributor -strip-dead-prototypes -callsite-splitting -mergefunc -consthoist -dce -aggressive-instcombine -loop-sink -strip -mem2reg -inferattrs -loop-interchange -mem2reg -strip -consthoist -mergereturn -bdce -mem2reg -callsite-splitting -loop-deletion -inferattrs -constmerge -ee-instrument -separate-const-offset-from-gep -loop-simplifycfg -ee-instrument -irce -argpromotion -barrier -separate-const-offset-from-gep -jump-threading -mergeicmps -dce -adce -loop-data-prefetch -loweratomic -coro-split -rpo-functionattrs -ipconstprop -float2int -sroa -lower-matrix-intrinsics -loop-vectorize -dce -guard-widening -coro-elide -simplifycfg -loop-unroll-and-jam -mem2reg -lower-widenable-condition -jump-threading -inferattrs -mergereturn -functionattrs -loop-guard-widening -loop-fusion -insert-gcov-profiling -irce -loop-simplify -lowerinvoke -constmerge -loop-reroll -strip-dead-prototypes -sroa -mldst-motion -slsr -float2int -loop-simplify -functionattrs -loop-data-prefetch -lower-expect -infer-address-spaces -tailcallelim -instsimplify -cross-dso-cfi -dce -irce -instcombine -coro-split -newgvn -loop-versioning -always-inline -lower-matrix-intrinsics -mergeicmps -functionattrs -post-inline-ee-instrument -coro-early -mergeicmps -licm -instnamer -slp-vectorizer -speculative-execution -functionattrs -coro-early -loop-versioning -indvars -loop-idiom -globalopt -strip-dead-prototypes -called-value-propagation -name-anon-globals -nary-reassociate -loop-instsimplify -loop-reduce -mergefunc -loop-predication -mergereturn -rpo-functionattrs -libcalls-shrinkwrap -dse -memcpyopt -lower-expect -indvars -dce -instcombine -cross-dso-cfi -die -mldst-motion -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/gsm,1.0586404382470118,62.90404176712036,opt -always-inline -lower-matrix-intrinsics -lcssa -dse -deadargelim -pgo-memop-opt -coro-elide -guard-widening -separate-const-offset-from-gep -insert-gcov-profiling -libcalls-shrinkwrap -separate-const-offset-from-gep -loop-instsimplify -lower-constant-intrinsics -nary-reassociate -coro-early -prune-eh -indvars -loop-unswitch -barrier -sccp -deadargelim -constprop -loop-reroll -sink -loop-versioning-licm -loop-predication -ipsccp -ipconstprop -globalopt -sink -constprop -loop-instsimplify -lowerinvoke -pgo-memop-opt -early-cse-memssa -lowerinvoke -callsite-splitting -deadargelim -pgo-memop-opt -sancov -post-inline-ee-instrument -simple-loop-unswitch -sroa -loop-versioning-licm -loop-interchange -instsimplify -indvars -flattencfg -slp-vectorizer -always-inline -instcombine -infer-address-spaces -add-discriminators -break-crit-edges -ipconstprop -slsr -simplifycfg -correlated-propagation -load-store-vectorizer -instcombine -rewrite-statepoints-for-gc -lower-widenable-condition -instcombine -div-rem-pairs -elim-avail-extern input.bc -o output.bc -benchmark://cBench-v1/gsm,1.0632470119521908,65.17371106147766,opt -ipconstprop -mem2reg -reg2mem -ee-instrument -inferattrs -break-crit-edges -sancov -loop-vectorize -rpo-functionattrs -consthoist -loop-unroll-and-jam -coro-elide -always-inline -loop-fusion -bdce -loop-idiom -functionattrs -strip-nondebug -constprop -div-rem-pairs -loop-simplify -slp-vectorizer -loop-sink -name-anon-globals -loop-interchange -loop-load-elim -rpo-functionattrs -redundant-dbg-inst-elim -guard-widening -add-discriminators -correlated-propagation -instcombine -loop-predication -memcpyopt -early-cse-memssa -insert-gcov-profiling -rpo-functionattrs -gvn -redundant-dbg-inst-elim -loop-unroll-and-jam -div-rem-pairs -loop-reduce -ipconstprop -consthoist -functionattrs -mergereturn -loop-simplify -loop-guard-widening -sink -newgvn -lower-guard-intrinsic -loop-simplifycfg -separate-const-offset-from-gep -rewrite-statepoints-for-gc -guard-widening -scalarizer -die -strip-debug-declare -loop-rotate -partial-inliner -newgvn -bdce -gvn-hoist -sancov -loop-guard-widening -post-inline-ee-instrument -strip-nondebug -lower-widenable-condition -loop-interchange -indvars -dse -loop-load-elim -ipconstprop -always-inline -partially-inline-libcalls -loop-predication -loop-guard-widening -sroa -load-store-vectorizer -load-store-vectorizer -instcombine -rpo-functionattrs -simple-loop-unswitch -barrier -loop-guard-widening -simple-loop-unswitch -attributor -lcssa -sccp -name-anon-globals -attributor -guard-widening -early-cse-memssa -float2int -infer-address-spaces -simple-loop-unswitch -reassociate -globalsplit -loop-predication -lower-matrix-intrinsics -slp-vectorizer -constmerge -globalopt -instcombine -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/gsm,1.0634960159362552,65.4237732887268,opt -consthoist -loop-instsimplify -rpo-functionattrs -forceattrs -lowerswitch -constprop -loop-unswitch -gvn -argpromotion -div-rem-pairs -loop-unswitch -consthoist -loop-instsimplify -lower-widenable-condition -infer-address-spaces -simple-loop-unswitch -loop-reroll -loop-simplify -always-inline -constmerge -separate-const-offset-from-gep -globalsplit -loop-load-elim -lower-expect -irce -lower-matrix-intrinsics -name-anon-globals -loop-load-elim -early-cse-memssa -float2int -loop-simplify -lowerswitch -simple-loop-unswitch -always-inline -argpromotion -loop-predication -instsimplify -instnamer -globalopt -name-anon-globals -adce -gvn-hoist -reg2mem -redundant-dbg-inst-elim -loop-deletion -newgvn -sccp -called-value-propagation -mem2reg -loop-unswitch -inferattrs -loop-guard-widening -dce -globaldce -nary-reassociate -flattencfg -called-value-propagation -simplifycfg -correlated-propagation -coro-cleanup -sink -mldst-motion -slsr -strip-nondebug -inject-tli-mappings -loop-unroll-and-jam -loop-distribute -speculative-execution -libcalls-shrinkwrap -rewrite-statepoints-for-gc -coro-elide -early-cse-memssa -always-inline -mergeicmps -instsimplify -functionattrs -sroa -partially-inline-libcalls -nary-reassociate -instcombine -attributor -infer-address-spaces -loop-simplify -simple-loop-unswitch -sink -loop-versioning -canonicalize-aliases -redundant-dbg-inst-elim -deadargelim -lower-expect -inject-tli-mappings -lower-widenable-condition -load-store-vectorizer -strip-debug-declare -coro-split -bdce -memcpyopt -ee-instrument -loop-simplify -loop-interchange -strip-nondebug -load-store-vectorizer -loop-load-elim -irce -partially-inline-libcalls -prune-eh -consthoist -gvn-hoist -lcssa -loop-predication -cross-dso-cfi -newgvn -mem2reg -sroa -strip-nondebug -indvars -loop-rotate -flattencfg -globaldce -separate-const-offset-from-gep -ipsccp -redundant-dbg-inst-elim -simple-loop-unswitch -strip-nondebug -strip-dead-prototypes -aggressive-instcombine -barrier -dce -mergereturn -attributor -indvars -loop-unroll-and-jam -callsite-splitting -slp-vectorizer -irce -adce -consthoist -licm -sancov -early-cse-memssa -separate-const-offset-from-gep -gvn -called-value-propagation -dse -lower-widenable-condition -loop-interchange -simple-loop-unswitch -loop-rotate -rpo-functionattrs -sink -lower-widenable-condition -coro-split -mem2reg -loop-interchange -lowerinvoke -constmerge -aggressive-instcombine -libcalls-shrinkwrap -gvn -loop-unroll-and-jam -ipconstprop -ee-instrument -strip-nondebug -lower-constant-intrinsics -inferattrs -hotcoldsplit -canonicalize-aliases -speculative-execution -rpo-functionattrs -separate-const-offset-from-gep -cross-dso-cfi -die -infer-address-spaces -gvn -memcpyopt -instcombine input.bc -o output.bc -benchmark://cBench-v1/gsm,1.0643675298804778,63.232433795928955,opt -indvars -mergereturn -pgo-memop-opt -ipsccp -redundant-dbg-inst-elim -add-discriminators -jump-threading -jump-threading -attributor -break-crit-edges -redundant-dbg-inst-elim -lowerswitch -early-cse-memssa -early-cse-memssa -loop-versioning -strip-nondebug -alignment-from-assumptions -ipsccp -sroa -redundant-dbg-inst-elim -dse -loop-simplifycfg -pgo-memop-opt -rewrite-statepoints-for-gc -name-anon-globals -simplifycfg -redundant-dbg-inst-elim -constmerge -consthoist -elim-avail-extern -die -coro-cleanup -globalopt -loop-deletion -slsr -add-discriminators -insert-gcov-profiling -infer-address-spaces -loop-fusion -consthoist -partially-inline-libcalls -callsite-splitting -consthoist -loop-load-elim -rewrite-statepoints-for-gc -loop-reroll -loweratomic -inferattrs -loop-unswitch -consthoist -lower-widenable-condition -loop-distribute -mergereturn -rpo-functionattrs -dse -instsimplify -loop-simplifycfg -loop-distribute -loop-unswitch -loop-simplify -callsite-splitting -rewrite-statepoints-for-gc -instcombine -insert-gcov-profiling -adce -instsimplify -loop-deletion -cross-dso-cfi -loweratomic -loop-distribute -insert-gcov-profiling -slp-vectorizer -lowerswitch -loop-guard-widening -loop-versioning -cross-dso-cfi -indvars -argpromotion -reassociate -simplifycfg -insert-gcov-profiling -lcssa -sancov -pgo-memop-opt -speculative-execution -sancov -post-inline-ee-instrument -sink -argpromotion -partially-inline-libcalls -ipsccp -lower-expect -dse -canonicalize-aliases -dce -sancov -prune-eh -loop-unswitch -functionattrs -globaldce -correlated-propagation -flattencfg -lower-matrix-intrinsics -strip -loop-instsimplify -simplifycfg -loop-fusion -loop-idiom -aggressive-instcombine -loop-idiom -coro-elide -called-value-propagation -loop-load-elim -coro-elide -lcssa -globalopt -slp-vectorizer -scalarizer -loop-simplifycfg -called-value-propagation -coro-early -mergeicmps -ee-instrument -loop-data-prefetch -pgo-memop-opt -gvn -bdce -loop-simplifycfg -partial-inliner -slp-vectorizer -globalsplit -dce -reassociate -loop-versioning-licm -barrier -coro-split -strip -loop-guard-widening -lcssa -partially-inline-libcalls -loop-data-prefetch -constprop -loop-vectorize -sroa -coro-elide -libcalls-shrinkwrap -loop-instsimplify -mergeicmps -loop-rotate -adce -strip-debug-declare -forceattrs -add-discriminators -instnamer -canonicalize-aliases -constmerge -lcssa -coro-early -simple-loop-unswitch -redundant-dbg-inst-elim -lower-expect -tailcallelim -forceattrs -lcssa -strip -loop-fusion -strip-dead-prototypes -mldst-motion -globalopt -ipsccp -nary-reassociate -separate-const-offset-from-gep -load-store-vectorizer -loop-simplify -loop-interchange -loop-unswitch -indvars -inject-tli-mappings -elim-avail-extern -newgvn -loop-simplify -jump-threading input.bc -o output.bc -benchmark://cBench-v1/gsm,1.065986055776892,65.38988256454468,opt -instcombine -rpo-functionattrs -infer-address-spaces -mergereturn -float2int -argpromotion -loop-unroll -simplifycfg -partially-inline-libcalls -argpromotion -loop-interchange -lcssa -strip-nondebug -strip -globalopt -redundant-dbg-inst-elim -dce -guard-widening -cross-dso-cfi -name-anon-globals -aggressive-instcombine -mergeicmps -redundant-dbg-inst-elim -rpo-functionattrs -loop-simplifycfg -coro-early -lower-matrix-intrinsics -ipsccp -loop-unroll -loop-simplify -speculative-execution -rpo-functionattrs -loop-data-prefetch -lowerinvoke -loop-sink -gvn -called-value-propagation -instcombine -sccp -reassociate -loop-unswitch -barrier -loop-reroll -simple-loop-unswitch -coro-early -loop-fusion -loop-unswitch -instnamer -flattencfg -dse -lower-expect -loop-fusion -reg2mem -mergereturn -coro-elide -coro-split -loop-distribute -tailcallelim -loop-unroll -coro-early -lcssa -slp-vectorizer -partially-inline-libcalls -rpo-functionattrs -cross-dso-cfi -dse -rpo-functionattrs -libcalls-shrinkwrap -lower-constant-intrinsics -guard-widening -inject-tli-mappings -slp-vectorizer -flattencfg -lower-expect -loop-predication -lcssa -rewrite-statepoints-for-gc -constprop -nary-reassociate -simplifycfg -early-cse-memssa -lowerinvoke -sroa -coro-split -rewrite-statepoints-for-gc -sink -loop-guard-widening -loop-unswitch -newgvn -callsite-splitting -elim-avail-extern -prune-eh -strip-nondebug -sink -elim-avail-extern -licm -lower-widenable-condition -dce -loop-load-elim -add-discriminators -dse -name-anon-globals -separate-const-offset-from-gep -early-cse-memssa -strip-debug-declare -globalsplit -sancov -name-anon-globals -rpo-functionattrs -irce -rpo-functionattrs -adce -newgvn -loop-guard-widening -loop-idiom -lcssa -post-inline-ee-instrument -loop-unroll-and-jam -lower-guard-intrinsic -functionattrs -jump-threading -rpo-functionattrs -globalsplit -loop-reroll -sancov -loop-load-elim -post-inline-ee-instrument -rewrite-statepoints-for-gc -lower-constant-intrinsics -name-anon-globals -dse -indvars -loweratomic -strip-dead-prototypes -loop-load-elim -canonicalize-aliases -strip-dead-prototypes -prune-eh -loop-versioning-licm -loop-fusion -sancov -guard-widening -loop-distribute -coro-early -strip-debug-declare -flattencfg -lcssa -separate-const-offset-from-gep -tailcallelim -slp-vectorizer -loop-sink -sancov -mldst-motion -strip-nondebug -dce -irce -simple-loop-unswitch -mem2reg -newgvn -irce -lower-widenable-condition -mem2reg -coro-cleanup -aggressive-instcombine -float2int -consthoist -add-discriminators -slsr -inject-tli-mappings -attributor -guard-widening -mergefunc -inferattrs -adce -aggressive-instcombine -instnamer -slp-vectorizer -redundant-dbg-inst-elim -sink -always-inline -inject-tli-mappings -lower-widenable-condition -loop-unroll-and-jam -ee-instrument -load-store-vectorizer -loop-simplify -gvn-hoist -loop-fusion -dse -loop-distribute -loop-fusion -loop-guard-widening -ipsccp -mem2reg -globalsplit -pgo-memop-opt -lower-widenable-condition -instcombine input.bc -o output.bc -benchmark://cBench-v1/gsm,1.0709661354581672,63.0761559009552,opt -coro-early -loop-fusion -adce -infer-address-spaces -loop-guard-widening -simplifycfg -lower-guard-intrinsic -mergereturn -rpo-functionattrs -speculative-execution -div-rem-pairs -forceattrs -strip -instsimplify -called-value-propagation -loop-unroll-and-jam -globalopt -loop-load-elim -lowerinvoke -hotcoldsplit -gvn-hoist -early-cse-memssa -forceattrs -strip-nondebug -instsimplify -globaldce -sccp -mergereturn -inject-tli-mappings -loop-interchange -sink -speculative-execution -adce -adce -argpromotion -sccp -inferattrs -tailcallelim -loop-vectorize -div-rem-pairs -elim-avail-extern -loop-fusion -instsimplify -sroa -functionattrs -pgo-memop-opt -argpromotion -mergeicmps -constprop -ee-instrument -flattencfg -mldst-motion -loop-idiom -alignment-from-assumptions -adce -barrier -mergefunc -ee-instrument -separate-const-offset-from-gep -gvn-hoist -adce -prune-eh -lcssa -loop-idiom -loop-unswitch -always-inline -slp-vectorizer -instcombine -slp-vectorizer -prune-eh -memcpyopt -alignment-from-assumptions -sccp -partially-inline-libcalls -ee-instrument -inferattrs -rpo-functionattrs -inject-tli-mappings -loop-distribute -instcombine -redundant-dbg-inst-elim -aggressive-instcombine -canonicalize-aliases -rpo-functionattrs -loop-instsimplify -mem2reg -licm -loop-interchange -hotcoldsplit -loop-predication -strip-nondebug -globalopt -memcpyopt -lower-widenable-condition -ee-instrument -called-value-propagation -simple-loop-unswitch -constmerge -slp-vectorizer -loop-simplifycfg -partial-inliner -loop-load-elim -gvn -licm -early-cse-memssa -correlated-propagation -loop-interchange -ee-instrument -float2int -mergereturn -pgo-memop-opt -ipconstprop -mergeicmps -die -ee-instrument -load-store-vectorizer -ipsccp -infer-address-spaces -callsite-splitting -flattencfg -loop-versioning-licm -sink -infer-address-spaces -loop-reroll -coro-early -loop-instsimplify -float2int -gvn-hoist -elim-avail-extern -bdce -lower-guard-intrinsic -loop-fusion -aggressive-instcombine -flattencfg -gvn -coro-early -deadargelim -adce -sancov -rpo-functionattrs -pgo-memop-opt -adce -loweratomic -ipsccp -guard-widening -simple-loop-unswitch -jump-threading -adce -loop-sink -early-cse-memssa -simplifycfg -coro-early -loop-idiom -early-cse-memssa -coro-cleanup -indvars -infer-address-spaces -infer-address-spaces -lower-expect -mem2reg -sancov -loop-interchange -loop-versioning -mergefunc -post-inline-ee-instrument -loop-versioning -loop-reroll -ipsccp -ee-instrument -nary-reassociate -hotcoldsplit -slp-vectorizer -strip-debug-declare -gvn-hoist -strip-nondebug -sancov -loop-distribute -loop-idiom -strip-debug-declare -reassociate -adce -newgvn -loop-fusion -mem2reg -memcpyopt -strip-dead-prototypes -instnamer -guard-widening -sroa -loop-simplify -rpo-functionattrs -slp-vectorizer -post-inline-ee-instrument -lower-constant-intrinsics -constmerge -loop-load-elim -ipsccp -loop-versioning -hotcoldsplit -loop-simplifycfg -mergeicmps -loop-idiom -rpo-functionattrs -constmerge -die -attributor -lower-expect -instcombine input.bc -o output.bc -benchmark://cBench-v1/gsm,1.0743276892430278,63.134528160095215,opt -simple-loop-unswitch -constprop -gvn-hoist -name-anon-globals -indvars -always-inline -name-anon-globals -instcombine -always-inline -simplifycfg -pgo-memop-opt -rewrite-statepoints-for-gc -loop-distribute -nary-reassociate -name-anon-globals -mergefunc -callsite-splitting -loop-rotate -loop-predication -alignment-from-assumptions -forceattrs -reg2mem -redundant-dbg-inst-elim -reg2mem -barrier -slsr -lower-widenable-condition -loop-reduce -loop-idiom -constprop -strip -tailcallelim -simplifycfg -callsite-splitting -loop-simplifycfg -mergeicmps -loop-rotate -mem2reg -coro-early -alignment-from-assumptions -loop-simplify -simplifycfg -dse -loop-data-prefetch -simple-loop-unswitch -loop-simplify -constprop -loop-guard-widening -cross-dso-cfi -sink -globalsplit -strip -instcombine -adce -always-inline -inject-tli-mappings -speculative-execution -instnamer -barrier -loop-simplifycfg -newgvn -name-anon-globals -lowerinvoke -tailcallelim -gvn -loop-sink -hotcoldsplit -slp-vectorizer -loop-unswitch -coro-split -canonicalize-aliases -loop-unroll-and-jam -dse -lower-widenable-condition -lower-matrix-intrinsics -insert-gcov-profiling -loop-unroll-and-jam -loop-instsimplify -strip-debug-declare -flattencfg -correlated-propagation -guard-widening -coro-elide -functionattrs -argpromotion -flattencfg -newgvn -strip-debug-declare -loop-data-prefetch -loop-unroll-and-jam -div-rem-pairs -insert-gcov-profiling -sccp -float2int -canonicalize-aliases -ee-instrument -loop-fusion -sancov -loop-versioning-licm -globalsplit -loop-unswitch -partial-inliner -deadargelim -functionattrs -lowerinvoke -loop-deletion -coro-early -jump-threading -globalsplit -coro-elide -ipsccp -redundant-dbg-inst-elim -prune-eh -coro-early -ee-instrument -strip -libcalls-shrinkwrap -rpo-functionattrs -insert-gcov-profiling -mergeicmps -loop-interchange -adce -strip-nondebug -tailcallelim -nary-reassociate -loop-reroll -mldst-motion -coro-cleanup -reg2mem -coro-early -rpo-functionattrs -loop-fusion -loop-guard-widening -redundant-dbg-inst-elim -bdce -load-store-vectorizer -called-value-propagation -loweratomic -jump-threading -constprop -float2int -globalopt -speculative-execution -guard-widening -argpromotion -lower-constant-intrinsics -called-value-propagation -callsite-splitting -loop-load-elim -loop-sink -loop-distribute -mergereturn -load-store-vectorizer -div-rem-pairs -partial-inliner -alignment-from-assumptions -gvn-hoist -correlated-propagation -instnamer -scalarizer -loop-sink -mem2reg -libcalls-shrinkwrap -sroa -partially-inline-libcalls -coro-split -always-inline -globalsplit -separate-const-offset-from-gep -loop-guard-widening -forceattrs -loop-unroll-and-jam -loop-unswitch -licm -instcombine -slsr -callsite-splitting -pgo-memop-opt -coro-cleanup -cross-dso-cfi -rpo-functionattrs -loop-load-elim -loop-idiom -globalopt -dce -die -gvn-hoist -newgvn -reassociate -loop-simplifycfg -load-store-vectorizer -licm -loweratomic -aggressive-instcombine -loop-unswitch -mergeicmps -flattencfg -mldst-motion -globaldce -loop-reroll -loop-vectorize -lower-guard-intrinsic -loop-unswitch -early-cse-memssa -slp-vectorizer -instcombine input.bc -o output.bc -benchmark://cBench-v1/ispell,0.9643912737508797,63.807353258132935,opt -instnamer -lcssa -infer-address-spaces -lower-guard-intrinsic -loop-simplify -slp-vectorizer -deadargelim -adce -barrier -inferattrs -early-cse-memssa -separate-const-offset-from-gep -sccp -strip -mergereturn -sroa -sroa -instcombine -separate-const-offset-from-gep -float2int -simple-loop-unswitch -correlated-propagation -loop-reduce -pgo-memop-opt -alignment-from-assumptions -coro-early -loop-vectorize -constprop -sccp -mergereturn -argpromotion -instsimplify -jump-threading -early-cse-memssa -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/ispell,0.9748064743138635,64.32104349136353,opt -strip-nondebug -indvars -coro-elide -flattencfg -deadargelim -tailcallelim -tailcallelim -prune-eh -loweratomic -separate-const-offset-from-gep -lower-constant-intrinsics -loop-interchange -insert-gcov-profiling -lower-matrix-intrinsics -sroa -redundant-dbg-inst-elim -simplifycfg -inferattrs -loop-load-elim -gvn-hoist -slsr -libcalls-shrinkwrap -constprop -loop-unroll -instcombine -attributor -strip-debug-declare -loop-versioning-licm -loop-fusion -lcssa -strip -ee-instrument -sink -redundant-dbg-inst-elim -loop-interchange -consthoist -globalopt -loop-deletion -constmerge -sroa -prune-eh -sccp -globalsplit -mergeicmps -prune-eh -simplifycfg -coro-split -lowerinvoke -cross-dso-cfi -mergereturn -consthoist -slsr -simplifycfg -float2int -deadargelim -speculative-execution -loop-distribute -loop-fusion -loop-fusion -div-rem-pairs -loop-unroll-and-jam -gvn-hoist -loop-unroll -strip-debug-declare -loop-idiom -constmerge -ee-instrument -loop-sink -loweratomic -strip-debug-declare -mergereturn -inject-tli-mappings -canonicalize-aliases -loop-reroll -loop-unroll-and-jam -name-anon-globals -guard-widening -jump-threading -break-crit-edges -mergeicmps -canonicalize-aliases -elim-avail-extern -lower-expect -sccp -ipsccp -loop-simplifycfg -loop-unroll -scalarizer -strip-nondebug -loop-unroll -hotcoldsplit -mldst-motion -inferattrs -aggressive-instcombine -called-value-propagation -instcombine -coro-split -tailcallelim -sancov -newgvn -scalarizer -lower-widenable-condition -gvn -separate-const-offset-from-gep -lower-matrix-intrinsics -newgvn -add-discriminators -lower-matrix-intrinsics -pgo-memop-opt -callsite-splitting -loop-unroll-and-jam -sroa -lower-expect -functionattrs -sink -loop-guard-widening -coro-cleanup -functionattrs -lower-widenable-condition -irce -cross-dso-cfi -reassociate -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/ispell,0.9791695988740322,64.13968276977539,opt -name-anon-globals -break-crit-edges -coro-early -loop-guard-widening -partial-inliner -slp-vectorizer -loweratomic -loop-reduce -partial-inliner -sroa -instcombine -correlated-propagation -sccp -strip-nondebug -simplifycfg -mergeicmps -inject-tli-mappings -slsr -loop-versioning-licm -alignment-from-assumptions -loop-unroll-and-jam -newgvn -instsimplify -sroa -scalarizer -instcombine -ee-instrument -scalarizer -irce -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/ispell,0.9847994370161856,66.86581897735596,opt -redundant-dbg-inst-elim -lower-widenable-condition -strip -nary-reassociate -loop-reduce -nary-reassociate -loop-load-elim -simple-loop-unswitch -loop-versioning-licm -redundant-dbg-inst-elim -scalarizer -nary-reassociate -instnamer -simplifycfg -break-crit-edges -loop-load-elim -indvars -load-store-vectorizer -dse -lower-matrix-intrinsics -lower-constant-intrinsics -pgo-memop-opt -slsr -instsimplify -sink -loop-predication -loweratomic -float2int -constmerge -speculative-execution -loop-reroll -callsite-splitting -always-inline -consthoist -redundant-dbg-inst-elim -cross-dso-cfi -inferattrs -globaldce -ipsccp -mergeicmps -instsimplify -constprop -redundant-dbg-inst-elim -sroa -globalopt -div-rem-pairs -coro-elide -early-cse-memssa -loop-versioning-licm -inferattrs -scalarizer -globalopt -loop-versioning -rpo-functionattrs -load-store-vectorizer -barrier -globalopt -irce -redundant-dbg-inst-elim -ipconstprop -guard-widening -post-inline-ee-instrument -globalopt -mem2reg -coro-cleanup -sroa -deadargelim -instsimplify -add-discriminators -constprop -alignment-from-assumptions -partially-inline-libcalls -aggressive-instcombine -reg2mem -early-cse-memssa -strip -mem2reg -newgvn -coro-split -always-inline -strip-nondebug -rewrite-statepoints-for-gc -licm -functionattrs -instsimplify -slsr -hotcoldsplit -dce -infer-address-spaces -coro-cleanup -float2int -post-inline-ee-instrument -loop-instsimplify -elim-avail-extern -globaldce -functionattrs -sink -guard-widening -loop-sink -add-discriminators -inject-tli-mappings -globalopt -indvars -instnamer -instcombine -ipconstprop -strip-debug-declare -functionattrs -jump-threading -gvn -always-inline -prune-eh -attributor -slp-vectorizer -newgvn input.bc -o output.bc -benchmark://cBench-v1/ispell,0.9855031667839551,64.19602680206299,opt -functionattrs -barrier -globalsplit -speculative-execution -correlated-propagation -separate-const-offset-from-gep -loop-interchange -constmerge -memcpyopt -loop-distribute -redundant-dbg-inst-elim -loop-instsimplify -lower-expect -alignment-from-assumptions -early-cse-memssa -indvars -gvn-hoist -globalsplit -partially-inline-libcalls -constprop -loop-unswitch -strip -post-inline-ee-instrument -loop-versioning -sccp -argpromotion -instcombine -argpromotion -lowerinvoke -loop-deletion -elim-avail-extern -sroa -partially-inline-libcalls -reassociate -dse -scalarizer -strip-nondebug -loop-guard-widening -strip-dead-prototypes -gvn -loop-data-prefetch -sccp -name-anon-globals -coro-early -simplifycfg -called-value-propagation -instnamer -load-store-vectorizer -forceattrs -mergefunc -prune-eh -lower-constant-intrinsics -ipconstprop -newgvn -jump-threading -called-value-propagation -instcombine input.bc -o output.bc -benchmark://cBench-v1/ispell,0.9874736101337088,64.0391092300415,opt -loop-idiom -float2int -aggressive-instcombine -nary-reassociate -simple-loop-unswitch -mldst-motion -loop-sink -correlated-propagation -insert-gcov-profiling -partially-inline-libcalls -lower-widenable-condition -scalarizer -load-store-vectorizer -guard-widening -hotcoldsplit -aggressive-instcombine -redundant-dbg-inst-elim -guard-widening -loop-guard-widening -indvars -inferattrs -sancov -dce -rpo-functionattrs -called-value-propagation -coro-split -callsite-splitting -newgvn -mem2reg -instnamer -instsimplify -partially-inline-libcalls -loop-versioning-licm -deadargelim -instcombine -newgvn -pgo-memop-opt -ipconstprop -pgo-memop-opt -loop-versioning -loweratomic -strip-dead-prototypes -callsite-splitting -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/ispell,0.9894440534834623,65.27008605003357,opt -deadargelim -loop-vectorize -inferattrs -jump-threading -name-anon-globals -coro-cleanup -simplifycfg -jump-threading -gvn-hoist -div-rem-pairs -loop-idiom -reg2mem -loop-unswitch -loop-unswitch -loop-versioning -hotcoldsplit -slp-vectorizer -sink -loop-interchange -sancov -gvn -redundant-dbg-inst-elim -globalsplit -coro-elide -strip-nondebug -lower-constant-intrinsics -loop-versioning -indvars -loop-load-elim -lower-widenable-condition -loop-reroll -partial-inliner -gvn -cross-dso-cfi -always-inline -loop-versioning -argpromotion -loop-unroll-and-jam -strip-debug-declare -lower-guard-intrinsic -barrier -argpromotion -loop-simplifycfg -argpromotion -coro-cleanup -prune-eh -coro-cleanup -coro-early -loop-simplifycfg -break-crit-edges -sccp -ipconstprop -called-value-propagation -inject-tli-mappings -memcpyopt -tailcallelim -argpromotion -tailcallelim -gvn-hoist -dce -elim-avail-extern -post-inline-ee-instrument -slsr -always-inline -indvars -inferattrs -simplifycfg -speculative-execution -always-inline -alignment-from-assumptions -inject-tli-mappings -globalsplit -coro-cleanup -gvn -load-store-vectorizer -insert-gcov-profiling -lowerinvoke -partially-inline-libcalls -instcombine -name-anon-globals -globalsplit -separate-const-offset-from-gep -sccp -forceattrs -coro-elide -barrier -loop-reroll -nary-reassociate -reassociate -callsite-splitting -post-inline-ee-instrument -newgvn -inferattrs -loop-versioning -mergereturn -always-inline -post-inline-ee-instrument -strip -loop-idiom -mem2reg -newgvn -break-crit-edges -scalarizer -reassociate -loop-unroll -strip-nondebug -lower-matrix-intrinsics -rpo-functionattrs -cross-dso-cfi -instcombine -break-crit-edges -dce -inject-tli-mappings -sink -pgo-memop-opt -globalopt -consthoist -loop-idiom -rpo-functionattrs -functionattrs -always-inline -newgvn -float2int -argpromotion -instnamer -hotcoldsplit -simplifycfg -lower-expect -mergefunc input.bc -o output.bc -benchmark://cBench-v1/ispell,0.9952146375791695,65.40430235862732,opt -name-anon-globals -memcpyopt -aggressive-instcombine -float2int -ee-instrument -gvn-hoist -div-rem-pairs -instnamer -prune-eh -forceattrs -coro-cleanup -alignment-from-assumptions -lower-guard-intrinsic -coro-elide -newgvn -prune-eh -sancov -indvars -float2int -loop-guard-widening -loop-simplifycfg -loop-idiom -dse -prune-eh -loop-guard-widening -flattencfg -lower-guard-intrinsic -deadargelim -float2int -simplifycfg -load-store-vectorizer -coro-split -float2int -lowerinvoke -mergefunc -guard-widening -break-crit-edges -inferattrs -mem2reg -instcombine -cross-dso-cfi -insert-gcov-profiling -memcpyopt -gvn-hoist -reg2mem -separate-const-offset-from-gep -elim-avail-extern -sroa -ipconstprop -loop-unroll -pgo-memop-opt -memcpyopt -sancov -newgvn -functionattrs -slp-vectorizer -loop-unroll-and-jam -loop-deletion -rpo-functionattrs -lower-widenable-condition -attributor -loop-simplifycfg -simple-loop-unswitch -loop-idiom -loop-fusion -ipsccp -loop-guard-widening -loop-vectorize -alignment-from-assumptions -insert-gcov-profiling -consthoist -sancov -ee-instrument -loop-deletion -redundant-dbg-inst-elim -insert-gcov-profiling -barrier -consthoist -div-rem-pairs -partial-inliner -lcssa -correlated-propagation -partially-inline-libcalls -lower-constant-intrinsics -callsite-splitting -loop-predication -constmerge -sccp -jump-threading -instsimplify input.bc -o output.bc -benchmark://cBench-v1/ispell,1.0014074595355382,64.54691743850708,opt -callsite-splitting -slp-vectorizer -name-anon-globals -argpromotion -insert-gcov-profiling -inject-tli-mappings -lowerinvoke -sancov -globalopt -strip-dead-prototypes -div-rem-pairs -always-inline -loop-idiom -instnamer -loop-versioning -cross-dso-cfi -sccp -bdce -mergeicmps -slp-vectorizer -pgo-memop-opt -reg2mem -prune-eh -constmerge -constmerge -speculative-execution -strip-nondebug -lower-matrix-intrinsics -early-cse-memssa -mem2reg -loweratomic -sroa -loop-reroll -globalsplit -globalsplit -loop-unroll -newgvn -strip-dead-prototypes -constprop -indvars -simplifycfg -argpromotion -post-inline-ee-instrument -loop-reroll -argpromotion -globalsplit -sancov -early-cse-memssa -loop-simplifycfg -gvn -instcombine -strip-nondebug -lowerinvoke -slp-vectorizer -mldst-motion -loweratomic -reassociate -loop-simplifycfg -rewrite-statepoints-for-gc -loop-sink -break-crit-edges -mergeicmps -jump-threading -loop-distribute -lcssa -canonicalize-aliases -attributor -bdce -lower-expect -coro-split -loop-fusion -guard-widening -instnamer -rpo-functionattrs -strip-dead-prototypes -early-cse-memssa -callsite-splitting -separate-const-offset-from-gep -newgvn -lower-matrix-intrinsics -gvn -mldst-motion -loop-data-prefetch -ipconstprop -dse -strip-nondebug -loop-versioning-licm -newgvn -libcalls-shrinkwrap -early-cse-memssa -dse -attributor -early-cse-memssa -called-value-propagation -lower-matrix-intrinsics -slp-vectorizer -coro-early -slsr -argpromotion -tailcallelim -slsr -jump-threading -coro-early -gvn-hoist -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/ispell,1.0014074595355382,64.55206608772278,opt -memcpyopt -inferattrs -speculative-execution -consthoist -callsite-splitting -flattencfg -loop-simplifycfg -scalarizer -reassociate -mergeicmps -always-inline -gvn-hoist -newgvn -dse -mem2reg -speculative-execution -loop-idiom -loop-simplify -simplifycfg -newgvn -infer-address-spaces -jump-threading -load-store-vectorizer -loop-data-prefetch -sink -insert-gcov-profiling -lower-constant-intrinsics -barrier -loop-idiom -mergefunc -add-discriminators -div-rem-pairs -functionattrs -float2int -deadargelim -licm -scalarizer -forceattrs -loop-predication -instcombine -simplifycfg -loop-vectorize -flattencfg -loop-unroll-and-jam -loop-reroll -guard-widening -loop-distribute -lcssa -div-rem-pairs -coro-cleanup -barrier -strip-dead-prototypes -prune-eh -jump-threading -loop-distribute -licm -argpromotion -forceattrs -guard-widening -lower-widenable-condition -simple-loop-unswitch -redundant-dbg-inst-elim -loop-reduce -forceattrs -dce -instsimplify -load-store-vectorizer -flattencfg -post-inline-ee-instrument -loop-distribute -loop-load-elim -ee-instrument -memcpyopt -loop-versioning-licm -barrier -coro-split -lower-constant-intrinsics -constprop -load-store-vectorizer -rewrite-statepoints-for-gc -loop-load-elim -irce -coro-elide -simple-loop-unswitch -loop-predication -lower-guard-intrinsic -deadargelim -lower-expect -functionattrs -globaldce -newgvn -dce -cross-dso-cfi -loop-simplifycfg -float2int -die -instnamer -memcpyopt -lower-widenable-condition -loop-distribute -strip-debug-declare -coro-elide -barrier -rpo-functionattrs -ee-instrument -instsimplify -bdce -dce -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.0063552097219208,76.24695205688477,opt -sccp -partially-inline-libcalls -barrier -slsr -hotcoldsplit -forceattrs -simple-loop-unswitch -dse -strip-dead-prototypes -rewrite-statepoints-for-gc -hotcoldsplit -die -cross-dso-cfi -sancov -lower-expect -mem2reg -loop-vectorize -newgvn -loop-vectorize -loop-reroll -loop-sink -licm -lowerswitch -bdce -mergeicmps -strip-dead-prototypes -pgo-memop-opt -lowerswitch -mldst-motion -loop-rotate -div-rem-pairs -loop-fusion -forceattrs -loop-unroll-and-jam -coro-split -canonicalize-aliases -scalarizer -dce -constmerge -dse -attributor -reassociate -loop-simplify -jump-threading -speculative-execution -sroa -loop-idiom -name-anon-globals -break-crit-edges -loop-interchange -coro-split -constprop -attributor -simple-loop-unswitch -coro-elide -constmerge -loop-deletion -attributor -licm -post-inline-ee-instrument -pgo-memop-opt -newgvn -loweratomic -loop-versioning-licm -strip-nondebug -load-store-vectorizer -forceattrs -coro-early -break-crit-edges -loop-rotate -slsr -simplifycfg -tailcallelim -sroa -lower-constant-intrinsics -libcalls-shrinkwrap -strip-debug-declare -instcombine input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.006696220975292,73.28315615653992,opt -slp-vectorizer -elim-avail-extern -libcalls-shrinkwrap -load-store-vectorizer -rpo-functionattrs -mem2reg -callsite-splitting -instcombine -constprop -licm -barrier -load-store-vectorizer -functionattrs -sink -redundant-dbg-inst-elim -attributor -jump-threading -coro-cleanup -strip-nondebug -loop-versioning -name-anon-globals -deadargelim -libcalls-shrinkwrap -mergereturn -scalarizer -strip-dead-prototypes -libcalls-shrinkwrap -flattencfg -indvars -loweratomic -loweratomic -infer-address-spaces -canonicalize-aliases -prune-eh -gvn-hoist -ipconstprop -insert-gcov-profiling -newgvn -loop-load-elim -bdce -cross-dso-cfi -infer-address-spaces -lower-expect -prune-eh -globaldce input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.0068822271134945,73.44375777244568,opt -instsimplify -early-cse-memssa -barrier -loop-unswitch -argpromotion -mergereturn -attributor -memcpyopt -float2int -coro-early -redundant-dbg-inst-elim -flattencfg -div-rem-pairs -scalarizer -die -loop-instsimplify -early-cse-memssa -argpromotion -globaldce -break-crit-edges -mergereturn -dse -loop-simplifycfg -inject-tli-mappings -mem2reg -lcssa -argpromotion -indvars -slp-vectorizer -scalarizer -coro-elide -sancov -adce -instnamer -sroa -alignment-from-assumptions -bdce -aggressive-instcombine -ipconstprop -ipsccp -attributor -early-cse-memssa -instcombine -mergefunc -ipconstprop -rpo-functionattrs -infer-address-spaces -jump-threading -instsimplify input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.012245404098335,77.20652055740356,opt -prune-eh -redundant-dbg-inst-elim -strip-nondebug -partially-inline-libcalls -mergeicmps -inferattrs -die -strip-dead-prototypes -newgvn -strip-nondebug -mergefunc -sroa -instsimplify -instnamer -mldst-motion -jump-threading -ee-instrument -die -ipconstprop -argpromotion -scalarizer -coro-early -memcpyopt -loop-instsimplify -barrier -die -loop-deletion -slsr -coro-cleanup -instsimplify -coro-cleanup -instcombine -reg2mem -redundant-dbg-inst-elim -guard-widening -slsr -deadargelim -dse -float2int -attributor -loop-instsimplify -sink -redundant-dbg-inst-elim -indvars -reg2mem -early-cse-memssa -loop-data-prefetch -coro-elide -tailcallelim -slp-vectorizer -consthoist -gvn-hoist -lower-constant-intrinsics -lower-expect -deadargelim -sink -mergefunc -coro-elide -coro-early -insert-gcov-profiling -float2int -inject-tli-mappings -loop-fusion -libcalls-shrinkwrap -loop-simplify -lower-widenable-condition -globaldce -loop-instsimplify -loop-sink -functionattrs -memcpyopt -callsite-splitting -early-cse-memssa -simplifycfg -globaldce -sroa -coro-split -licm -mergereturn -lower-matrix-intrinsics -loop-versioning-licm -name-anon-globals -inferattrs -instcombine -rpo-functionattrs -elim-avail-extern -loop-versioning-licm -consthoist -scalarizer -mergefunc -tailcallelim -barrier -loop-distribute -loop-reroll -irce -loop-interchange -deadargelim -memcpyopt -indvars -float2int -mem2reg -loop-sink -globalopt -pgo-memop-opt -ipconstprop -mldst-motion -reassociate -loop-unroll-and-jam -name-anon-globals -jump-threading input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.0148184890101377,75.44664001464844,opt -lcssa -rewrite-statepoints-for-gc -dse -sancov -inferattrs -inject-tli-mappings -speculative-execution -sccp -flattencfg -dse -lower-widenable-condition -ipsccp -rpo-functionattrs -indvars -load-store-vectorizer -gvn-hoist -ipsccp -callsite-splitting -coro-early -partially-inline-libcalls -loop-versioning -dce -libcalls-shrinkwrap -loop-versioning -strip-debug-declare -coro-cleanup -loop-sink -lower-widenable-condition -load-store-vectorizer -flattencfg -mergefunc -early-cse-memssa -canonicalize-aliases -functionattrs -loop-interchange -loop-instsimplify -guard-widening -ee-instrument -bdce -loop-guard-widening -strip -scalarizer -instsimplify -ipsccp -loop-fusion -correlated-propagation -scalarizer -mergefunc -coro-split -loop-reroll -loop-versioning-licm -constmerge -loop-sink -dse -jump-threading -mldst-motion -separate-const-offset-from-gep -instnamer -post-inline-ee-instrument -tailcallelim -coro-elide -loop-distribute -called-value-propagation -loop-unswitch -speculative-execution -constprop -ipsccp -coro-cleanup -licm -gvn-hoist -loop-unroll-and-jam -mldst-motion -ipconstprop -flattencfg -loop-simplify -reg2mem -loweratomic -loop-interchange -loop-guard-widening -consthoist -cross-dso-cfi -loop-unroll -sroa -pgo-memop-opt -strip-debug-declare -loop-guard-widening -loop-instsimplify -nary-reassociate -forceattrs -loop-vectorize -loop-instsimplify -lcssa -instcombine -libcalls-shrinkwrap -post-inline-ee-instrument -loop-reroll -indvars -name-anon-globals -inferattrs -loop-load-elim -instsimplify -memcpyopt -ee-instrument -loop-unroll-and-jam -adce -constprop -lowerinvoke -ipsccp -consthoist -constmerge -loweratomic -gvn-hoist -slsr -infer-address-spaces -strip-nondebug -pgo-memop-opt -loop-unroll-and-jam -functionattrs -slp-vectorizer -ipsccp -float2int -loop-sink -simplifycfg -correlated-propagation -loop-unroll-and-jam -loop-interchange -loop-guard-widening -loop-sink -div-rem-pairs -called-value-propagation -instcombine -load-store-vectorizer -gvn -globaldce -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.0154075084477787,74.82714986801147,opt -loop-unroll-and-jam -argpromotion -pgo-memop-opt -coro-cleanup -lowerinvoke -loop-reroll -sccp -strip-debug-declare -alignment-from-assumptions -loop-instsimplify -loop-distribute -strip-dead-prototypes -rewrite-statepoints-for-gc -canonicalize-aliases -mergeicmps -post-inline-ee-instrument -early-cse-memssa -bdce -functionattrs -break-crit-edges -loop-deletion -memcpyopt -loop-guard-widening -name-anon-globals -loop-reduce -loop-fusion -canonicalize-aliases -attributor -argpromotion -coro-cleanup -reg2mem -strip-dead-prototypes -add-discriminators -globaldce -loop-interchange -mem2reg -lower-widenable-condition -gvn -partially-inline-libcalls -lower-guard-intrinsic -loop-instsimplify -instsimplify -lower-guard-intrinsic -instcombine -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.0182906035899184,74.4551010131836,opt -attributor -loop-instsimplify -sroa -argpromotion -redundant-dbg-inst-elim -flattencfg -strip -jump-threading -mergeicmps -lower-matrix-intrinsics -scalarizer -nary-reassociate -lower-widenable-condition -barrier -adce -indvars -coro-cleanup -mergeicmps -redundant-dbg-inst-elim -elim-avail-extern -lower-widenable-condition -inferattrs -alignment-from-assumptions -coro-split -ipconstprop -loop-vectorize -forceattrs -loop-versioning-licm -mergeicmps -loop-distribute -inferattrs -instcombine -strip -inject-tli-mappings -lower-expect -indvars -constprop -tailcallelim -loop-fusion -licm -nary-reassociate -elim-avail-extern -ipconstprop -redundant-dbg-inst-elim -gvn-hoist -lower-widenable-condition -sancov -loop-instsimplify -indvars -mldst-motion -newgvn input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.0190346281427287,72.94964694976807,opt -hotcoldsplit -loop-load-elim -mem2reg -redundant-dbg-inst-elim -functionattrs -constprop -guard-widening -mergeicmps -sroa -coro-cleanup -gvn -load-store-vectorizer -called-value-propagation -loweratomic -loop-versioning-licm -ipsccp -inject-tli-mappings -mem2reg -loop-interchange -lowerinvoke -redundant-dbg-inst-elim -jump-threading -tailcallelim -sink -inject-tli-mappings -instcombine -add-discriminators -partially-inline-libcalls -coro-elide -lcssa -infer-address-spaces -jump-threading -break-crit-edges -aggressive-instcombine -infer-address-spaces -early-cse-memssa -elim-avail-extern -redundant-dbg-inst-elim -flattencfg -lowerinvoke -slp-vectorizer -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.0216077130545307,374.86166167259216,opt -sccp -mergereturn -constmerge -reassociate -lowerinvoke -globalopt -coro-cleanup -strip-debug-declare -strip-debug-declare -lower-matrix-intrinsics -functionattrs -jump-threading -ipconstprop -alignment-from-assumptions -loop-versioning-licm -strip -alignment-from-assumptions -ee-instrument -lcssa -dce -rewrite-statepoints-for-gc -ipconstprop -mem2reg -strip -loop-guard-widening -mergereturn -correlated-propagation -instsimplify -name-anon-globals -lower-expect -div-rem-pairs -constprop -lower-matrix-intrinsics -always-inline -guard-widening -newgvn -coro-early -forceattrs -ipconstprop -argpromotion -aggressive-instcombine -correlated-propagation -break-crit-edges -called-value-propagation -strip-debug-declare -lower-matrix-intrinsics -gvn-hoist -gvn-hoist -callsite-splitting -lower-constant-intrinsics -lowerinvoke -tailcallelim -lower-expect -rewrite-statepoints-for-gc -hotcoldsplit -irce -mldst-motion -gvn-hoist -aggressive-instcombine -loop-idiom -globalsplit -instcombine -post-inline-ee-instrument -loop-versioning -aggressive-instcombine -globalsplit -memcpyopt -constprop -infer-address-spaces -early-cse-memssa -partially-inline-libcalls -guard-widening -die -scalarizer -mergefunc -licm -loop-data-prefetch -loop-data-prefetch -loop-deletion -hotcoldsplit -rewrite-statepoints-for-gc -gvn-hoist -scalarizer -lower-constant-intrinsics -constprop -reg2mem -rpo-functionattrs -loop-reduce -loop-unroll-and-jam -lower-widenable-condition -loop-guard-widening -insert-gcov-profiling -speculative-execution -instsimplify -sroa -mergefunc -licm -loop-sink -loop-simplify -globalsplit -lower-matrix-intrinsics -hotcoldsplit -canonicalize-aliases -indvars -die -coro-cleanup -cross-dso-cfi -hotcoldsplit -called-value-propagation -simple-loop-unswitch -simplifycfg -elim-avail-extern input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,1.0307220138264561,76.84722781181335,opt -coro-early -indvars -slp-vectorizer -callsite-splitting -attributor -loop-reroll -lower-constant-intrinsics -instsimplify -consthoist -lcssa -partially-inline-libcalls -alignment-from-assumptions -deadargelim -lower-widenable-condition -loop-versioning -adce -add-discriminators -speculative-execution -loop-predication -die -elim-avail-extern -loop-deletion -licm -loop-load-elim -break-crit-edges -sink -simplifycfg -div-rem-pairs -forceattrs -tailcallelim -strip-dead-prototypes -loweratomic -rpo-functionattrs -constprop -loop-simplifycfg -canonicalize-aliases -nary-reassociate -consthoist -loop-simplifycfg -reg2mem -lcssa -infer-address-spaces -lower-constant-intrinsics -loop-versioning-licm -insert-gcov-profiling -strip-dead-prototypes -loop-idiom -coro-split -strip-nondebug -barrier -ee-instrument -name-anon-globals -sancov -loop-instsimplify -loop-versioning -loop-simplify -loop-deletion -aggressive-instcombine -globalopt -gvn-hoist -sroa -instcombine -correlated-propagation -loop-sink -sccp -simple-loop-unswitch -argpromotion -rewrite-statepoints-for-gc -libcalls-shrinkwrap -gvn-hoist -elim-avail-extern -always-inline -mergereturn -newgvn -sancov -irce -strip -slp-vectorizer -inject-tli-mappings -lower-expect -always-inline -sancov -partially-inline-libcalls -indvars -mem2reg -correlated-propagation -coro-split -loop-load-elim -coro-early -sink -instsimplify -constprop -guard-widening -instsimplify -loop-guard-widening -constmerge -simplifycfg -inferattrs -loop-deletion -memcpyopt -loop-distribute -rewrite-statepoints-for-gc -irce -loop-data-prefetch -inject-tli-mappings -gvn-hoist -strip -slsr -irce -bdce -dse -loop-data-prefetch -loop-reroll -break-crit-edges -simplifycfg -tailcallelim -slp-vectorizer -loop-unroll-and-jam -ipsccp -licm -loweratomic -mldst-motion -always-inline -loop-versioning -sink -lower-guard-intrinsic -loop-sink -lcssa -reassociate -inferattrs -lowerinvoke -rpo-functionattrs -strip-debug-declare -reassociate -dse -globaldce -slsr -mergeicmps -coro-split -flattencfg -forceattrs -speculative-execution -elim-avail-extern -globalopt -memcpyopt -lower-constant-intrinsics -ee-instrument -correlated-propagation -simplifycfg -libcalls-shrinkwrap -libcalls-shrinkwrap -called-value-propagation -redundant-dbg-inst-elim -strip-debug-declare -div-rem-pairs -nary-reassociate input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.014874915483435,77.7471342086792,opt -loop-reroll -mergeicmps -called-value-propagation -loop-vectorize -adce -name-anon-globals -loop-reroll -canonicalize-aliases -tailcallelim -constprop -loop-versioning-licm -loop-deletion -mem2reg -loop-versioning-licm -insert-gcov-profiling -called-value-propagation -loop-deletion -sancov -loop-idiom -lower-guard-intrinsic -speculative-execution -tailcallelim -sink -loop-idiom -inferattrs -gvn -called-value-propagation -coro-split -constprop -barrier -cross-dso-cfi -scalarizer -coro-early -name-anon-globals -mem2reg -lowerinvoke -globalopt -licm -inferattrs -loop-load-elim -loop-unroll -lower-expect -attributor -gvn-hoist -mem2reg -die -mergereturn -rpo-functionattrs -lower-constant-intrinsics -irce -instsimplify -called-value-propagation -reassociate -loop-unroll-and-jam -prune-eh -elim-avail-extern -memcpyopt -instcombine -die -strip-debug-declare -post-inline-ee-instrument -argpromotion -insert-gcov-profiling -lower-matrix-intrinsics -strip-debug-declare -called-value-propagation -coro-cleanup -guard-widening -mergereturn -sancov -loweratomic -mldst-motion -instsimplify -slsr -globaldce -simplifycfg -lowerinvoke -bdce -break-crit-edges -infer-address-spaces -mergereturn -deadargelim -canonicalize-aliases -coro-elide -aggressive-instcombine -strip-debug-declare -ee-instrument -lower-expect -globaldce -loop-interchange -loop-idiom -lcssa -loop-predication -loweratomic -loop-simplifycfg -loop-load-elim -coro-early -ipsccp -die -separate-const-offset-from-gep -aggressive-instcombine -ipsccp -cross-dso-cfi -hotcoldsplit -constmerge -strip -ee-instrument -globaldce -loop-deletion -loop-versioning -mergefunc -lower-expect -aggressive-instcombine -elim-avail-extern -sroa -loop-distribute -irce -insert-gcov-profiling -infer-address-spaces -simplifycfg -loop-sink -loop-simplify -loop-deletion -loop-simplify -instcombine -attributor -nary-reassociate -memcpyopt -globalsplit -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.0167423291155535,78.36895751953125,opt -loop-versioning-licm -loop-vectorize -gvn-hoist -rpo-functionattrs -loop-interchange -sccp -loop-simplifycfg -sancov -lower-matrix-intrinsics -gvn-hoist -callsite-splitting -loop-guard-widening -loop-unroll -ipsccp -strip-debug-declare -separate-const-offset-from-gep -simplifycfg -post-inline-ee-instrument -alignment-from-assumptions -mem2reg -libcalls-shrinkwrap -hotcoldsplit -loop-predication -partially-inline-libcalls -post-inline-ee-instrument -lower-widenable-condition -loop-reroll -bdce -loop-predication -loop-data-prefetch -indvars -loop-idiom -globaldce -strip-dead-prototypes -loop-simplifycfg -separate-const-offset-from-gep -loop-simplify -loop-predication -loop-unswitch -always-inline -loop-versioning-licm -mergefunc -rpo-functionattrs -reg2mem -elim-avail-extern -pgo-memop-opt -partial-inliner -ipsccp -die -globalsplit -add-discriminators -memcpyopt -div-rem-pairs -canonicalize-aliases -bdce -nary-reassociate -simple-loop-unswitch -insert-gcov-profiling -loop-simplify -partial-inliner -loop-unswitch -die -sancov -insert-gcov-profiling -break-crit-edges -functionattrs -break-crit-edges -loop-vectorize -ipconstprop -load-store-vectorizer -sroa -gvn -lower-matrix-intrinsics -loop-reroll -barrier -loop-simplify -rewrite-statepoints-for-gc -newgvn -sancov -coro-split -scalarizer -loop-versioning-licm -add-discriminators -mldst-motion -partial-inliner -consthoist -licm -rewrite-statepoints-for-gc -simplifycfg -jump-threading -sccp -lcssa -globaldce -deadargelim -hotcoldsplit -coro-cleanup -loop-data-prefetch -die -loop-vectorize -indvars -strip-debug-declare -jump-threading -coro-split -instcombine -float2int -instsimplify -insert-gcov-profiling -inject-tli-mappings -loop-simplify -loop-data-prefetch -lower-widenable-condition -strip-debug-declare -loop-simplifycfg -dse -indvars -loop-distribute -strip-nondebug -strip-dead-prototypes -functionattrs -ipsccp -gvn -indvars -lower-matrix-intrinsics -consthoist -alignment-from-assumptions -memcpyopt -loop-load-elim -sancov -loop-simplifycfg -barrier -strip-nondebug -infer-address-spaces -mergefunc -barrier -mem2reg -loop-guard-widening -mergereturn -loop-sink -rpo-functionattrs -sancov -add-discriminators -coro-elide -simplifycfg -rewrite-statepoints-for-gc -coro-early -name-anon-globals -loop-fusion -adce -lower-matrix-intrinsics -alignment-from-assumptions -tailcallelim -scalarizer -coro-early -loop-versioning-licm -cross-dso-cfi -coro-early -mergeicmps -strip-debug-declare -loop-simplifycfg -coro-cleanup -pgo-memop-opt -prune-eh -constprop -coro-split -div-rem-pairs -loop-fusion -jump-threading -functionattrs -lowerinvoke -functionattrs -elim-avail-extern -loop-idiom -lower-expect -argpromotion -loop-sink -rewrite-statepoints-for-gc -loop-unswitch -slp-vectorizer -lower-constant-intrinsics -lower-widenable-condition -lower-constant-intrinsics -lower-constant-intrinsics -argpromotion -argpromotion -ee-instrument -loop-load-elim -lower-guard-intrinsic -strip-dead-prototypes -correlated-propagation -forceattrs -libcalls-shrinkwrap -alignment-from-assumptions -always-inline -jump-threading -loop-fusion -canonicalize-aliases -coro-cleanup -mldst-motion -loop-interchange -rpo-functionattrs -loop-idiom -loop-simplify -rewrite-statepoints-for-gc -instcombine -loop-load-elim -irce -memcpyopt -loop-fusion -cross-dso-cfi -loop-predication -loweratomic -lower-widenable-condition -correlated-propagation -slsr -gvn-hoist -loop-instsimplify -mergefunc -mem2reg -sink -constmerge -loop-simplifycfg -forceattrs -lower-matrix-intrinsics -prune-eh -attributor -argpromotion -sccp -gvn -simple-loop-unswitch -dse -loop-simplifycfg -irce -reassociate -break-crit-edges -strip-debug-declare -mem2reg -loop-versioning-licm -attributor -globalopt -loop-deletion -loop-sink -rpo-functionattrs -loop-load-elim -tailcallelim -loop-reroll -jump-threading -lower-guard-intrinsic -globalopt -consthoist -callsite-splitting -loop-reroll -loop-unroll-and-jam -alignment-from-assumptions -nary-reassociate -loop-versioning-licm -simple-loop-unswitch -loop-deletion -mergeicmps -argpromotion -float2int -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.020702533887118,75.7045681476593,opt -newgvn -insert-gcov-profiling -bdce -indvars -deadargelim -dse -loop-guard-widening -always-inline -aggressive-instcombine -div-rem-pairs -load-store-vectorizer -constmerge -globalopt -ipconstprop -rewrite-statepoints-for-gc -gvn-hoist -lcssa -post-inline-ee-instrument -hotcoldsplit -lowerswitch -break-crit-edges -indvars -loop-guard-widening -loop-reroll -inject-tli-mappings -mem2reg -globalsplit -constmerge -insert-gcov-profiling -slp-vectorizer -lowerswitch -callsite-splitting -licm -loop-unroll-and-jam -separate-const-offset-from-gep -strip-debug-declare -loop-guard-widening -argpromotion -inject-tli-mappings -aggressive-instcombine -licm -add-discriminators -loop-load-elim -licm -lower-constant-intrinsics -hotcoldsplit -simple-loop-unswitch -infer-address-spaces -partially-inline-libcalls -strip-dead-prototypes -globaldce -argpromotion -loop-idiom -constmerge -rewrite-statepoints-for-gc -infer-address-spaces -nary-reassociate -loop-simplify -loop-predication -strip-dead-prototypes -loop-distribute -loop-guard-widening -called-value-propagation -loop-interchange -forceattrs -loop-guard-widening -ipsccp -strip -mem2reg -globalsplit -loop-simplifycfg -div-rem-pairs -guard-widening -load-store-vectorizer -early-cse-memssa -loop-versioning-licm -partial-inliner -elim-avail-extern -loop-sink -lower-guard-intrinsic -indvars -loop-sink -canonicalize-aliases -pgo-memop-opt -loop-load-elim -loop-data-prefetch -lower-constant-intrinsics -functionattrs -sroa -strip-nondebug -constprop -lower-matrix-intrinsics -flattencfg -loweratomic -alignment-from-assumptions -flattencfg -inferattrs -functionattrs -canonicalize-aliases -flattencfg -loop-distribute -simple-loop-unswitch -loop-guard-widening -prune-eh -lower-widenable-condition -strip-debug-declare -insert-gcov-profiling -deadargelim -cross-dso-cfi -ee-instrument -loop-versioning-licm -ipconstprop -sccp -mergeicmps -simplifycfg -float2int -loop-reroll -inferattrs -globaldce -lower-guard-intrinsic -instcombine -sccp -newgvn -newgvn -globaldce input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.020992304967964,74.4376745223999,opt -insert-gcov-profiling -sroa -load-store-vectorizer -reassociate -nary-reassociate -loop-guard-widening -die -sancov -aggressive-instcombine -ee-instrument -rpo-functionattrs -loop-versioning-licm -aggressive-instcombine -jump-threading -lower-matrix-intrinsics -cross-dso-cfi -post-inline-ee-instrument -tailcallelim -reassociate -strip -newgvn -always-inline -instnamer -sink -lcssa -strip-dead-prototypes -irce -mldst-motion -correlated-propagation -libcalls-shrinkwrap -nary-reassociate -loop-guard-widening -called-value-propagation -prune-eh -strip-nondebug -inject-tli-mappings -lower-widenable-condition -consthoist -simplifycfg -slsr -licm -scalarizer -sancov -constmerge -early-cse-memssa -callsite-splitting -separate-const-offset-from-gep -simple-loop-unswitch -sancov -cross-dso-cfi -instcombine -gvn-hoist -gvn -memcpyopt -mem2reg -inferattrs -loop-distribute -sroa -constprop -loop-instsimplify -cross-dso-cfi -gvn-hoist -partially-inline-libcalls -load-store-vectorizer -memcpyopt -ee-instrument -instcombine input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.022408963585434,71.32278347015381,opt -correlated-propagation -float2int -name-anon-globals -jump-threading -redundant-dbg-inst-elim -loop-data-prefetch -redundant-dbg-inst-elim -div-rem-pairs -sancov -correlated-propagation -slp-vectorizer -mem2reg -simplifycfg -coro-elide -libcalls-shrinkwrap -strip-dead-prototypes -float2int -slp-vectorizer -globaldce -slp-vectorizer -separate-const-offset-from-gep -early-cse-memssa -flattencfg -lower-constant-intrinsics -instnamer -libcalls-shrinkwrap -loop-vectorize -dce -inject-tli-mappings -functionattrs -instcombine -float2int -strip-dead-prototypes -bdce -gvn-hoist -loop-idiom -newgvn input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.0232460800412118,73.95274901390076,opt -sink -guard-widening -cross-dso-cfi -hotcoldsplit -mergereturn -break-crit-edges -licm -inject-tli-mappings -break-crit-edges -argpromotion -alignment-from-assumptions -rewrite-statepoints-for-gc -die -ipsccp -slsr -loop-predication -bdce -constprop -rewrite-statepoints-for-gc -coro-split -slsr -lower-expect -aggressive-instcombine -lcssa -div-rem-pairs -separate-const-offset-from-gep -sroa -partially-inline-libcalls -libcalls-shrinkwrap -sroa -guard-widening -loop-simplifycfg -instcombine -nary-reassociate -canonicalize-aliases -licm -newgvn -gvn -mergeicmps -loop-unroll-and-jam -attributor -ipconstprop -partial-inliner -elim-avail-extern -loop-guard-widening -pgo-memop-opt -lowerswitch -slp-vectorizer -guard-widening -inferattrs -slsr -instcombine -lower-guard-intrinsic -simplifycfg -mldst-motion -sancov -ee-instrument -memcpyopt -bdce input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.027367268746579,74.0155394077301,opt -elim-avail-extern -strip-nondebug -dse -lower-matrix-intrinsics -loop-reduce -globalopt -reg2mem -early-cse-memssa -separate-const-offset-from-gep -separate-const-offset-from-gep -argpromotion -instsimplify -dce -reassociate -jump-threading -globalopt -lcssa -bdce -simple-loop-unswitch -mem2reg -guard-widening -tailcallelim -instcombine -loop-predication -coro-elide -tailcallelim -licm -licm -lower-expect -simplifycfg -libcalls-shrinkwrap -mergereturn -newgvn input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.0304903570623651,81.23560118675232,opt -newgvn -coro-early -hotcoldsplit -loop-idiom -canonicalize-aliases -loop-interchange -always-inline -lcssa -strip -rewrite-statepoints-for-gc -float2int -alignment-from-assumptions -sink -aggressive-instcombine -callsite-splitting -constmerge -insert-gcov-profiling -canonicalize-aliases -irce -lower-widenable-condition -callsite-splitting -lower-expect -gvn-hoist -loop-interchange -mem2reg -sancov -simplifycfg -instsimplify -canonicalize-aliases -speculative-execution -mergefunc -libcalls-shrinkwrap -instcombine -instsimplify -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.0318104253195528,73.58163642883301,opt -instsimplify -reassociate -loop-instsimplify -coro-elide -rpo-functionattrs -alignment-from-assumptions -alignment-from-assumptions -ee-instrument -loop-load-elim -sink -loop-instsimplify -loop-versioning-licm -called-value-propagation -pgo-memop-opt -loop-simplify -inferattrs -separate-const-offset-from-gep -globalsplit -flattencfg -rewrite-statepoints-for-gc -licm -loop-unroll-and-jam -newgvn -rpo-functionattrs -strip-dead-prototypes -loop-vectorize -sroa -load-store-vectorizer -mergereturn -ipsccp -attributor -insert-gcov-profiling -globalsplit -bdce -coro-elide -always-inline -loop-reroll -loop-sink -newgvn -add-discriminators -loop-fusion -adce -break-crit-edges -loop-reroll -pgo-memop-opt -forceattrs -simple-loop-unswitch -die -early-cse-memssa -mergefunc -partially-inline-libcalls -gvn -loop-vectorize -instcombine -globalopt -partially-inline-libcalls -sancov -loop-unroll-and-jam -loop-sink -globaldce -break-crit-edges -mldst-motion -jump-threading -sancov -dce -lower-widenable-condition -loop-data-prefetch -dce -memcpyopt -lower-widenable-condition -slsr -cross-dso-cfi -hotcoldsplit -inject-tli-mappings -bdce -lcssa -rpo-functionattrs -licm -constprop -lower-widenable-condition -partially-inline-libcalls -inferattrs -loop-vectorize -constprop -speculative-execution -lower-expect -always-inline -cross-dso-cfi -slp-vectorizer -load-store-vectorizer -mergereturn -early-cse-memssa -slp-vectorizer -loweratomic -attributor -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,1.040793328825783,74.14569687843323,opt -prune-eh -loop-data-prefetch -partially-inline-libcalls -loop-fusion -strip -canonicalize-aliases -loop-interchange -coro-cleanup -jump-threading -early-cse-memssa -consthoist -loop-unroll -loop-data-prefetch -sink -loop-unroll -mem2reg -loop-instsimplify -pgo-memop-opt -simplifycfg -inferattrs -simple-loop-unswitch -loop-instsimplify -functionattrs -called-value-propagation -mergefunc -mldst-motion -jump-threading -insert-gcov-profiling -strip-dead-prototypes -loop-vectorize -loop-guard-widening -callsite-splitting -mem2reg -canonicalize-aliases -sroa -loop-load-elim -loop-predication -die -lcssa -irce -ipconstprop -loop-versioning-licm -indvars -sccp -mergefunc -mergereturn -memcpyopt -ipconstprop -always-inline -ipsccp -float2int -newgvn -reassociate -loop-instsimplify -strip-dead-prototypes -correlated-propagation -guard-widening -memcpyopt -alignment-from-assumptions -lower-guard-intrinsic -irce -loop-vectorize -attributor -loop-data-prefetch -licm -loop-predication -consthoist -barrier -dce -infer-address-spaces -mem2reg -mem2reg -prune-eh -gvn -inject-tli-mappings -adce -tailcallelim -gvn-hoist -globalsplit -loop-distribute -prune-eh -ipconstprop -instcombine -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/lame,1.0177636073787293,82.4673900604248,opt -canonicalize-aliases -loweratomic -loop-unroll-and-jam -loop-vectorize -infer-address-spaces -loop-instsimplify -break-crit-edges -rewrite-statepoints-for-gc -nary-reassociate -mergefunc -post-inline-ee-instrument -name-anon-globals -flattencfg -functionattrs -strip-debug-declare -loop-vectorize -lowerinvoke -strip-nondebug -redundant-dbg-inst-elim -simple-loop-unswitch -memcpyopt -instnamer -lower-widenable-condition -sink -newgvn -loop-load-elim -pgo-memop-opt -scalarizer -loop-reroll -flattencfg -early-cse-memssa -early-cse-memssa -lowerswitch -sroa -loop-predication -mem2reg -reg2mem -mergeicmps -float2int -die -mergefunc -loop-unroll -lower-constant-intrinsics -instsimplify -bdce -simple-loop-unswitch -loop-guard-widening -globalsplit -loop-distribute -ee-instrument -loop-guard-widening -lower-matrix-intrinsics -bdce -loop-sink -instnamer -infer-address-spaces -strip-dead-prototypes -loop-guard-widening -libcalls-shrinkwrap -adce -gvn -loop-predication -tailcallelim -consthoist -attributor -inject-tli-mappings -correlated-propagation -loop-predication -elim-avail-extern -loop-unroll-and-jam -forceattrs -slsr -partial-inliner -loop-simplifycfg -early-cse-memssa -loweratomic -mldst-motion -loop-reroll -div-rem-pairs -lcssa -loop-versioning -instcombine -alignment-from-assumptions -loop-versioning-licm -coro-split -sccp -guard-widening -lowerinvoke -aggressive-instcombine -hotcoldsplit -adce -adce -loop-simplify -cross-dso-cfi -pgo-memop-opt -always-inline -gvn -add-discriminators -prune-eh -callsite-splitting -memcpyopt -loop-predication -barrier -sroa -strip-dead-prototypes -coro-early -lower-constant-intrinsics -instsimplify -mem2reg -ipsccp -dse -reassociate -loop-data-prefetch -reassociate -canonicalize-aliases -constprop -coro-elide -loop-versioning -float2int -coro-split -inferattrs -loop-vectorize -early-cse-memssa -slp-vectorizer -sancov -ipconstprop -irce -ee-instrument -strip-debug-declare -partially-inline-libcalls -jump-threading -argpromotion -coro-early -strip -bdce -loop-fusion -ipsccp -globaldce -div-rem-pairs -pgo-memop-opt -lowerswitch -insert-gcov-profiling -reassociate -deadargelim -mem2reg -break-crit-edges -partial-inliner -post-inline-ee-instrument -coro-cleanup -irce -lower-guard-intrinsic -correlated-propagation -aggressive-instcombine -add-discriminators -ipconstprop -loop-distribute -lower-constant-intrinsics -separate-const-offset-from-gep -bdce -loop-versioning -dse -coro-cleanup -inferattrs -early-cse-memssa -argpromotion -instcombine -loweratomic -licm -alignment-from-assumptions -mergefunc -deadargelim -strip-dead-prototypes -sink -loop-unswitch -load-store-vectorizer -adce -strip-dead-prototypes -early-cse-memssa -pgo-memop-opt -slp-vectorizer -elim-avail-extern -prune-eh -loop-distribute -coro-elide -gvn-hoist -deadargelim -loop-distribute -reg2mem -reg2mem -mem2reg -attributor -guard-widening -partial-inliner -sink -loop-simplifycfg -loop-idiom -instsimplify -break-crit-edges -loop-unswitch -hotcoldsplit -simplifycfg -float2int -loop-instsimplify -div-rem-pairs -strip-dead-prototypes -guard-widening -indvars -loop-versioning-licm -loop-instsimplify -prune-eh -loop-versioning-licm -globalopt -attributor -lowerswitch -coro-split -sink -mergeicmps -rewrite-statepoints-for-gc -lower-guard-intrinsic -loop-sink -hotcoldsplit -rewrite-statepoints-for-gc -loop-fusion -coro-early -loop-vectorize -mergereturn -div-rem-pairs -mldst-motion -gvn -pgo-memop-opt -forceattrs -speculative-execution -ipsccp -loop-unroll-and-jam -strip -correlated-propagation -lower-widenable-condition -lower-constant-intrinsics -float2int -constprop -strip-nondebug -scalarizer -slp-vectorizer -deadargelim -inject-tli-mappings -lower-widenable-condition -rewrite-statepoints-for-gc -memcpyopt -ipsccp -globaldce -instnamer -coro-early -insert-gcov-profiling -loop-data-prefetch -tailcallelim -instnamer -globalsplit -inferattrs -lower-guard-intrinsic -slsr -always-inline -float2int -globalopt -deadargelim -instcombine -sroa -float2int -lowerswitch -loop-simplifycfg -libcalls-shrinkwrap -die -sink -loop-simplify -loop-simplifycfg -mergefunc -infer-address-spaces -loop-versioning -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/lame,1.0220906399453424,80.74984622001648,opt -lower-guard-intrinsic -loop-predication -mem2reg -mergeicmps -correlated-propagation -mergereturn -coro-split -loop-predication -inject-tli-mappings -prune-eh -correlated-propagation -name-anon-globals -lower-constant-intrinsics -prune-eh -loop-instsimplify -simplifycfg -canonicalize-aliases -ee-instrument -loop-versioning -alignment-from-assumptions -mem2reg -cross-dso-cfi -canonicalize-aliases -die -simplifycfg -slp-vectorizer -globalopt -loop-fusion -callsite-splitting -loop-instsimplify -simple-loop-unswitch -instcombine -mergeicmps -tailcallelim -reassociate -attributor -insert-gcov-profiling -newgvn input.bc -o output.bc -benchmark://cBench-v1/lame,1.026000151825704,89.91641187667847,opt -ipsccp -coro-elide -strip-debug-declare -strip-dead-prototypes -sroa -consthoist -lowerswitch -loweratomic -loop-simplifycfg -coro-elide -alignment-from-assumptions -tailcallelim -lcssa -instnamer -pgo-memop-opt -irce -rewrite-statepoints-for-gc -forceattrs -cross-dso-cfi -mergereturn -loop-sink -gvn-hoist -rpo-functionattrs -float2int -infer-address-spaces -libcalls-shrinkwrap -deadargelim -functionattrs -consthoist -mldst-motion -globalsplit -die -aggressive-instcombine -bdce -aggressive-instcombine -licm -gvn-hoist -slsr -loop-deletion -slsr -loop-idiom -coro-early -licm -globalopt -nary-reassociate -early-cse-memssa -barrier -lowerinvoke -sroa -flattencfg -insert-gcov-profiling -adce -loop-versioning -loop-simplifycfg -partially-inline-libcalls -ee-instrument -simple-loop-unswitch -instnamer -post-inline-ee-instrument -simple-loop-unswitch -ipsccp -bdce -loop-interchange -break-crit-edges -jump-threading -redundant-dbg-inst-elim -lower-expect -always-inline -simplifycfg -speculative-execution -coro-elide -loop-guard-widening -mergefunc -strip-nondebug -mldst-motion -jump-threading -die -loop-guard-widening -instsimplify -prune-eh -ipsccp -instcombine input.bc -o output.bc -benchmark://cBench-v1/lame,1.0306687922265239,78.65229177474976,opt -callsite-splitting -simplifycfg -indvars -mem2reg -correlated-propagation -lower-widenable-condition -constprop -loop-instsimplify -partial-inliner -callsite-splitting -sccp -loop-vectorize -loop-data-prefetch -mergefunc -newgvn -coro-early -loop-idiom -simplifycfg -loop-predication -coro-early -gvn -loweratomic -consthoist -argpromotion -loop-interchange -mldst-motion -loop-deletion -loop-predication -partially-inline-libcalls -jump-threading -instcombine -deadargelim -constprop -name-anon-globals -functionattrs -tailcallelim -attributor -loop-unroll-and-jam -always-inline -memcpyopt -aggressive-instcombine -ee-instrument -loop-vectorize -loop-simplify -mldst-motion -loop-sink -instcombine -ipsccp -jump-threading -elim-avail-extern input.bc -o output.bc -benchmark://cBench-v1/lame,1.0326804828057392,102.16820931434631,opt -jump-threading -strip -inferattrs -gvn -loop-fusion -barrier -canonicalize-aliases -deadargelim -mergefunc -post-inline-ee-instrument -sroa -coro-split -redundant-dbg-inst-elim -loop-reroll -sccp -indvars -reassociate -irce -lower-constant-intrinsics -loop-simplify -post-inline-ee-instrument -mem2reg -slsr -loop-versioning-licm -separate-const-offset-from-gep -mergeicmps -dce -globalsplit -loop-instsimplify -flattencfg -simplifycfg -memcpyopt -rpo-functionattrs -loop-distribute -sroa -hotcoldsplit -float2int -deadargelim -globalsplit -load-store-vectorizer -float2int -rewrite-statepoints-for-gc -globalsplit -mergeicmps -add-discriminators -loop-sink -constprop -strip-dead-prototypes -argpromotion -loop-distribute -libcalls-shrinkwrap -die -loop-load-elim -instnamer -indvars -correlated-propagation -instnamer -instcombine -strip-debug-declare -early-cse-memssa -loop-idiom -ee-instrument -loop-guard-widening -coro-split -lower-guard-intrinsic -cross-dso-cfi -licm -alignment-from-assumptions -flattencfg -consthoist -bdce -add-discriminators -elim-avail-extern -loop-unroll-and-jam -loop-simplifycfg -memcpyopt -speculative-execution -globaldce -loop-interchange -rpo-functionattrs -loop-distribute -mergereturn -memcpyopt -separate-const-offset-from-gep -mergefunc -deadargelim -reassociate -libcalls-shrinkwrap -loop-versioning -mldst-motion -newgvn -nary-reassociate -instcombine input.bc -o output.bc -benchmark://cBench-v1/lame,1.0330600470659683,195.33090710639954,opt -separate-const-offset-from-gep -coro-early -bdce -pgo-memop-opt -nary-reassociate -loop-sink -loop-unswitch -loop-simplifycfg -globalopt -coro-elide -loop-vectorize -break-crit-edges -irce -sccp -coro-cleanup -speculative-execution -functionattrs -called-value-propagation -instnamer -loop-vectorize -argpromotion -mldst-motion -mergereturn -flattencfg -loop-unroll-and-jam -loop-distribute -globalopt -always-inline -instnamer -separate-const-offset-from-gep -load-store-vectorizer -coro-early -lower-guard-intrinsic -insert-gcov-profiling -insert-gcov-profiling -irce -loop-idiom -coro-elide -float2int -licm -loop-simplifycfg -sink -lower-matrix-intrinsics -inject-tli-mappings -lower-expect -inferattrs -simple-loop-unswitch -adce -ipconstprop -strip-nondebug -called-value-propagation -dce -loop-deletion -bdce -float2int -lower-expect -slp-vectorizer -post-inline-ee-instrument -guard-widening -sink -loop-reroll -argpromotion -break-crit-edges -coro-split -mem2reg -guard-widening -simplifycfg -hotcoldsplit -rpo-functionattrs -loop-instsimplify -dse -globaldce -loop-idiom -alignment-from-assumptions -loop-sink -redundant-dbg-inst-elim -gvn-hoist -loop-deletion -loop-simplifycfg -newgvn -rewrite-statepoints-for-gc -strip-nondebug -elim-avail-extern -strip-debug-declare -attributor -lower-expect -lowerinvoke -div-rem-pairs -libcalls-shrinkwrap -tailcallelim -always-inline -instcombine -lowerinvoke -indvars -nary-reassociate -mldst-motion -loop-guard-widening -aggressive-instcombine -mem2reg -deadargelim -attributor -attributor -infer-address-spaces -callsite-splitting -correlated-propagation -attributor -loop-versioning -float2int -hotcoldsplit -hotcoldsplit -inject-tli-mappings -argpromotion -break-crit-edges -instcombine -rewrite-statepoints-for-gc -loop-interchange -loop-data-prefetch -float2int -lower-constant-intrinsics -loop-guard-widening -globaldce -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/lame,1.0341607834206334,72.04348230361938,opt -loop-unswitch -licm -lower-constant-intrinsics -dse -irce -strip-debug-declare -hotcoldsplit -sroa -strip-debug-declare -callsite-splitting -early-cse-memssa -lower-constant-intrinsics -die -div-rem-pairs -lower-expect -attributor -reassociate -insert-gcov-profiling -ee-instrument -deadargelim -correlated-propagation -dse -loop-load-elim -coro-split -strip -loop-versioning-licm -loop-predication -mem2reg -guard-widening -strip -float2int -loop-guard-widening -strip-dead-prototypes -loop-instsimplify -globalsplit -elim-avail-extern -loop-versioning -ipconstprop -irce -inject-tli-mappings -insert-gcov-profiling -gvn-hoist -die -lowerswitch -partially-inline-libcalls -gvn -die -instsimplify -post-inline-ee-instrument -loop-sink -loop-unroll-and-jam -loop-predication -loop-unroll-and-jam -ipconstprop -loop-versioning -sroa -cross-dso-cfi -instnamer -loop-vectorize -constmerge -loop-instsimplify -sccp -lower-constant-intrinsics -sink -mergefunc -reassociate -add-discriminators -sccp -instcombine -instcombine -loop-simplifycfg -loop-fusion -slsr -inject-tli-mappings -irce -alignment-from-assumptions -loop-versioning-licm -sccp -post-inline-ee-instrument -lowerinvoke -ipsccp -flattencfg -loop-instsimplify -ee-instrument -flattencfg -simplifycfg -infer-address-spaces -memcpyopt -loop-load-elim -coro-elide -loop-guard-widening -rpo-functionattrs -adce -loop-simplify -newgvn input.bc -o output.bc -benchmark://cBench-v1/lame,1.039892203750095,87.48616743087769,opt -insert-gcov-profiling -gvn-hoist -loop-deletion -strip-debug-declare -adce -strip-debug-declare -lower-expect -early-cse-memssa -loop-reroll -partially-inline-libcalls -simplifycfg -sroa -instcombine -gvn -infer-address-spaces -lowerinvoke -loop-predication -memcpyopt -nary-reassociate -reg2mem -coro-elide -loop-instsimplify -simple-loop-unswitch -sroa -called-value-propagation -lcssa -loop-fusion -rewrite-statepoints-for-gc -separate-const-offset-from-gep -lower-matrix-intrinsics -irce -loop-unswitch -loop-reroll -lower-guard-intrinsic -ipconstprop -simplifycfg -mergereturn -coro-early -argpromotion -instcombine -mergereturn -lower-guard-intrinsic -strip -elim-avail-extern -ipsccp input.bc -o output.bc -benchmark://cBench-v1/lame,1.0432703256661353,320.4585802555084,opt -separate-const-offset-from-gep -irce -jump-threading -constprop -loop-deletion -sroa -newgvn -licm -lowerinvoke -canonicalize-aliases -inferattrs -simple-loop-unswitch -speculative-execution -name-anon-globals -adce -sancov -die -instsimplify -separate-const-offset-from-gep -inject-tli-mappings -lower-guard-intrinsic -licm -lower-matrix-intrinsics -mergereturn -constprop -instcombine -mem2reg -loop-instsimplify -inferattrs -loop-data-prefetch -mergereturn -irce -speculative-execution -loop-versioning-licm -called-value-propagation -globaldce -loop-reroll -forceattrs -ee-instrument -sccp -inferattrs -loop-load-elim -barrier -simplifycfg -loop-fusion -loop-reroll -loop-distribute -insert-gcov-profiling -lower-widenable-condition -sink -div-rem-pairs -redundant-dbg-inst-elim -loop-instsimplify -deadargelim -nary-reassociate -correlated-propagation -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/lame,1.0480528353450238,136.65584301948547,opt -globalsplit -inject-tli-mappings -mergefunc -tailcallelim -libcalls-shrinkwrap -gvn-hoist -loop-fusion -loop-versioning -prune-eh -loop-interchange -strip-debug-declare -loop-sink -flattencfg -dce -elim-avail-extern -consthoist -barrier -float2int -globalopt -sroa -gvn-hoist -correlated-propagation -gvn -float2int -simple-loop-unswitch -functionattrs -globalsplit -newgvn -instsimplify -simplifycfg -simple-loop-unswitch -loop-versioning -functionattrs -newgvn -loweratomic -pgo-memop-opt -lcssa -adce -insert-gcov-profiling -loop-unroll-and-jam -infer-address-spaces -loop-data-prefetch -loop-deletion -correlated-propagation -rpo-functionattrs -lcssa -instcombine -loop-reroll -flattencfg -loop-predication -functionattrs -scalarizer -insert-gcov-profiling -tailcallelim -loop-fusion -mergefunc -sancov -loop-interchange -loop-unroll-and-jam -loop-sink -inject-tli-mappings -globalopt -loweratomic -sroa -separate-const-offset-from-gep -prune-eh -mergereturn -loop-distribute -deadargelim -loop-instsimplify -ipconstprop -simplifycfg -loop-data-prefetch -pgo-memop-opt -add-discriminators -coro-elide -pgo-memop-opt -partially-inline-libcalls -sccp -rpo-functionattrs -sccp -memcpyopt -constprop -rewrite-statepoints-for-gc -indvars -dce -ipconstprop -globalsplit -argpromotion -called-value-propagation -strip-debug-declare -redundant-dbg-inst-elim -lower-expect -globaldce -ee-instrument -newgvn -mldst-motion input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9955506117908788,61.57529139518738,opt -loop-sink -simplifycfg -lower-widenable-condition -strip -inject-tli-mappings -mldst-motion -lower-constant-intrinsics -adce -loop-distribute -loop-predication -lower-matrix-intrinsics -rpo-functionattrs -lowerinvoke -name-anon-globals -load-store-vectorizer -coro-cleanup -hotcoldsplit -ipsccp -consthoist -guard-widening -strip-debug-declare -bdce -coro-early -bdce -loop-interchange -simplifycfg -redundant-dbg-inst-elim -simplifycfg -loop-guard-widening -forceattrs -loop-versioning -ipconstprop -name-anon-globals -canonicalize-aliases -barrier -loop-data-prefetch -post-inline-ee-instrument -tailcallelim -mem2reg -simplifycfg -ipsccp -loop-interchange -scalarizer -prune-eh -nary-reassociate -post-inline-ee-instrument -nary-reassociate -loop-deletion -argpromotion -insert-gcov-profiling -loop-deletion -constmerge -add-discriminators -gvn -dse -instcombine -functionattrs -coro-elide -loop-load-elim -strip-nondebug -loop-load-elim -ee-instrument -gvn -attributor -die -globalopt -redundant-dbg-inst-elim -strip-dead-prototypes -sccp -float2int -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9955506117908788,61.80874562263489,opt -rpo-functionattrs -lowerswitch -rpo-functionattrs -loop-unroll -early-cse-memssa -deadargelim -hotcoldsplit -inferattrs -mldst-motion -flattencfg -argpromotion -load-store-vectorizer -forceattrs -newgvn -post-inline-ee-instrument -loop-simplifycfg -mldst-motion -globaldce -name-anon-globals -add-discriminators -ee-instrument -mergereturn -loweratomic -sink -argpromotion -jump-threading -consthoist -strip -break-crit-edges -coro-cleanup -lower-matrix-intrinsics -loop-interchange -guard-widening -loop-unroll-and-jam -loop-instsimplify -loop-data-prefetch -jump-threading -indvars -loop-simplifycfg -strip-debug-declare -instnamer -div-rem-pairs -ee-instrument -lower-guard-intrinsic -lower-constant-intrinsics -loop-load-elim -coro-split -lowerinvoke -loop-guard-widening -speculative-execution -loop-unroll-and-jam -loweratomic -gvn -dse -loop-predication -strip -correlated-propagation -die -loop-sink -mem2reg -functionattrs -coro-split -loop-instsimplify -always-inline -globaldce -sroa -loop-simplifycfg -irce -consthoist -attributor -flattencfg -separate-const-offset-from-gep -barrier -ee-instrument -guard-widening -mergereturn -partially-inline-libcalls -loop-simplifycfg -die -loop-deletion -reassociate -strip-dead-prototypes -ipsccp -irce -loop-load-elim -irce -bdce -insert-gcov-profiling -loop-reroll -loop-simplifycfg -strip -lower-guard-intrinsic -loop-reduce -instnamer -deadargelim -coro-split -licm -rpo-functionattrs -loop-deletion -add-discriminators -name-anon-globals -called-value-propagation -loop-versioning -loop-data-prefetch -gvn-hoist -guard-widening -loop-deletion -div-rem-pairs -instcombine -partial-inliner -name-anon-globals -indvars -insert-gcov-profiling -strip-nondebug -globalopt -newgvn -float2int -redundant-dbg-inst-elim -callsite-splitting -deadargelim -ipsccp -loop-predication -loop-simplifycfg -alignment-from-assumptions -barrier -cross-dso-cfi -redundant-dbg-inst-elim -early-cse-memssa -argpromotion -loop-versioning -callsite-splitting -called-value-propagation -loop-versioning-licm -instcombine -sccp -loop-unroll -simplifycfg -strip -loop-sink -consthoist -strip-nondebug -instsimplify -infer-address-spaces -globaldce -loop-guard-widening -die -instnamer -simplifycfg -rewrite-statepoints-for-gc -instcombine input.bc -o output.bc -benchmark://cBench-v1/patricia,0.995550611790879,61.725738286972046,opt -inferattrs -attributor -partially-inline-libcalls -correlated-propagation -speculative-execution -ipsccp -elim-avail-extern -coro-cleanup -loop-versioning-licm -forceattrs -nary-reassociate -constprop -coro-cleanup -loop-simplifycfg -attributor -simple-loop-unswitch -consthoist -constprop -correlated-propagation -partial-inliner -gvn -rewrite-statepoints-for-gc -slp-vectorizer -barrier -instnamer -loop-simplifycfg -instcombine -deadargelim -dce -scalarizer -newgvn -alignment-from-assumptions -loop-interchange -called-value-propagation -functionattrs -guard-widening -forceattrs -loop-interchange -loop-guard-widening -indvars -sccp -early-cse-memssa -dse -correlated-propagation -instnamer -mldst-motion -redundant-dbg-inst-elim -loop-distribute -slsr -loop-predication -lower-matrix-intrinsics -lower-matrix-intrinsics -coro-early -strip-dead-prototypes -hotcoldsplit -loop-simplifycfg -loop-interchange -pgo-memop-opt -memcpyopt -loop-simplifycfg -coro-cleanup -indvars -loop-load-elim -mem2reg -bdce -reassociate -loop-versioning-licm -callsite-splitting -rewrite-statepoints-for-gc -loop-data-prefetch -loop-load-elim -rpo-functionattrs -loweratomic -loop-load-elim -newgvn -gvn-hoist -inferattrs -dce -coro-early -dce -lower-widenable-condition -loweratomic -pgo-memop-opt -dse -die -mem2reg -loop-guard-widening -ipsccp -inferattrs -aggressive-instcombine -instnamer -gvn-hoist -lower-matrix-intrinsics -memcpyopt -libcalls-shrinkwrap -partial-inliner -loop-reduce -reassociate -lower-expect -loop-deletion -instnamer -mergefunc -loop-simplifycfg -lower-widenable-condition -pgo-memop-opt -strip -deadargelim -coro-elide -barrier -newgvn -gvn -sancov -float2int -inject-tli-mappings -barrier -coro-split -tailcallelim -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9977753058954394,61.65921092033386,opt -loop-reroll -coro-early -libcalls-shrinkwrap -loop-guard-widening -loop-unswitch -callsite-splitting -post-inline-ee-instrument -early-cse-memssa -add-discriminators -mldst-motion -strip-nondebug -loop-unswitch -break-crit-edges -infer-address-spaces -sroa -instnamer -loop-fusion -loop-sink -flattencfg -lower-constant-intrinsics -reg2mem -indvars -indvars -mergefunc -insert-gcov-profiling -flattencfg -mldst-motion -elim-avail-extern -loop-vectorize -prune-eh -partial-inliner -functionattrs -speculative-execution -bdce -dce -canonicalize-aliases -coro-elide -pgo-memop-opt -prune-eh -mergefunc -simplifycfg -mergeicmps -loop-unroll-and-jam -lower-guard-intrinsic -mergereturn -bdce -libcalls-shrinkwrap -loop-simplifycfg -coro-split -dse -lowerinvoke -loop-deletion -loop-guard-widening -pgo-memop-opt -load-store-vectorizer -correlated-propagation -loop-sink -loop-guard-widening -mergeicmps -loop-distribute -strip -inject-tli-mappings -loop-reduce -strip-debug-declare -strip -coro-cleanup -irce -simple-loop-unswitch -scalarizer -gvn-hoist -sancov -called-value-propagation -simplifycfg -globalopt -always-inline -rewrite-statepoints-for-gc -ee-instrument -div-rem-pairs -add-discriminators -lower-expect -coro-elide -loop-versioning -ipconstprop -loop-deletion -coro-split -die -mem2reg -gvn -rewrite-statepoints-for-gc -strip-nondebug -attributor -adce -elim-avail-extern -loop-instsimplify -aggressive-instcombine -name-anon-globals -constprop -mergefunc -ee-instrument -lower-expect -separate-const-offset-from-gep -loop-guard-widening -adce -strip -loop-deletion -loop-instsimplify -add-discriminators -newgvn -constprop -instcombine -strip -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9977753058954394,62.400047063827515,opt -sancov -barrier -loop-data-prefetch -libcalls-shrinkwrap -loop-simplifycfg -mldst-motion -strip-dead-prototypes -coro-elide -loop-reduce -loop-idiom -globalopt -loop-sink -loop-unroll-and-jam -canonicalize-aliases -barrier -indvars -strip-nondebug -float2int -simplifycfg -forceattrs -infer-address-spaces -cross-dso-cfi -loop-unroll -coro-cleanup -bdce -nary-reassociate -globalsplit -licm -nary-reassociate -callsite-splitting -slsr -float2int -correlated-propagation -lower-widenable-condition -globalsplit -ee-instrument -callsite-splitting -add-discriminators -constmerge -loop-distribute -functionattrs -flattencfg -early-cse-memssa -lower-constant-intrinsics -correlated-propagation -lower-constant-intrinsics -rewrite-statepoints-for-gc -functionattrs -ipconstprop -rewrite-statepoints-for-gc -insert-gcov-profiling -constmerge -guard-widening -loop-sink -loop-guard-widening -partially-inline-libcalls -mergefunc -partial-inliner -loop-load-elim -loop-data-prefetch -mem2reg -flattencfg -alignment-from-assumptions -called-value-propagation -partially-inline-libcalls -rewrite-statepoints-for-gc -loop-reroll -loop-simplifycfg -instnamer -coro-split -loop-interchange -strip -instcombine -gvn -nary-reassociate -lowerinvoke -globaldce -aggressive-instcombine -globaldce -float2int -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9988876529477196,61.67392659187317,opt -strip -break-crit-edges -loop-unroll-and-jam -correlated-propagation -rpo-functionattrs -functionattrs -separate-const-offset-from-gep -forceattrs -mergereturn -lcssa -scalarizer -redundant-dbg-inst-elim -instnamer -libcalls-shrinkwrap -coro-early -lcssa -ipconstprop -loop-unroll -lower-constant-intrinsics -coro-early -gvn -mergefunc -instcombine -strip-dead-prototypes -sancov -globalsplit -slp-vectorizer -aggressive-instcombine -name-anon-globals -elim-avail-extern -sccp -loop-guard-widening -mergereturn -loop-guard-widening -simplifycfg -add-discriminators -loop-interchange -ipconstprop -callsite-splitting -loop-simplifycfg -lower-constant-intrinsics -jump-threading -scalarizer -coro-cleanup -loop-vectorize -mldst-motion -loop-versioning -correlated-propagation -called-value-propagation -sink -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/patricia,0.9999999999999999,61.583837270736694,opt -ipconstprop -attributor -hotcoldsplit -coro-split -newgvn -barrier -irce -lower-widenable-condition -mem2reg -mergeicmps -die -name-anon-globals -always-inline -loop-deletion -globalsplit -rpo-functionattrs -reassociate -loop-interchange -break-crit-edges -lower-constant-intrinsics -argpromotion -forceattrs -rpo-functionattrs -slsr -loop-unroll -globaldce -sancov -globalopt -loop-sink -mergeicmps -simplifycfg -lower-guard-intrinsic -reg2mem -div-rem-pairs -loop-idiom -lower-constant-intrinsics -mem2reg -mergefunc -pgo-memop-opt -partially-inline-libcalls -cross-dso-cfi -loop-load-elim -instnamer -hotcoldsplit -mergereturn -add-discriminators -irce -partially-inline-libcalls -flattencfg -alignment-from-assumptions -globaldce -mem2reg -loweratomic -functionattrs -insert-gcov-profiling -lower-constant-intrinsics -loop-predication -post-inline-ee-instrument -ipconstprop -loop-vectorize -die -mergeicmps -strip-dead-prototypes -loop-predication -nary-reassociate -strip -cross-dso-cfi -instcombine -loop-distribute -strip-nondebug -constprop -guard-widening -dse -instsimplify -licm -strip-dead-prototypes -loop-fusion -newgvn -mldst-motion -constprop -reassociate -float2int -loop-load-elim -speculative-execution -flattencfg -loop-load-elim -add-discriminators -rpo-functionattrs -scalarizer -rpo-functionattrs -functionattrs -inferattrs -simplifycfg -lowerinvoke -instnamer -lower-matrix-intrinsics -dse input.bc -o output.bc -benchmark://cBench-v1/patricia,1.0000000000000002,61.69987082481384,opt -forceattrs -sink -loop-simplify -loop-simplify -adce -ee-instrument -loop-vectorize -loop-fusion -partial-inliner -loweratomic -lower-widenable-condition -mergeicmps -post-inline-ee-instrument -prune-eh -aggressive-instcombine -scalarizer -insert-gcov-profiling -slsr -barrier -loop-simplify -lower-guard-intrinsic -insert-gcov-profiling -irce -correlated-propagation -coro-cleanup -licm -lower-guard-intrinsic -speculative-execution -forceattrs -sink -break-crit-edges -lcssa -mergereturn -barrier -ee-instrument -strip-debug-declare -memcpyopt -instnamer -constprop -ee-instrument -redundant-dbg-inst-elim -strip-nondebug -mergefunc -constmerge -gvn-hoist -mem2reg -prune-eh -globalsplit -loop-unroll-and-jam -functionattrs -slp-vectorizer -simplifycfg -strip-debug-declare -indvars -reassociate -coro-cleanup -loop-predication -float2int -loop-fusion -called-value-propagation -coro-elide -bdce -loop-simplifycfg -called-value-propagation -strip -cross-dso-cfi -tailcallelim -lower-guard-intrinsic -ipsccp -mem2reg -mldst-motion -simplifycfg -instcombine -loop-idiom -loop-vectorize -always-inline -strip-debug-declare -consthoist -attributor -nary-reassociate -constmerge -loop-interchange -newgvn -lower-matrix-intrinsics -coro-early -lowerinvoke -aggressive-instcombine -simple-loop-unswitch -float2int -bdce -loop-fusion -gvn -licm -consthoist -flattencfg -simplifycfg -loop-simplify -ee-instrument -float2int -partially-inline-libcalls -irce -redundant-dbg-inst-elim -barrier -add-discriminators -jump-threading -redundant-dbg-inst-elim -infer-address-spaces -mldst-motion -canonicalize-aliases -lowerswitch -sink -always-inline -strip-nondebug -lower-constant-intrinsics -mem2reg -name-anon-globals -instsimplify input.bc -o output.bc -benchmark://cBench-v1/patricia,1.0000000000000002,61.75343203544617,opt -globalopt -memcpyopt -mergereturn -infer-address-spaces -globaldce -lowerinvoke -insert-gcov-profiling -sroa -speculative-execution -rewrite-statepoints-for-gc -nary-reassociate -guard-widening -globalopt -bdce -scalarizer -simplifycfg -lower-guard-intrinsic -float2int -loop-idiom -mergereturn -constmerge -argpromotion -loop-instsimplify -name-anon-globals -loop-reroll -globalopt -lowerinvoke -mergeicmps -nary-reassociate -simplifycfg -consthoist -mergeicmps -instnamer -flattencfg -libcalls-shrinkwrap -loop-versioning-licm -lowerinvoke -inject-tli-mappings -indvars -sink -loop-simplifycfg -ipsccp -callsite-splitting -constmerge -loweratomic -licm -loop-unroll -dse -sancov -newgvn -globalopt -argpromotion -loop-simplify -redundant-dbg-inst-elim -libcalls-shrinkwrap -post-inline-ee-instrument -attributor -loop-versioning-licm -lower-expect -correlated-propagation -early-cse-memssa -libcalls-shrinkwrap -lower-constant-intrinsics -sroa -functionattrs -loop-sink -instcombine -reg2mem -loop-predication -loop-simplifycfg -rpo-functionattrs -globaldce -scalarizer -rewrite-statepoints-for-gc -mem2reg -coro-split -loop-vectorize -coro-elide -simplifycfg -simple-loop-unswitch -ipconstprop -name-anon-globals -infer-address-spaces -loop-unroll-and-jam -sroa -loop-idiom -loop-reroll -separate-const-offset-from-gep -inferattrs -simple-loop-unswitch -ee-instrument -loop-fusion -loop-guard-widening -always-inline -rpo-functionattrs -redundant-dbg-inst-elim -instsimplify -sink -loop-reduce -gvn-hoist -mergereturn -jump-threading -pgo-memop-opt -globalopt -gvn-hoist -barrier -loop-predication -rewrite-statepoints-for-gc -partially-inline-libcalls -insert-gcov-profiling -coro-early -newgvn -tailcallelim -forceattrs -loop-guard-widening -loop-interchange -nary-reassociate -coro-early -loop-versioning -flattencfg -rpo-functionattrs -post-inline-ee-instrument -gvn -infer-address-spaces -irce -consthoist -coro-elide -functionattrs -mergefunc -reg2mem -loop-versioning-licm -mem2reg -simplifycfg -always-inline -simplifycfg -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/patricia,1.0011123470522802,61.89285445213318,opt -infer-address-spaces -redundant-dbg-inst-elim -coro-early -loop-predication -speculative-execution -loop-unroll-and-jam -mem2reg -hotcoldsplit -infer-address-spaces -memcpyopt -globalopt -elim-avail-extern -name-anon-globals -loop-versioning-licm -strip-nondebug -coro-early -dse -reg2mem -lowerinvoke -separate-const-offset-from-gep -globaldce -loop-deletion -bdce -dce -argpromotion -always-inline -loop-data-prefetch -inferattrs -coro-early -loop-guard-widening -lower-guard-intrinsic -gvn -pgo-memop-opt -rpo-functionattrs -coro-elide -nary-reassociate -dce -consthoist -scalarizer -lcssa -partially-inline-libcalls -coro-elide -gvn-hoist -adce -loop-instsimplify -licm -prune-eh -mergefunc -strip-debug-declare -newgvn -attributor -loop-unroll-and-jam -coro-early -scalarizer -scalarizer -mergereturn -cross-dso-cfi -loop-distribute -globalsplit -pgo-memop-opt -sink -indvars -globalsplit -cross-dso-cfi -inferattrs -mergereturn -loop-versioning -libcalls-shrinkwrap -called-value-propagation -loweratomic -callsite-splitting -mergeicmps -libcalls-shrinkwrap -ee-instrument -barrier -tailcallelim -ee-instrument -canonicalize-aliases -div-rem-pairs -tailcallelim -libcalls-shrinkwrap -ipconstprop -alignment-from-assumptions -redundant-dbg-inst-elim -flattencfg -loop-idiom -break-crit-edges -load-store-vectorizer -mldst-motion -globalsplit -lowerswitch -lower-matrix-intrinsics -loop-simplifycfg -nary-reassociate -ee-instrument -loop-fusion -infer-address-spaces -loop-unroll-and-jam -div-rem-pairs -libcalls-shrinkwrap -tailcallelim -elim-avail-extern -reassociate -attributor -cross-dso-cfi -loop-deletion -infer-address-spaces -loop-sink -ipsccp -canonicalize-aliases -callsite-splitting -barrier -sancov -called-value-propagation -lower-expect -loop-versioning -gvn-hoist -loop-versioning -consthoist -coro-cleanup -lcssa -name-anon-globals -simplifycfg -rewrite-statepoints-for-gc -always-inline -loop-simplify -mergefunc -loop-data-prefetch -sink -licm -argpromotion -hotcoldsplit -loop-idiom -slsr -nary-reassociate -mem2reg -insert-gcov-profiling -add-discriminators -memcpyopt -loop-sink -forceattrs -lower-guard-intrinsic -ee-instrument -pgo-memop-opt -name-anon-globals -instsimplify -loweratomic -lowerswitch -instcombine -simplifycfg -die -loop-simplifycfg -simple-loop-unswitch -adce -loop-versioning-licm -inferattrs -loop-load-elim -simple-loop-unswitch -lower-expect -attributor -strip-nondebug -loop-vectorize -attributor -slsr -strip-nondebug -cross-dso-cfi -functionattrs -newgvn input.bc -o output.bc -benchmark://cBench-v1/qsort,1.1145510835913313,61.80645179748535,opt -inferattrs -add-discriminators -memcpyopt -lowerswitch -constmerge -memcpyopt -elim-avail-extern -loop-load-elim -loop-distribute -deadargelim -loop-reroll -reg2mem -instnamer -globaldce -sancov -simple-loop-unswitch -ipconstprop -strip -loweratomic -loop-distribute -sroa -called-value-propagation -loop-distribute -instcombine -cross-dso-cfi -loop-predication -div-rem-pairs -loop-fusion -loop-reroll -loop-idiom -newgvn -globalsplit -dce -bdce -coro-cleanup -coro-cleanup -ee-instrument -coro-elide -loop-distribute -always-inline -lcssa -speculative-execution -loop-distribute -slsr -lower-matrix-intrinsics -instnamer -guard-widening -deadargelim -forceattrs -loop-deletion -rewrite-statepoints-for-gc -coro-cleanup -tailcallelim -loop-predication -loop-versioning -break-crit-edges -cross-dso-cfi -load-store-vectorizer -sink -redundant-dbg-inst-elim -break-crit-edges -sccp -lowerinvoke -deadargelim -dse -functionattrs -constmerge -tailcallelim -gvn-hoist -attributor -inject-tli-mappings -separate-const-offset-from-gep -mergefunc -flattencfg -libcalls-shrinkwrap -scalarizer -name-anon-globals -scalarizer -guard-widening -loop-data-prefetch -loop-simplifycfg -slp-vectorizer -deadargelim -loop-unswitch -dce -loop-reroll -mem2reg -indvars -flattencfg -inject-tli-mappings -div-rem-pairs -strip-dead-prototypes -loop-idiom -loop-distribute -loop-guard-widening -globaldce -sink -attributor -slp-vectorizer -ee-instrument -loop-interchange -loweratomic -lowerinvoke -partially-inline-libcalls -lowerswitch -lower-constant-intrinsics -loop-simplify -rewrite-statepoints-for-gc -adce -jump-threading -loop-load-elim -alignment-from-assumptions -globaldce -inject-tli-mappings -loop-sink -scalarizer -pgo-memop-opt -argpromotion -adce -functionattrs -sink -irce -sroa -alignment-from-assumptions -loweratomic -ipconstprop -globalsplit -lcssa -newgvn -attributor -speculative-execution -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/qsort,1.117647058823529,61.690404653549194,opt -globaldce -mergefunc -gvn-hoist -ipconstprop -mergeicmps -tailcallelim -newgvn -loop-simplifycfg -mem2reg -lower-guard-intrinsic -constprop -constmerge -mldst-motion -barrier -tailcallelim -lowerinvoke -barrier -name-anon-globals -lower-matrix-intrinsics -lcssa -strip-dead-prototypes -globaldce -loop-predication -slp-vectorizer -guard-widening -always-inline -coro-cleanup -loop-unroll-and-jam -slp-vectorizer -elim-avail-extern -instcombine -inferattrs -slp-vectorizer -lowerswitch -insert-gcov-profiling -coro-early -instnamer -strip-debug-declare -globalopt -simplifycfg -loop-deletion -globalsplit -loop-guard-widening -gvn-hoist -simplifycfg -libcalls-shrinkwrap -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/qsort,1.1207430340557274,61.65247201919556,opt -slsr -coro-cleanup -insert-gcov-profiling -lowerswitch -sink -lower-widenable-condition -post-inline-ee-instrument -coro-split -strip-debug-declare -deadargelim -lower-constant-intrinsics -loop-reroll -forceattrs -jump-threading -loop-reduce -canonicalize-aliases -loop-interchange -loop-idiom -globalsplit -loop-distribute -callsite-splitting -mergereturn -bdce -loop-vectorize -loop-unswitch -partially-inline-libcalls -ee-instrument -loop-load-elim -globaldce -coro-split -deadargelim -barrier -loweratomic -slsr -elim-avail-extern -loop-data-prefetch -sroa -alignment-from-assumptions -gvn -strip-nondebug -libcalls-shrinkwrap -indvars -loop-unroll-and-jam -guard-widening -loop-guard-widening -insert-gcov-profiling -loop-simplify -gvn -guard-widening -jump-threading -globalopt -coro-elide -early-cse-memssa -infer-address-spaces -loop-simplifycfg -float2int -sccp -dse -lower-guard-intrinsic -loop-deletion -lower-guard-intrinsic -lcssa -loop-vectorize -strip -ipsccp -die -prune-eh -dse -inject-tli-mappings -inferattrs -mergeicmps -alignment-from-assumptions -strip-debug-declare -strip-dead-prototypes -simple-loop-unswitch -coro-split -gvn -lowerinvoke -sink -inject-tli-mappings -loop-data-prefetch -break-crit-edges -libcalls-shrinkwrap -strip -speculative-execution -adce -loweratomic -hotcoldsplit -reassociate -redundant-dbg-inst-elim -strip -guard-widening -strip-debug-declare -inferattrs -newgvn -sancov -loop-distribute -adce -licm -add-discriminators -insert-gcov-profiling -ee-instrument -instcombine -attributor -loop-unswitch -loop-deletion -canonicalize-aliases -coro-cleanup -deadargelim -strip-nondebug -add-discriminators -libcalls-shrinkwrap -div-rem-pairs -lower-constant-intrinsics -barrier -sancov -instnamer -simplifycfg -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/qsort,1.1207430340557276,61.6931471824646,opt -loop-load-elim -irce -loop-sink -loop-idiom -loop-deletion -early-cse-memssa -pgo-memop-opt -partially-inline-libcalls -break-crit-edges -mldst-motion -rpo-functionattrs -elim-avail-extern -canonicalize-aliases -libcalls-shrinkwrap -irce -loweratomic -constmerge -strip -loop-load-elim -licm -callsite-splitting -inject-tli-mappings -globalsplit -loop-versioning-licm -loop-reroll -float2int -loop-unswitch -separate-const-offset-from-gep -slp-vectorizer -sccp -aggressive-instcombine -gvn -loop-guard-widening -flattencfg -prune-eh -loop-unroll-and-jam -float2int -loop-fusion -instcombine -adce -load-store-vectorizer -die -pgo-memop-opt -ipsccp -rewrite-statepoints-for-gc -loop-simplifycfg -simplifycfg -reassociate -strip -globalsplit -coro-early -gvn input.bc -o output.bc -benchmark://cBench-v1/qsort,1.1207430340557276,61.77819585800171,opt -loop-reduce -break-crit-edges -hotcoldsplit -loop-interchange -post-inline-ee-instrument -reassociate -loop-fusion -coro-elide -irce -loop-idiom -libcalls-shrinkwrap -gvn-hoist -called-value-propagation -loop-data-prefetch -coro-cleanup -lowerinvoke -name-anon-globals -load-store-vectorizer -canonicalize-aliases -constprop -forceattrs -slsr -rewrite-statepoints-for-gc -functionattrs -name-anon-globals -sroa -sancov -licm -strip-debug-declare -consthoist -ee-instrument -lower-expect -loop-deletion -gvn -instcombine -rewrite-statepoints-for-gc -pgo-memop-opt -newgvn -loop-fusion -lowerinvoke -lower-constant-intrinsics -instcombine -callsite-splitting -newgvn -float2int -loop-sink -canonicalize-aliases -div-rem-pairs -float2int -instcombine -rpo-functionattrs -forceattrs -mergefunc -separate-const-offset-from-gep -guard-widening -lower-guard-intrinsic -div-rem-pairs -scalarizer -die -ipconstprop -prune-eh -irce -mem2reg -coro-cleanup -simplifycfg -inject-tli-mappings -correlated-propagation input.bc -o output.bc -benchmark://cBench-v1/qsort,1.1207430340557276,61.80295729637146,opt -mergefunc -separate-const-offset-from-gep -loop-unroll -called-value-propagation -loop-reroll -elim-avail-extern -sroa -name-anon-globals -loop-predication -add-discriminators -name-anon-globals -speculative-execution -loop-reroll -elim-avail-extern -inject-tli-mappings -globalopt -loop-unswitch -sancov -mergefunc -coro-cleanup -div-rem-pairs -loop-simplify -newgvn -barrier -instcombine -lcssa -early-cse-memssa -lower-matrix-intrinsics -break-crit-edges -loop-guard-widening -nary-reassociate -strip-dead-prototypes -slp-vectorizer -dse -loop-instsimplify -loweratomic -instnamer -functionattrs -globalopt -strip-nondebug -consthoist -slp-vectorizer -name-anon-globals -load-store-vectorizer -coro-split -slsr -sink -loop-interchange -float2int -argpromotion -simplifycfg -instsimplify -gvn input.bc -o output.bc -benchmark://cBench-v1/qsort,1.1207430340557276,64.49103260040283,opt -coro-early -coro-early -loop-deletion -ee-instrument -sink -argpromotion -lcssa -partially-inline-libcalls -sancov -div-rem-pairs -separate-const-offset-from-gep -load-store-vectorizer -aggressive-instcombine -simple-loop-unswitch -bdce -newgvn -instsimplify -early-cse-memssa -sink -inferattrs -bdce -rpo-functionattrs -ipconstprop -consthoist -mergereturn -scalarizer -redundant-dbg-inst-elim -loop-idiom -mem2reg -globalopt -lowerswitch -elim-avail-extern -loop-reroll -deadargelim -elim-avail-extern -lowerinvoke -scalarizer -barrier -instcombine -loop-unswitch -lower-expect -lowerinvoke -separate-const-offset-from-gep -guard-widening -barrier -gvn -deadargelim -pgo-memop-opt -guard-widening -reassociate -mergeicmps -instnamer -flattencfg -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/qsort,1.1207430340557278,61.58107852935791,opt -scalarizer -mergefunc -reassociate -loop-vectorize -loop-instsimplify -guard-widening -lower-constant-intrinsics -sancov -constprop -newgvn -guard-widening -mem2reg -instcombine -canonicalize-aliases -licm -alignment-from-assumptions -inject-tli-mappings -mergereturn -sancov -lcssa -sccp -loop-simplifycfg -sccp -ipsccp -constmerge -lower-constant-intrinsics -lower-constant-intrinsics -callsite-splitting -loop-versioning -die -break-crit-edges -coro-cleanup -strip -post-inline-ee-instrument -lower-constant-intrinsics -lower-widenable-condition -elim-avail-extern -strip-nondebug -newgvn -lower-matrix-intrinsics -dse -nary-reassociate -name-anon-globals -reassociate -gvn-hoist -globalsplit -insert-gcov-profiling -strip-debug-declare -die -sccp -newgvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/qsort,1.1238390092879258,61.713104486465454,opt -partially-inline-libcalls -consthoist -loop-versioning -instnamer -add-discriminators -name-anon-globals -lower-guard-intrinsic -mergereturn -newgvn -indvars -name-anon-globals -callsite-splitting -lowerinvoke -scalarizer -lowerswitch -constmerge -loop-sink -instcombine -consthoist -separate-const-offset-from-gep -loop-sink -inject-tli-mappings -loop-reduce -slsr -gvn -ipsccp -always-inline -sink -slsr -insert-gcov-profiling -post-inline-ee-instrument -sancov -loop-deletion -strip-nondebug -loop-interchange -indvars -sccp -globaldce -loop-predication -strip-dead-prototypes -dce -lower-constant-intrinsics -rpo-functionattrs -instcombine -lower-guard-intrinsic -nary-reassociate -memcpyopt -strip-dead-prototypes -simple-loop-unswitch -ee-instrument -sroa -mergeicmps -libcalls-shrinkwrap -lower-widenable-condition -strip-debug-declare -partially-inline-libcalls -gvn -div-rem-pairs -lower-constant-intrinsics -canonicalize-aliases -callsite-splitting -dce -die -dse -coro-cleanup -inject-tli-mappings -instsimplify -inject-tli-mappings -die -strip-debug-declare -coro-split -loop-unroll -nary-reassociate -sancov -guard-widening -correlated-propagation -strip-dead-prototypes -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/qsort,1.123839009287926,61.65643358230591,opt -instsimplify -globalopt -mergereturn -load-store-vectorizer -reg2mem -loop-simplify -ipsccp -slsr -load-store-vectorizer -loop-unswitch -indvars -loop-deletion -mergeicmps -memcpyopt -pgo-memop-opt -forceattrs -argpromotion -infer-address-spaces -flattencfg -loop-load-elim -simplifycfg -loop-vectorize -ipsccp -irce -load-store-vectorizer -div-rem-pairs -loop-unswitch -barrier -strip-debug-declare -slsr -licm -instnamer -loop-data-prefetch -sccp -deadargelim -lcssa -pgo-memop-opt -canonicalize-aliases -inferattrs -loop-reroll -speculative-execution -separate-const-offset-from-gep -globalopt -nary-reassociate -slsr -constprop -scalarizer -called-value-propagation -hotcoldsplit -loop-versioning -nary-reassociate -libcalls-shrinkwrap -lcssa -strip-nondebug -mldst-motion -coro-cleanup -gvn-hoist -mergefunc -strip-dead-prototypes -ee-instrument -mergefunc -strip-dead-prototypes -die -nary-reassociate -reassociate -loop-versioning -loop-vectorize -aggressive-instcombine -loop-unroll-and-jam -gvn -float2int -globaldce -globaldce -constmerge -consthoist -dse -sancov -add-discriminators -prune-eh -simplifycfg -loop-unroll -forceattrs -newgvn -canonicalize-aliases -loop-vectorize -float2int -mergereturn -loop-deletion -partial-inliner -bdce -instsimplify -loop-data-prefetch -reassociate -dse -post-inline-ee-instrument -scalarizer -called-value-propagation -strip -loop-instsimplify -aggressive-instcombine -nary-reassociate -loop-predication -loop-load-elim -lower-guard-intrinsic -name-anon-globals -lowerinvoke -strip -loop-simplify -loop-guard-widening -break-crit-edges -loop-unswitch -sancov -instsimplify -gvn-hoist -nary-reassociate -newgvn -newgvn -load-store-vectorizer -gvn-hoist -licm -ee-instrument -flattencfg -loop-predication -globalsplit -newgvn -canonicalize-aliases -instnamer -instcombine -coro-early -bdce -irce -loop-versioning -simplifycfg -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.0969720199310078,63.5710289478302,opt -partially-inline-libcalls -simplifycfg -reassociate -called-value-propagation -loop-fusion -libcalls-shrinkwrap -loop-sink -ee-instrument -canonicalize-aliases -loop-distribute -gvn -mem2reg -sancov -float2int -loop-load-elim -slp-vectorizer -dse -licm -jump-threading -loop-fusion -instcombine -div-rem-pairs -rpo-functionattrs -slsr -gvn-hoist -constmerge -loweratomic -loop-versioning-licm -memcpyopt -nary-reassociate -constprop -infer-address-spaces -lower-guard-intrinsic -rpo-functionattrs -prune-eh -strip -bdce -mldst-motion -strip-debug-declare -rpo-functionattrs -loop-reroll -functionattrs -slp-vectorizer -loop-instsimplify -div-rem-pairs -mem2reg -mergereturn -ipconstprop -loop-distribute -callsite-splitting -newgvn -coro-split -ee-instrument -alignment-from-assumptions -mergeicmps -loop-simplify -instsimplify -mem2reg -sroa -loop-data-prefetch -tailcallelim -loop-interchange -gvn-hoist -called-value-propagation -float2int -jump-threading -loop-sink -loop-idiom -inject-tli-mappings -loop-guard-widening -instnamer -inferattrs -ee-instrument -newgvn input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.0981218857799924,62.43927502632141,opt -sroa -loop-vectorize -die -simplifycfg -slp-vectorizer -argpromotion -loop-unroll-and-jam -gvn-hoist -pgo-memop-opt -forceattrs -reassociate -called-value-propagation -instcombine -loop-load-elim -coro-elide -gvn-hoist -insert-gcov-profiling -reassociate -irce -ipconstprop -libcalls-shrinkwrap -loop-data-prefetch -instcombine -deadargelim -partially-inline-libcalls -canonicalize-aliases -speculative-execution -bdce -lower-expect -loop-interchange -coro-cleanup -newgvn input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.100038328861633,62.28735589981079,opt -strip-debug-declare -loweratomic -alignment-from-assumptions -ipsccp -loop-guard-widening -flattencfg -redundant-dbg-inst-elim -lower-expect -instnamer -prune-eh -early-cse-memssa -inject-tli-mappings -gvn -constprop -ee-instrument -inferattrs -loop-sink -prune-eh -loop-reduce -mergeicmps -dse -canonicalize-aliases -irce -mergeicmps -argpromotion -lower-widenable-condition -loop-reduce -inferattrs -jump-threading -tailcallelim -strip-debug-declare -always-inline -sccp -sancov -mergereturn -always-inline -inject-tli-mappings -loop-unroll-and-jam -mergeicmps -dce -consthoist -rewrite-statepoints-for-gc -loop-reduce -instcombine -die -loop-simplifycfg -pgo-memop-opt -coro-split -rewrite-statepoints-for-gc -break-crit-edges -argpromotion -canonicalize-aliases -reassociate -called-value-propagation -partial-inliner -rewrite-statepoints-for-gc -gvn -jump-threading -prune-eh -forceattrs -loop-fusion -sancov -newgvn -sroa -tailcallelim -libcalls-shrinkwrap -rewrite-statepoints-for-gc -argpromotion -instcombine -sancov -canonicalize-aliases -argpromotion -coro-elide -slsr -loop-guard-widening -coro-cleanup -dse -inject-tli-mappings -coro-early -libcalls-shrinkwrap -newgvn -loweratomic -inferattrs -strip-nondebug -coro-cleanup -lower-matrix-intrinsics -die -loop-fusion -jump-threading -loop-instsimplify -simplifycfg -lower-widenable-condition -sink -sancov -cross-dso-cfi -gvn input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.1008049060942893,64.57522320747375,opt -mem2reg -loop-simplifycfg -die -strip-dead-prototypes -ee-instrument -name-anon-globals -reassociate -gvn-hoist -globalopt -loop-simplify -loweratomic -loweratomic -loop-reroll -inferattrs -coro-elide -separate-const-offset-from-gep -lcssa -newgvn -loop-sink -ipconstprop -early-cse-memssa -loop-fusion -hotcoldsplit -cross-dso-cfi -scalarizer -loop-distribute -globalopt -sink -newgvn -name-anon-globals -called-value-propagation -cross-dso-cfi -die -canonicalize-aliases -lower-guard-intrinsic -prune-eh -loop-fusion -libcalls-shrinkwrap -lcssa -slp-vectorizer -nary-reassociate -loop-versioning -infer-address-spaces -constmerge -loweratomic -partial-inliner -sroa -mldst-motion -coro-elide -constmerge -flattencfg -constmerge -lowerinvoke -attributor -bdce -lower-widenable-condition -argpromotion -ipsccp -globaldce -licm -loweratomic -div-rem-pairs -globalopt -speculative-execution -inferattrs -lcssa -deadargelim -lowerinvoke -partially-inline-libcalls -loop-simplify -separate-const-offset-from-gep -slp-vectorizer -strip-debug-declare -newgvn -sccp -break-crit-edges -forceattrs -irce -simplifycfg -lower-guard-intrinsic -instcombine -loop-versioning -mergereturn -bdce -lower-constant-intrinsics -guard-widening -bdce -flattencfg -lower-matrix-intrinsics -coro-elide -loop-fusion -lower-guard-intrinsic -ipconstprop -mergereturn -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.1011881947106172,62.217052936553955,opt -correlated-propagation -forceattrs -lcssa -guard-widening -memcpyopt -instcombine -reassociate -loop-predication -hotcoldsplit -nary-reassociate -slsr -libcalls-shrinkwrap -infer-address-spaces -constmerge -aggressive-instcombine -flattencfg -sink -infer-address-spaces -lower-expect -constmerge -break-crit-edges -mergereturn -loop-simplifycfg -partially-inline-libcalls -instcombine -loop-guard-widening -sancov -forceattrs -loop-reroll -lcssa -strip -constmerge -instsimplify -loop-load-elim -coro-early -guard-widening -loweratomic -loop-vectorize -rpo-functionattrs -gvn -cross-dso-cfi -loop-fusion -ee-instrument -indvars -break-crit-edges -consthoist -argpromotion -loop-guard-widening -functionattrs -ipsccp -die -gvn-hoist -loop-guard-widening -coro-elide -sccp -constprop -sroa -slsr -consthoist -loop-data-prefetch -correlated-propagation -loop-versioning-licm -infer-address-spaces -loop-vectorize -nary-reassociate -loop-idiom -mem2reg -inject-tli-mappings -speculative-execution -break-crit-edges -loweratomic -loop-unswitch -coro-early -mem2reg -dce -partial-inliner -pgo-memop-opt -loop-guard-widening -gvn-hoist -pgo-memop-opt -mem2reg -strip-dead-prototypes -loweratomic -constprop -ee-instrument -mem2reg -always-inline -callsite-splitting -flattencfg -loop-deletion -globalopt -memcpyopt -instnamer -loweratomic -loweratomic -constmerge -lower-expect -nary-reassociate -attributor -globalopt -simplifycfg -globalopt -pgo-memop-opt -slsr -instcombine input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.1015714833269452,62.28260684013367,opt -globalsplit -speculative-execution -ee-instrument -cross-dso-cfi -lowerinvoke -dse -loop-unroll-and-jam -aggressive-instcombine -ee-instrument -strip-nondebug -elim-avail-extern -sink -loop-reroll -loweratomic -loop-distribute -instsimplify -irce -loop-deletion -add-discriminators -loop-interchange -loop-idiom -break-crit-edges -irce -sccp -sancov -loop-instsimplify -break-crit-edges -called-value-propagation -functionattrs -gvn-hoist -loop-unroll-and-jam -elim-avail-extern -ee-instrument -div-rem-pairs -coro-split -simple-loop-unswitch -loop-unswitch -ipconstprop -forceattrs -partially-inline-libcalls -sroa -instcombine -float2int -early-cse-memssa -simplifycfg -post-inline-ee-instrument -loweratomic -globalopt -lowerinvoke -lower-guard-intrinsic -slsr -gvn -loweratomic -newgvn -libcalls-shrinkwrap -inject-tli-mappings -callsite-splitting -aggressive-instcombine -instcombine input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.1023380605596014,61.92038822174072,opt -strip -loop-fusion -correlated-propagation -lower-matrix-intrinsics -consthoist -mldst-motion -inject-tli-mappings -nary-reassociate -partial-inliner -loop-load-elim -loop-simplify -strip-dead-prototypes -ipconstprop -loop-data-prefetch -functionattrs -reassociate -constmerge -indvars -lower-guard-intrinsic -loop-unswitch -indvars -coro-elide -sroa -add-discriminators -flattencfg -indvars -bdce -libcalls-shrinkwrap -elim-avail-extern -memcpyopt -loop-unroll -mergereturn -strip-debug-declare -always-inline -loop-simplify -loop-reroll -loop-simplifycfg -adce -constmerge -loop-versioning -coro-split -loop-simplify -bdce -jump-threading -libcalls-shrinkwrap -loop-simplifycfg -argpromotion -functionattrs -loop-interchange -called-value-propagation -instcombine -reg2mem -pgo-memop-opt -lower-constant-intrinsics -ipsccp -called-value-propagation -scalarizer -slp-vectorizer -instsimplify -mldst-motion -coro-elide -jump-threading -newgvn -ipsccp -infer-address-spaces -mergefunc -globaldce -insert-gcov-profiling -name-anon-globals -nary-reassociate -lower-matrix-intrinsics -mem2reg -loop-load-elim -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.1027213491759291,62.01464819908142,opt -slsr -nary-reassociate -indvars -loop-vectorize -coro-elide -loop-versioning -elim-avail-extern -irce -loop-versioning-licm -instnamer -prune-eh -bdce -loop-simplify -sroa -early-cse-memssa -inferattrs -infer-address-spaces -constmerge -mem2reg -strip-nondebug -deadargelim -constmerge -instcombine -instsimplify -loop-instsimplify -coro-cleanup -functionattrs -globalsplit -simplifycfg -dse -mergereturn -redundant-dbg-inst-elim -slsr -forceattrs -loop-simplify -jump-threading -globalsplit -simplifycfg -called-value-propagation -adce -reassociate -lowerinvoke -gvn input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.1038712150249135,62.3216187953949,opt -slsr -lower-expect -globalsplit -die -irce -slp-vectorizer -elim-avail-extern -partial-inliner -simplifycfg -sroa -forceattrs -lower-widenable-condition -sancov -cross-dso-cfi -consthoist -mergeicmps -ee-instrument -loop-simplifycfg -mem2reg -loop-load-elim -globalopt -mergereturn -strip-dead-prototypes -callsite-splitting -sink -attributor -gvn -loop-sink -loop-guard-widening -correlated-propagation -separate-const-offset-from-gep -simple-loop-unswitch -loop-distribute -lower-expect -rewrite-statepoints-for-gc -redundant-dbg-inst-elim -loop-distribute -rewrite-statepoints-for-gc -loop-predication -break-crit-edges -strip-debug-declare -nary-reassociate -lowerinvoke -loop-guard-widening -jump-threading -correlated-propagation -sroa -post-inline-ee-instrument -rewrite-statepoints-for-gc -forceattrs -dse -loop-fusion -die -prune-eh -cross-dso-cfi -newgvn -separate-const-offset-from-gep -infer-address-spaces -alignment-from-assumptions -loop-sink -guard-widening -called-value-propagation -gvn-hoist -globalopt -simplifycfg -div-rem-pairs -instcombine -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/rijndael,1.1046377922575703,62.29489493370056,opt -adce -pgo-memop-opt -speculative-execution -loop-unroll-and-jam -coro-cleanup -loop-sink -dce -newgvn -simple-loop-unswitch -irce -inferattrs -argpromotion -always-inline -simplifycfg -globaldce -simplifycfg -lower-widenable-condition -globalsplit -deadargelim -loop-guard-widening -deadargelim -flattencfg -functionattrs -constmerge -loop-distribute -lower-widenable-condition -coro-cleanup -simple-loop-unswitch -sroa -loop-vectorize -mergereturn -gvn-hoist -infer-address-spaces -loop-deletion -ee-instrument -pgo-memop-opt -prune-eh -rpo-functionattrs -loop-data-prefetch -loop-guard-widening -instsimplify -lower-matrix-intrinsics -instsimplify -dce -pgo-memop-opt -inferattrs -strip-dead-prototypes -alignment-from-assumptions -gvn -loop-deletion -simplifycfg -globalopt -reg2mem -insert-gcov-profiling -loop-simplify -indvars -newgvn -loop-distribute -simple-loop-unswitch -ipsccp -inline -loop-vectorize -constmerge -loop-deletion -loop-unroll -gvn-hoist -callsite-splitting -cross-dso-cfi -flattencfg -mergefunc -loop-data-prefetch -name-anon-globals -jump-threading -mldst-motion -coro-cleanup -consthoist -strip-nondebug -bdce -loop-interchange -loop-idiom -tailcallelim -gvn -reg2mem -sccp -dse -correlated-propagation -insert-gcov-profiling -alignment-from-assumptions -newgvn -insert-gcov-profiling -deadargelim -div-rem-pairs -tailcallelim -loop-idiom -lower-widenable-condition -jump-threading -partially-inline-libcalls -mergeicmps -newgvn -coro-elide -inline -rpo-functionattrs -lowerinvoke -early-cse-memssa -loop-sink -tailcallelim -globalopt -adce -coro-split -ipconstprop -dse -loop-instsimplify -canonicalize-aliases -instcombine -bdce -loop-unswitch -jump-threading -loop-distribute -coro-cleanup -prune-eh -attributor -reassociate -globaldce -loop-predication -callsite-splitting -prune-eh -indvars -instsimplify -loop-predication -early-cse-memssa -gvn -loop-versioning -instcombine -loop-load-elim -loop-fusion -loop-rotate -loop-reroll -lower-constant-intrinsics -newgvn -loop-reroll -loop-guard-widening -argpromotion -loop-distribute -forceattrs -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/sha,1.4816053511705685,61.649839878082275,opt -loop-guard-widening -tailcallelim -partially-inline-libcalls -loop-simplifycfg -attributor -dse -reg2mem -loop-load-elim -ipconstprop -reg2mem -strip-nondebug -load-store-vectorizer -lower-constant-intrinsics -infer-address-spaces -instsimplify -prune-eh -early-cse-memssa -slsr -post-inline-ee-instrument -newgvn -loop-idiom -simplifycfg -globalopt -loop-data-prefetch -rewrite-statepoints-for-gc -elim-avail-extern -slp-vectorizer -argpromotion -speculative-execution -instcombine -div-rem-pairs -prune-eh -sink -alignment-from-assumptions -float2int -loop-instsimplify -adce -tailcallelim -loop-interchange -functionattrs -bdce -sroa -loop-versioning-licm -jump-threading -loop-versioning-licm -mldst-motion -strip-debug-declare -loop-load-elim -lowerswitch -mergeicmps -strip-nondebug -loop-load-elim -indvars -mergeicmps -nary-reassociate -coro-early -speculative-execution -sancov -sccp -lowerinvoke -alignment-from-assumptions -lower-expect -sccp -loop-interchange -globalopt -prune-eh -slsr -strip-nondebug -slsr -loop-data-prefetch -nary-reassociate -mergeicmps -cross-dso-cfi -loop-unroll-and-jam -loop-reroll -flattencfg -strip-dead-prototypes -elim-avail-extern -mem2reg -sccp -separate-const-offset-from-gep -slp-vectorizer -callsite-splitting -barrier -globalsplit -div-rem-pairs -cross-dso-cfi -name-anon-globals -loop-predication -reassociate -dse -newgvn -rpo-functionattrs -div-rem-pairs -separate-const-offset-from-gep -mem2reg -loop-unroll-and-jam -libcalls-shrinkwrap -hotcoldsplit -functionattrs -infer-address-spaces -reassociate -mldst-motion -loop-data-prefetch -strip-debug-declare -lcssa -correlated-propagation -separate-const-offset-from-gep -coro-early -licm -rewrite-statepoints-for-gc -gvn -strip-debug-declare -mergereturn -lower-guard-intrinsic -guard-widening -reassociate -insert-gcov-profiling -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/sha,1.4983277591973243,61.73563838005066,opt -lowerswitch -tailcallelim -slp-vectorizer -newgvn -globalsplit -always-inline -argpromotion -called-value-propagation -constprop -correlated-propagation -add-discriminators -sancov -lower-matrix-intrinsics -loweratomic -mergefunc -loop-reduce -die -guard-widening -loop-unroll-and-jam -slsr -indvars -partially-inline-libcalls -strip-dead-prototypes -instnamer -sroa -lower-widenable-condition -strip-debug-declare -partial-inliner -lower-expect -tailcallelim -float2int -redundant-dbg-inst-elim -alignment-from-assumptions -loop-distribute -instcombine -correlated-propagation -loop-unroll-and-jam -loop-fusion -correlated-propagation -coro-early -scalarizer -elim-avail-extern -ipconstprop -loop-data-prefetch -scalarizer -newgvn -mergeicmps -loop-versioning-licm -canonicalize-aliases -coro-elide -slp-vectorizer -float2int -loweratomic -separate-const-offset-from-gep -redundant-dbg-inst-elim -called-value-propagation -libcalls-shrinkwrap -loop-guard-widening -argpromotion -indvars -elim-avail-extern -reassociate -prune-eh -libcalls-shrinkwrap -ipconstprop -mergeicmps -globaldce -coro-cleanup -break-crit-edges -slsr -mem2reg -gvn-hoist -loop-deletion -dce -post-inline-ee-instrument -loop-simplify -simplifycfg -mergereturn -strip -functionattrs -inferattrs -instcombine -libcalls-shrinkwrap -div-rem-pairs -loweratomic -always-inline -called-value-propagation -loop-data-prefetch -argpromotion -functionattrs -instsimplify -flattencfg -loop-data-prefetch -strip-debug-declare -licm -strip -attributor -gvn -cross-dso-cfi -functionattrs -inferattrs -insert-gcov-profiling -flattencfg -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/sha,1.501672240802675,61.79606604576111,opt -redundant-dbg-inst-elim -mergefunc -nary-reassociate -adce -licm -loop-data-prefetch -constprop -die -lowerswitch -scalarizer -lcssa -sancov -adce -ipconstprop -inject-tli-mappings -loop-interchange -pgo-memop-opt -break-crit-edges -deadargelim -ipconstprop -post-inline-ee-instrument -loop-sink -sancov -sroa -instcombine -early-cse-memssa -loop-deletion -loop-versioning-licm -slsr -ee-instrument -reg2mem -mergeicmps -loop-deletion -lower-constant-intrinsics -div-rem-pairs -coro-early -indvars -forceattrs -early-cse-memssa -gvn -early-cse-memssa -loop-sink -loop-instsimplify -mem2reg -coro-split -name-anon-globals -loop-interchange -irce -indvars -libcalls-shrinkwrap -load-store-vectorizer -simplifycfg -redundant-dbg-inst-elim -gvn -nary-reassociate -simplifycfg -sroa -argpromotion -post-inline-ee-instrument -bdce -ee-instrument -lower-expect -loop-interchange -speculative-execution -loop-distribute -lower-guard-intrinsic -lowerswitch -sancov -inject-tli-mappings -mldst-motion -inferattrs -loop-simplify -mergeicmps -globaldce -licm -simplifycfg -strip-nondebug -mergereturn -strip-dead-prototypes -scalarizer -adce -rewrite-statepoints-for-gc -float2int -deadargelim -globaldce -coro-early -called-value-propagation -coro-early -gvn-hoist -mergefunc -memcpyopt -mergefunc -flattencfg -loop-interchange -jump-threading -reassociate -alignment-from-assumptions -globalopt -constmerge -gvn -instcombine input.bc -o output.bc -benchmark://cBench-v1/sha,1.5050167224080266,61.69275736808777,opt -lower-matrix-intrinsics -barrier -slsr -partially-inline-libcalls -instsimplify -loop-unroll-and-jam -speculative-execution -loop-unroll -loop-distribute -functionattrs -hotcoldsplit -forceattrs -mem2reg -partial-inliner -sroa -functionattrs -loop-idiom -scalarizer -attributor -add-discriminators -add-discriminators -newgvn -loop-sink -add-discriminators -coro-early -callsite-splitting -strip -indvars -libcalls-shrinkwrap -loop-deletion -add-discriminators -pgo-memop-opt -constprop -loop-unroll-and-jam -rpo-functionattrs -add-discriminators -globalsplit -dse -mldst-motion -instcombine -loop-idiom -globalsplit -globaldce -memcpyopt -loop-versioning -correlated-propagation -flattencfg -adce -gvn-hoist -adce -nary-reassociate -instnamer -simplifycfg -lowerinvoke -speculative-execution -gvn -tailcallelim -sancov -inferattrs -deadargelim -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/sha,1.5083612040133778,61.7785108089447,opt -lower-widenable-condition -break-crit-edges -early-cse-memssa -loop-predication -ipsccp -float2int -indvars -post-inline-ee-instrument -ipconstprop -instnamer -loop-predication -loop-idiom -libcalls-shrinkwrap -strip-dead-prototypes -die -lower-guard-intrinsic -mldst-motion -loop-interchange -flattencfg -reassociate -loop-data-prefetch -flattencfg -gvn -functionattrs -dce -lower-widenable-condition -float2int -name-anon-globals -simplifycfg -speculative-execution -mldst-motion -libcalls-shrinkwrap -strip-nondebug -forceattrs -strip-debug-declare -post-inline-ee-instrument -prune-eh -sancov -loop-unroll-and-jam -sccp -loop-versioning-licm -coro-early -lower-widenable-condition -speculative-execution -mem2reg -globalopt -strip -coro-split -loop-idiom -loop-simplify -callsite-splitting -instcombine -dse -adce -sink -nary-reassociate -gvn -sroa -mergereturn -coro-early -rpo-functionattrs -newgvn -add-discriminators -called-value-propagation -loop-load-elim -loop-data-prefetch -loop-deletion -barrier -loop-vectorize -callsite-splitting -indvars -deadargelim -guard-widening -die -early-cse-memssa -inferattrs -gvn -instnamer -canonicalize-aliases -argpromotion -loweratomic -inject-tli-mappings -mem2reg -loop-simplifycfg -loop-reroll -adce -ipconstprop -lowerswitch -alignment-from-assumptions -always-inline -scalarizer -guard-widening -loop-versioning-licm -inject-tli-mappings -globaldce -div-rem-pairs -insert-gcov-profiling -strip-nondebug -slp-vectorizer -loop-simplify -attributor -indvars -ipconstprop -elim-avail-extern -bdce -instsimplify -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/sha,1.5117056856187288,61.70262050628662,opt -loop-reduce -flattencfg -loop-versioning -loweratomic -sroa -strip-debug-declare -alignment-from-assumptions -insert-gcov-profiling -forceattrs -coro-elide -redundant-dbg-inst-elim -early-cse-memssa -lower-constant-intrinsics -load-store-vectorizer -gvn -loop-reroll -post-inline-ee-instrument -loop-guard-widening -speculative-execution -sroa -tailcallelim -scalarizer -dce -pgo-memop-opt -loop-distribute -mldst-motion -post-inline-ee-instrument -instnamer -speculative-execution -float2int -mergereturn -called-value-propagation -div-rem-pairs -cross-dso-cfi -cross-dso-cfi -lower-expect -redundant-dbg-inst-elim -loop-versioning-licm -speculative-execution -ipconstprop -callsite-splitting -sccp -loop-simplifycfg -simple-loop-unswitch -scalarizer -mem2reg -lower-constant-intrinsics -loop-simplify -licm -prune-eh -partially-inline-libcalls -partially-inline-libcalls -loop-data-prefetch -lcssa -dce -memcpyopt -loop-sink -redundant-dbg-inst-elim -prune-eh -strip-dead-prototypes -pgo-memop-opt -load-store-vectorizer -gvn -instcombine -loweratomic -adce -speculative-execution -loop-unroll-and-jam -mldst-motion -loop-reroll -mergereturn -post-inline-ee-instrument -strip-nondebug -forceattrs -coro-early -rewrite-statepoints-for-gc -partial-inliner -loop-distribute -strip-debug-declare -strip -mergefunc -functionattrs -infer-address-spaces -lowerswitch -tailcallelim -sccp -sink -newgvn -indvars -loop-unroll-and-jam -loop-simplify -loop-simplify -callsite-splitting -deadargelim -simplifycfg -argpromotion -coro-split -newgvn input.bc -o output.bc -benchmark://cBench-v1/sha,1.511705685618729,61.58654522895813,opt -early-cse-memssa -inferattrs -coro-elide -sccp -load-store-vectorizer -lower-guard-intrinsic -coro-elide -loop-simplifycfg -load-store-vectorizer -nary-reassociate -die -libcalls-shrinkwrap -mergeicmps -loop-versioning-licm -tailcallelim -strip -name-anon-globals -redundant-dbg-inst-elim -mldst-motion -called-value-propagation -alignment-from-assumptions -strip-debug-declare -ipconstprop -bdce -mergeicmps -elim-avail-extern -always-inline -gvn -licm -post-inline-ee-instrument -ee-instrument -cross-dso-cfi -loop-simplify -loop-reroll -jump-threading -ee-instrument -lowerinvoke -float2int -loop-versioning -hotcoldsplit -instcombine -loop-data-prefetch -reassociate -simple-loop-unswitch -coro-split -loop-simplifycfg -gvn-hoist -sancov -load-store-vectorizer -lower-expect -lowerswitch -load-store-vectorizer -loop-rotate -barrier -simple-loop-unswitch -newgvn -called-value-propagation -load-store-vectorizer -loop-predication -memcpyopt -mergeicmps -float2int -div-rem-pairs -instsimplify -loop-instsimplify -speculative-execution -coro-cleanup -inferattrs -callsite-splitting -cross-dso-cfi -correlated-propagation -consthoist -mergeicmps -loop-vectorize -constmerge -mem2reg -instsimplify -ee-instrument -coro-early -loop-data-prefetch -argpromotion -irce -indvars -scalarizer -callsite-splitting -loop-guard-widening -instcombine -sancov -loop-unroll-and-jam -loop-deletion -loop-idiom -lower-matrix-intrinsics -loop-sink -simple-loop-unswitch -sccp -memcpyopt -cross-dso-cfi -mldst-motion -gvn -slsr -inject-tli-mappings -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/sha,1.5150501672240804,62.05151176452637,opt -elim-avail-extern -early-cse-memssa -jump-threading -tailcallelim -gvn-hoist -lower-widenable-condition -partially-inline-libcalls -lower-expect -speculative-execution -loop-guard-widening -insert-gcov-profiling -globalsplit -loop-distribute -lcssa -pgo-memop-opt -reassociate -pgo-memop-opt -loop-deletion -functionattrs -instsimplify -mldst-motion -scalarizer -canonicalize-aliases -speculative-execution -loop-idiom -add-discriminators -inferattrs -barrier -globaldce -consthoist -loop-reduce -mem2reg -partially-inline-libcalls -globalsplit -partial-inliner -jump-threading -functionattrs -sancov -globaldce -float2int -div-rem-pairs -simplifycfg -speculative-execution -lower-expect -coro-split -newgvn -rpo-functionattrs -indvars -rewrite-statepoints-for-gc -simplifycfg -ipsccp -instsimplify -barrier -ipsccp -ipconstprop -ee-instrument -indvars -ee-instrument -coro-early -float2int -attributor -ipconstprop -licm -lower-expect -slsr -globaldce -rpo-functionattrs -correlated-propagation -ipsccp -mldst-motion -infer-address-spaces -load-store-vectorizer -newgvn -sccp -indvars -newgvn -simple-loop-unswitch -simplifycfg -gvn -always-inline -partially-inline-libcalls -nary-reassociate -insert-gcov-profiling -coro-early -mergeicmps -irce -instcombine -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/sha,1.5183946488294315,61.559239864349365,opt -ipconstprop -reg2mem -ipconstprop -prune-eh -pgo-memop-opt -rewrite-statepoints-for-gc -rpo-functionattrs -always-inline -constprop -globaldce -libcalls-shrinkwrap -loop-unroll -loop-reroll -consthoist -coro-split -lower-constant-intrinsics -functionattrs -pgo-memop-opt -coro-elide -slsr -inject-tli-mappings -memcpyopt -loop-vectorize -barrier -libcalls-shrinkwrap -adce -div-rem-pairs -ipsccp -memcpyopt -gvn-hoist -partially-inline-libcalls -prune-eh -lowerinvoke -always-inline -loop-reroll -lowerswitch -coro-split -break-crit-edges -nary-reassociate -partially-inline-libcalls -gvn-hoist -attributor -instnamer -rpo-functionattrs -gvn -loop-fusion -bdce -sink -add-discriminators -simplifycfg -infer-address-spaces -lcssa -strip-dead-prototypes -loop-versioning -simplifycfg -partially-inline-libcalls -loop-deletion -simple-loop-unswitch -loop-distribute -licm -loop-vectorize -aggressive-instcombine -globalsplit -lower-guard-intrinsic -constmerge -constmerge -always-inline -loop-simplify -insert-gcov-profiling -indvars -elim-avail-extern -mergeicmps -loop-interchange -mem2reg -loop-reroll -load-store-vectorizer -alignment-from-assumptions -bdce -partial-inliner -loop-distribute -gvn-hoist -memcpyopt -mergefunc -coro-split -coro-split -mldst-motion -loop-idiom -loop-deletion -rpo-functionattrs -attributor -attributor -slsr -slp-vectorizer -loop-distribute -irce -lower-guard-intrinsic -gvn -loop-versioning-licm -loop-interchange -die -add-discriminators -deadargelim -instcombine -irce -lowerinvoke -separate-const-offset-from-gep -partially-inline-libcalls -jump-threading -consthoist -constprop -libcalls-shrinkwrap -aggressive-instcombine -flattencfg -constmerge -slsr -partial-inliner -sroa -correlated-propagation -deadargelim -correlated-propagation -indvars -mergefunc -indvars -load-store-vectorizer -loop-interchange -loop-interchange -jump-threading -inject-tli-mappings -attributor -forceattrs -loop-predication -loweratomic -sroa -loop-predication -correlated-propagation -loop-distribute -simple-loop-unswitch -loop-predication -loop-interchange -slp-vectorizer -loop-predication -jump-threading -loop-simplify -sink -loop-sink -sroa -coro-early -loop-distribute -insert-gcov-profiling -post-inline-ee-instrument -memcpyopt -coro-cleanup -name-anon-globals -loop-sink -sancov -slsr -lower-matrix-intrinsics -licm -simplifycfg -dse -early-cse-memssa -attributor -strip-debug-declare -nary-reassociate -div-rem-pairs -prune-eh -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/sha,1.5250836120401334,61.66695785522461,opt -partial-inliner -coro-elide -sancov -irce -nary-reassociate -alignment-from-assumptions -mergereturn -insert-gcov-profiling -ipconstprop -instsimplify -correlated-propagation -barrier -attributor -loop-deletion -load-store-vectorizer -dce -licm -globaldce -loop-vectorize -div-rem-pairs -strip-debug-declare -load-store-vectorizer -always-inline -inferattrs -mergeicmps -sink -loop-unroll-and-jam -flattencfg -sccp -load-store-vectorizer -loop-rotate -deadargelim -lcssa -attributor -indvars -globalopt -scalarizer -coro-cleanup -prune-eh -post-inline-ee-instrument -gvn -loop-idiom -loop-load-elim -attributor -simplifycfg -strip -constmerge -indvars -sroa -dce -instcombine -separate-const-offset-from-gep -mergefunc -loop-simplify -barrier -tailcallelim -lower-expect -globalopt -libcalls-shrinkwrap -lower-widenable-condition -jump-threading -deadargelim -pgo-memop-opt -rewrite-statepoints-for-gc -callsite-splitting -mergefunc -globalsplit -mergeicmps -gvn -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/stringsearch,0.9959016393442623,61.68849325180054,opt -nary-reassociate -lower-matrix-intrinsics -cross-dso-cfi -lower-expect -canonicalize-aliases -load-store-vectorizer -forceattrs -loop-idiom -barrier -slp-vectorizer -loop-versioning-licm -insert-gcov-profiling -dse -strip-nondebug -early-cse-memssa -instnamer -globaldce -hotcoldsplit -mergeicmps -lowerinvoke -sink -coro-early -lower-constant-intrinsics -ipconstprop -pgo-memop-opt -scalarizer -sancov -loop-fusion -barrier -pgo-memop-opt -coro-split -reg2mem -globalopt -lower-expect -infer-address-spaces -constprop -loop-sink -slp-vectorizer -gvn -nary-reassociate -speculative-execution -loop-interchange -lowerinvoke -libcalls-shrinkwrap -float2int -add-discriminators -sink -elim-avail-extern -reassociate -memcpyopt -loop-sink -elim-avail-extern -redundant-dbg-inst-elim -lowerswitch -mergefunc -add-discriminators -loop-fusion -simple-loop-unswitch -lower-matrix-intrinsics -globaldce -add-discriminators -load-store-vectorizer -infer-address-spaces -callsite-splitting -loop-simplifycfg -instnamer -adce -sroa -attributor -adce -name-anon-globals -globaldce -redundant-dbg-inst-elim -forceattrs -loop-simplify -elim-avail-extern -loop-distribute -aggressive-instcombine -lowerswitch -die -strip-dead-prototypes -forceattrs -infer-address-spaces -rpo-functionattrs -loop-simplify -globalsplit -loop-load-elim -licm -lower-widenable-condition -ee-instrument -lower-constant-intrinsics -insert-gcov-profiling -float2int -globalopt -attributor -redundant-dbg-inst-elim -lower-guard-intrinsic -sccp -strip -aggressive-instcombine -strip-nondebug -ipconstprop -loop-fusion -coro-elide -strip-dead-prototypes -loop-reroll -mergeicmps -float2int -loop-data-prefetch -reassociate -hotcoldsplit -newgvn -instcombine -mldst-motion -redundant-dbg-inst-elim -jump-threading -gvn input.bc -o output.bc -benchmark://cBench-v1/stringsearch,1.0013661202185793,61.93865656852722,opt -loop-fusion -coro-elide -coro-cleanup -guard-widening -simplifycfg -mergefunc -hotcoldsplit -inferattrs -guard-widening -guard-widening -globalopt -lower-matrix-intrinsics -loop-versioning-licm -lower-widenable-condition -loop-fusion -loop-instsimplify -irce -loop-vectorize -float2int -loop-reduce -partially-inline-libcalls -sccp -lower-expect -loop-distribute -lowerswitch -loop-predication -newgvn -early-cse-memssa -lowerswitch -libcalls-shrinkwrap -loop-deletion -loweratomic -attributor -coro-cleanup -loop-guard-widening -insert-gcov-profiling -lower-constant-intrinsics -sccp -loop-idiom -gvn-hoist -slsr -barrier -gvn -mem2reg -slsr -bdce -simple-loop-unswitch -newgvn -insert-gcov-profiling -globalopt -nary-reassociate -loop-idiom -gvn-hoist -partial-inliner -lcssa -die -aggressive-instcombine -canonicalize-aliases -loop-idiom -loop-idiom -libcalls-shrinkwrap -dse -globaldce -strip -coro-cleanup -adce -instcombine -loop-data-prefetch -instnamer -newgvn -deadargelim -loop-distribute -coro-split -sancov -correlated-propagation -mergereturn -insert-gcov-profiling -mergefunc -reassociate -insert-gcov-profiling -coro-elide -post-inline-ee-instrument -callsite-splitting -libcalls-shrinkwrap -loop-predication -loop-data-prefetch -lower-matrix-intrinsics -lower-expect -instsimplify -lowerinvoke -pgo-memop-opt -ipsccp -hotcoldsplit -sroa -coro-elide -gvn -loop-unroll -globalopt -redundant-dbg-inst-elim -ipsccp -dse -loop-guard-widening -ipconstprop -loop-deletion -memcpyopt -loop-sink -loop-instsimplify -partial-inliner -die -insert-gcov-profiling -loop-sink -constmerge -mergefunc -partially-inline-libcalls -inferattrs -loweratomic -sroa -constprop -dse -libcalls-shrinkwrap -callsite-splitting -barrier -name-anon-globals -name-anon-globals -loop-predication -correlated-propagation -loop-unroll-and-jam -deadargelim -loop-idiom -loop-deletion -loop-idiom -post-inline-ee-instrument -speculative-execution -loop-sink -lowerinvoke -speculative-execution -consthoist -die -canonicalize-aliases -canonicalize-aliases -memcpyopt -scalarizer -elim-avail-extern -tailcallelim -callsite-splitting -irce -speculative-execution -post-inline-ee-instrument -barrier -loop-interchange -pgo-memop-opt -lcssa -reg2mem -functionattrs -name-anon-globals -loop-reduce -loop-fusion -indvars -loop-unroll-and-jam -correlated-propagation -lower-constant-intrinsics -float2int -loop-interchange -functionattrs -ipsccp -loop-distribute -mergefunc -mergereturn -reg2mem -irce -strip-debug-declare -irce -reg2mem -loop-versioning-licm -functionattrs -slp-vectorizer -scalarizer -sancov -barrier -coro-cleanup -loop-unroll-and-jam -pgo-memop-opt -mem2reg -instnamer -newgvn -lcssa -cross-dso-cfi -globalsplit -loop-simplify -hotcoldsplit -called-value-propagation -sroa -jump-threading -mem2reg -mergeicmps -called-value-propagation -ipsccp -loop-unroll-and-jam -simplifycfg -loop-versioning -instcombine input.bc -o output.bc -benchmark://cBench-v1/stringsearch,1.0013661202185793,62.70221829414368,opt -loop-fusion -loop-simplifycfg -loop-reduce -loop-load-elim -loop-unswitch -partially-inline-libcalls -coro-split -insert-gcov-profiling -ipsccp -always-inline -post-inline-ee-instrument -coro-elide -loop-fusion -functionattrs -gvn -prune-eh -instsimplify -die -slp-vectorizer -inferattrs -coro-split -globaldce -callsite-splitting -sccp -loop-interchange -inject-tli-mappings -loop-versioning-licm -tailcallelim -partially-inline-libcalls -insert-gcov-profiling -nary-reassociate -jump-threading -float2int -tailcallelim -sroa -loop-versioning -loop-sink -called-value-propagation -loop-unroll -sccp -barrier -loop-instsimplify -coro-elide -constmerge -strip-nondebug -nary-reassociate -coro-early -cross-dso-cfi -attributor -mergeicmps -deadargelim -speculative-execution -constmerge -alignment-from-assumptions -ipsccp -div-rem-pairs -redundant-dbg-inst-elim -speculative-execution -prune-eh -newgvn -mldst-motion -sroa -lower-widenable-condition -attributor -simplifycfg -memcpyopt -indvars -lowerswitch -newgvn -name-anon-globals -strip-debug-declare -inject-tli-mappings -prune-eh -name-anon-globals -instcombine -coro-cleanup -functionattrs -globalsplit -functionattrs -aggressive-instcombine -sancov -bdce -rewrite-statepoints-for-gc -cross-dso-cfi -indvars -ipconstprop -nary-reassociate -separate-const-offset-from-gep -callsite-splitting -canonicalize-aliases -licm -sccp -redundant-dbg-inst-elim -loop-guard-widening -loop-reroll -consthoist -float2int -gvn-hoist -loop-data-prefetch -globaldce -elim-avail-extern -loop-sink -strip-dead-prototypes -argpromotion -correlated-propagation -indvars -lower-widenable-condition -rpo-functionattrs -loop-unswitch -lower-constant-intrinsics -lower-expect -jump-threading -globaldce -globaldce -simplifycfg -lower-constant-intrinsics -infer-address-spaces -early-cse-memssa -jump-threading -elim-avail-extern -rpo-functionattrs -dse -correlated-propagation -memcpyopt -strip -alignment-from-assumptions -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/stringsearch,1.0027322404371586,61.595093727111816,opt -canonicalize-aliases -gvn-hoist -float2int -coro-early -reg2mem -ipconstprop -loop-versioning -strip-debug-declare -strip-nondebug -constprop -speculative-execution -redundant-dbg-inst-elim -licm -simplifycfg -constmerge -inferattrs -lower-widenable-condition -globalopt -loop-vectorize -deadargelim -sancov -loop-distribute -post-inline-ee-instrument -partially-inline-libcalls -lower-constant-intrinsics -dce -dse -slp-vectorizer -die -ipconstprop -loop-vectorize -slp-vectorizer -prune-eh -strip -post-inline-ee-instrument -pgo-memop-opt -partial-inliner -deadargelim -gvn -forceattrs -load-store-vectorizer -globalsplit -separate-const-offset-from-gep -loop-interchange -pgo-memop-opt -lowerswitch -reassociate -rewrite-statepoints-for-gc -mergefunc -lcssa -inferattrs -infer-address-spaces -float2int -mldst-motion -libcalls-shrinkwrap -simplifycfg -ipconstprop -deadargelim -functionattrs -loop-simplify -lower-matrix-intrinsics -strip -mergereturn -elim-avail-extern -functionattrs -rpo-functionattrs -inject-tli-mappings -loop-simplify -loop-deletion -instcombine -lowerswitch -post-inline-ee-instrument -sroa -speculative-execution -infer-address-spaces -dce -lower-widenable-condition -jump-threading -loop-load-elim -sink -partial-inliner -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/stringsearch,1.005464480874317,61.7589898109436,opt -lower-constant-intrinsics -loop-predication -rewrite-statepoints-for-gc -loop-idiom -rpo-functionattrs -hotcoldsplit -infer-address-spaces -coro-cleanup -coro-elide -jump-threading -instsimplify -loop-reroll -coro-split -sink -coro-elide -lcssa -libcalls-shrinkwrap -correlated-propagation -infer-address-spaces -sroa -newgvn -elim-avail-extern -guard-widening -always-inline -simplifycfg -ipsccp -mergeicmps -instcombine input.bc -o output.bc -benchmark://cBench-v1/stringsearch,1.0054644808743174,61.90070199966431,opt -always-inline -float2int -loop-interchange -globalsplit -constmerge -nary-reassociate -flattencfg -loop-interchange -slsr -newgvn -lower-guard-intrinsic -loweratomic -lcssa -guard-widening -prune-eh -loop-interchange -float2int -flattencfg -libcalls-shrinkwrap -loop-idiom -loop-distribute -sccp -simple-loop-unswitch -mergereturn -functionattrs -slsr -always-inline -canonicalize-aliases -redundant-dbg-inst-elim -barrier -lower-widenable-condition -coro-elide -coro-split -loop-versioning -partially-inline-libcalls -dce -attributor -canonicalize-aliases -canonicalize-aliases -canonicalize-aliases -aggressive-instcombine -infer-address-spaces -mem2reg -deadargelim -libcalls-shrinkwrap -globalsplit -lower-widenable-condition -lower-matrix-intrinsics -lcssa -guard-widening -argpromotion -coro-split -strip -dse -loop-simplifycfg -rpo-functionattrs -slsr -loop-deletion -break-crit-edges -loop-reroll -coro-cleanup -simplifycfg -strip-debug-declare -scalarizer -lowerswitch -loop-load-elim -add-discriminators -partial-inliner -coro-split -globalsplit -loop-vectorize -lower-matrix-intrinsics -lower-widenable-condition -sancov -reassociate -coro-cleanup -alignment-from-assumptions -elim-avail-extern -strip-dead-prototypes -early-cse-memssa -reassociate -reg2mem -called-value-propagation -flattencfg -loop-unswitch -coro-cleanup -constprop -canonicalize-aliases -loop-reduce -irce -elim-avail-extern -sink -argpromotion -loop-data-prefetch -inject-tli-mappings -loop-data-prefetch -redundant-dbg-inst-elim -load-store-vectorizer -lower-constant-intrinsics -simplifycfg -inline -globaldce -sccp -elim-avail-extern -strip-dead-prototypes -functionattrs -coro-split -lower-expect -cross-dso-cfi -mergeicmps -globaldce -rpo-functionattrs -dse -loop-fusion -loop-reroll -constprop -lowerswitch -correlated-propagation -speculative-execution -inferattrs -deadargelim -simplifycfg -dce -post-inline-ee-instrument -globalopt -gvn -reassociate -loop-versioning -constmerge -coro-split -always-inline -gvn -loop-sink -newgvn -loop-idiom -guard-widening -reg2mem -indvars -aggressive-instcombine -strip -deadargelim -irce -loop-unroll-and-jam -reg2mem -sroa -loop-guard-widening -loop-sink -strip -break-crit-edges -instsimplify -slsr -break-crit-edges -inferattrs -always-inline -simple-loop-unswitch -instcombine -called-value-propagation -mergeicmps -slp-vectorizer -strip-debug-declare -lower-matrix-intrinsics -break-crit-edges -loop-sink -always-inline -lcssa -loop-versioning-licm -guard-widening -consthoist -loop-load-elim -argpromotion -mergefunc -reassociate -sink -simple-loop-unswitch -aggressive-instcombine -lcssa -reg2mem -strip-nondebug -lower-widenable-condition -mergereturn -simplifycfg -load-store-vectorizer -forceattrs -constprop -instsimplify -loop-reduce -ee-instrument -loop-simplify -globalsplit -mergereturn -adce -sroa -lower-matrix-intrinsics -ee-instrument -bdce -nary-reassociate -coro-early -rpo-functionattrs -called-value-propagation -cross-dso-cfi -jump-threading -name-anon-globals -rewrite-statepoints-for-gc -loop-reroll -pgo-memop-opt -alignment-from-assumptions -bdce -memcpyopt -forceattrs -deadargelim -sccp -argpromotion -speculative-execution -strip-nondebug -die -infer-address-spaces -sccp -mergefunc -strip-nondebug -sancov -sccp -always-inline -scalarizer -forceattrs -insert-gcov-profiling -mldst-motion -barrier -loop-versioning -lcssa -infer-address-spaces -coro-split -consthoist -loop-deletion -libcalls-shrinkwrap -loop-vectorize -reassociate -loop-simplify -simplifycfg -called-value-propagation -mergeicmps -lower-widenable-condition -rpo-functionattrs -memcpyopt -newgvn -insert-gcov-profiling -newgvn -insert-gcov-profiling -always-inline -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/stringsearch,1.0068306010928962,61.69719099998474,opt -loop-reroll -sancov -pgo-memop-opt -coro-early -loop-unroll-and-jam -strip-nondebug -instsimplify -loop-simplify -strip -break-crit-edges -die -globalsplit -lower-widenable-condition -add-discriminators -mergefunc -reassociate -lower-expect -div-rem-pairs -licm -argpromotion -gvn -post-inline-ee-instrument -gvn-hoist -scalarizer -loop-interchange -sink -rpo-functionattrs -reg2mem -inject-tli-mappings -ee-instrument -float2int -reg2mem -inferattrs -newgvn -div-rem-pairs -tailcallelim -coro-cleanup -instsimplify -deadargelim -name-anon-globals -pgo-memop-opt -partial-inliner -globalsplit -loop-versioning-licm -sancov -loop-simplify -indvars -slsr -correlated-propagation -libcalls-shrinkwrap -break-crit-edges -dse -nary-reassociate -slp-vectorizer -instnamer -float2int -infer-address-spaces -guard-widening -float2int -inline -lowerinvoke -sccp -loop-simplify -loop-distribute -alignment-from-assumptions -loop-simplifycfg -jump-threading -sink -scalarizer -die -inline -loop-unroll-and-jam -elim-avail-extern -gvn -die -mldst-motion -infer-address-spaces -consthoist -lower-expect -loop-instsimplify -barrier -simplifycfg -strip-dead-prototypes -name-anon-globals -called-value-propagation -sancov -barrier -tailcallelim -tailcallelim -loop-data-prefetch -loop-vectorize -name-anon-globals -lower-expect -reassociate -lcssa -loweratomic -globaldce -gvn-hoist -libcalls-shrinkwrap -nary-reassociate -adce -dse -adce -loop-versioning-licm -dse -libcalls-shrinkwrap -canonicalize-aliases -sroa -ipsccp -mergefunc -constmerge -inferattrs -name-anon-globals -mldst-motion -pgo-memop-opt -loop-versioning -die -add-discriminators -strip-nondebug -licm -libcalls-shrinkwrap -loop-unswitch -simplifycfg -constprop -cross-dso-cfi -forceattrs -sancov -coro-early -newgvn -nary-reassociate -instcombine -mem2reg -loop-predication -cross-dso-cfi -mem2reg -loop-data-prefetch -dse -loop-vectorize -irce -strip -cross-dso-cfi -loop-versioning-licm -loweratomic -loop-simplifycfg -partial-inliner -loop-instsimplify -loop-deletion -partially-inline-libcalls -loop-unroll -loop-predication -attributor -sink -correlated-propagation -lower-constant-intrinsics -reassociate -lower-expect -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/stringsearch,1.0068306010928965,61.84607648849487,opt -constmerge -memcpyopt -libcalls-shrinkwrap -consthoist -lower-constant-intrinsics -mem2reg -loop-data-prefetch -rewrite-statepoints-for-gc -called-value-propagation -separate-const-offset-from-gep -forceattrs -gvn -loop-simplify -rpo-functionattrs -constmerge -irce -dce -loop-load-elim -coro-early -constmerge -lower-matrix-intrinsics -slp-vectorizer -slp-vectorizer -add-discriminators -gvn -scalarizer -jump-threading -die -cross-dso-cfi -strip -loop-vectorize -inferattrs -adce -loweratomic -rewrite-statepoints-for-gc -lowerswitch -post-inline-ee-instrument -float2int -argpromotion -coro-split -ipconstprop -slp-vectorizer -lowerswitch -alignment-from-assumptions -add-discriminators -consthoist -mergeicmps -argpromotion -sink -loop-load-elim -loop-versioning-licm -mem2reg -inferattrs -indvars -instcombine -coro-early -ee-instrument -instcombine -alignment-from-assumptions -loop-instsimplify -consthoist -canonicalize-aliases -coro-split -load-store-vectorizer -aggressive-instcombine -gvn -slsr -loop-reroll -lower-constant-intrinsics -instnamer -sroa -infer-address-spaces -elim-avail-extern -correlated-propagation -scalarizer -lowerinvoke -inject-tli-mappings -constmerge -strip-debug-declare -loop-unswitch -elim-avail-extern -scalarizer -functionattrs -partial-inliner -early-cse-memssa -div-rem-pairs -inferattrs -mem2reg -mergefunc -separate-const-offset-from-gep -inferattrs -globalsplit -consthoist -mergeicmps -loop-sink -lower-guard-intrinsic -nary-reassociate -rewrite-statepoints-for-gc -partial-inliner -post-inline-ee-instrument -load-store-vectorizer -mldst-motion -deadargelim -barrier -dce -simplifycfg -loop-unroll -simple-loop-unswitch -break-crit-edges -loop-sink -globalsplit -loop-deletion -strip -deadargelim -loop-sink -loop-unswitch -loop-idiom -strip-nondebug -gvn-hoist -nary-reassociate -loop-vectorize -infer-address-spaces -early-cse-memssa -dse -always-inline -coro-split -globalsplit -loop-distribute -callsite-splitting -mldst-motion -loop-simplifycfg -speculative-execution -early-cse-memssa -die -instcombine -canonicalize-aliases -coro-early -die -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/stringsearch,1.0081967213114753,61.87919545173645,opt -called-value-propagation -jump-threading -break-crit-edges -globaldce -break-crit-edges -adce -gvn-hoist -name-anon-globals -mldst-motion -coro-split -attributor -correlated-propagation -jump-threading -simple-loop-unswitch -loop-unswitch -mergefunc -loop-unroll -pgo-memop-opt -partial-inliner -tailcallelim -add-discriminators -strip-nondebug -prune-eh -strip -load-store-vectorizer -strip -loop-deletion -callsite-splitting -slp-vectorizer -licm -lower-matrix-intrinsics -aggressive-instcombine -lower-widenable-condition -lowerinvoke -sroa -attributor -instnamer -attributor -loweratomic -load-store-vectorizer -insert-gcov-profiling -globaldce -sroa -simplifycfg -loop-interchange -simple-loop-unswitch -jump-threading -guard-widening -nary-reassociate -memcpyopt -gvn -ipconstprop -functionattrs -loop-load-elim -licm -irce -pgo-memop-opt -infer-address-spaces -elim-avail-extern -sccp -elim-avail-extern -correlated-propagation -coro-split -rpo-functionattrs -prune-eh -constprop -break-crit-edges -correlated-propagation -coro-cleanup -redundant-dbg-inst-elim -globalsplit -barrier -called-value-propagation -constmerge -hotcoldsplit -simplifycfg -scalarizer -insert-gcov-profiling -globalopt -loop-simplify -float2int -redundant-dbg-inst-elim -dce -slp-vectorizer -jump-threading -post-inline-ee-instrument -sancov -guard-widening -tailcallelim -coro-split -gvn -loop-versioning-licm -strip -licm -mem2reg -loop-unroll -dce -partial-inliner -reassociate -slsr -memcpyopt -instcombine -guard-widening -die -loop-predication -loweratomic -infer-address-spaces -libcalls-shrinkwrap -loop-unroll -redundant-dbg-inst-elim -instcombine -strip-dead-prototypes -instnamer -lower-constant-intrinsics -globaldce -sroa -callsite-splitting -licm -lower-expect -globalsplit -loop-predication -libcalls-shrinkwrap -globaldce -flattencfg -name-anon-globals -inferattrs -loweratomic -lower-matrix-intrinsics -mergefunc -elim-avail-extern -strip-nondebug -sink -loop-unswitch -simplifycfg -die -newgvn input.bc -o output.bc -benchmark://cBench-v1/stringsearch,1.012295081967213,61.989551305770874,opt -slsr -alignment-from-assumptions -ipsccp -canonicalize-aliases -slp-vectorizer -gvn-hoist -rewrite-statepoints-for-gc -lower-expect -constmerge -canonicalize-aliases -ee-instrument -nary-reassociate -licm -flattencfg -loop-unroll-and-jam -load-store-vectorizer -newgvn -loop-reroll -loop-distribute -licm -gvn -lcssa -globalopt -instnamer -mergereturn -loop-simplify -loop-interchange -globaldce -irce -flattencfg -mldst-motion -bdce -instcombine -jump-threading -loop-unswitch -callsite-splitting -licm -load-store-vectorizer -slsr -lower-constant-intrinsics -correlated-propagation -callsite-splitting -instnamer -infer-address-spaces -dse -loop-unswitch -dse -mergereturn -strip -loweratomic -instsimplify -loop-deletion -functionattrs -gvn-hoist -lower-expect -barrier -consthoist -inject-tli-mappings -prune-eh -lcssa -dse -strip-debug-declare -loop-reroll -called-value-propagation -deadargelim -mergereturn -loop-simplify -loop-unswitch -strip-dead-prototypes -coro-elide -attributor -tailcallelim -partially-inline-libcalls -loop-distribute -dce -licm -loop-versioning -inferattrs -loop-predication -loop-deletion -post-inline-ee-instrument -slp-vectorizer -coro-early -add-discriminators -name-anon-globals -strip -adce -consthoist -ipconstprop -loop-predication -lower-matrix-intrinsics -loop-sink -bdce -loop-reroll -simplifycfg -loop-versioning-licm -barrier -irce -dce -loop-load-elim -newgvn -always-inline -always-inline -callsite-splitting -loop-unroll -callsite-splitting -loweratomic -ee-instrument -lower-widenable-condition -break-crit-edges -instnamer -deadargelim -lowerswitch -ipconstprop -mem2reg -loop-load-elim -callsite-splitting -pgo-memop-opt -instcombine -lower-constant-intrinsics -strip -gvn -add-discriminators -loop-versioning -canonicalize-aliases -strip-nondebug -barrier -loop-fusion -inferattrs -mem2reg -lower-matrix-intrinsics -functionattrs -irce -correlated-propagation -deadargelim -sroa -strip-dead-prototypes -loop-predication -flattencfg -cross-dso-cfi -constmerge -strip-debug-declare -dce -reg2mem -lower-matrix-intrinsics -loop-predication -loop-predication -lower-constant-intrinsics -instnamer -attributor -dce -ipconstprop -instnamer -alignment-from-assumptions -strip-dead-prototypes -loop-simplifycfg -elim-avail-extern -argpromotion -early-cse-memssa -dse -loop-instsimplify -reg2mem -lowerswitch -partial-inliner -insert-gcov-profiling -loop-simplify -post-inline-ee-instrument -partial-inliner -float2int -loop-fusion -prune-eh -lcssa -float2int -div-rem-pairs -strip-debug-declare -loop-sink -loop-reduce -strip -alignment-from-assumptions -loop-simplify -canonicalize-aliases -reg2mem -gvn -insert-gcov-profiling -barrier -newgvn -mem2reg -strip-dead-prototypes -loop-simplify -loop-data-prefetch -loop-versioning-licm -simplifycfg -slsr -instcombine input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9850746268656715,61.64527368545532,opt -memcpyopt -sroa -elim-avail-extern -lower-widenable-condition -div-rem-pairs -div-rem-pairs -loop-load-elim -cross-dso-cfi -gvn -loop-versioning -insert-gcov-profiling -early-cse-memssa -instcombine -redundant-dbg-inst-elim -inferattrs -nary-reassociate -coro-cleanup -inferattrs -partial-inliner -loop-fusion -consthoist -adce -name-anon-globals -loop-versioning -aggressive-instcombine -correlated-propagation -loweratomic -early-cse-memssa -loop-unroll -jump-threading -sroa -name-anon-globals -speculative-execution -barrier -constprop -loop-data-prefetch -lower-expect -load-store-vectorizer -coro-split -lower-widenable-condition -early-cse-memssa -speculative-execution -elim-avail-extern -loop-guard-widening -loop-sink -coro-early -globalsplit -forceattrs -slsr -coro-elide -pgo-memop-opt -canonicalize-aliases -deadargelim -instcombine -deadargelim -sancov -guard-widening -elim-avail-extern -always-inline -libcalls-shrinkwrap -coro-cleanup -load-store-vectorizer -redundant-dbg-inst-elim -speculative-execution -prune-eh -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9850746268656717,62.151060581207275,opt -loop-simplifycfg -mem2reg -loop-interchange -tailcallelim -coro-cleanup -sroa -sink -insert-gcov-profiling -adce -die -loop-vectorize -rpo-functionattrs -post-inline-ee-instrument -slsr -loop-versioning -mergeicmps -load-store-vectorizer -loop-sink -loop-unroll -barrier -loweratomic -insert-gcov-profiling -mergereturn -div-rem-pairs -slp-vectorizer -mergefunc -strip-dead-prototypes -loop-sink -bdce -redundant-dbg-inst-elim -flattencfg -mergereturn -infer-address-spaces -flattencfg -newgvn -attributor -instcombine -bdce -mergereturn -loop-load-elim -redundant-dbg-inst-elim -add-discriminators -cross-dso-cfi -strip-debug-declare -inferattrs -mergereturn -loop-simplify -lower-widenable-condition -coro-early -barrier -loop-instsimplify -jump-threading -div-rem-pairs -loop-unroll-and-jam -loop-vectorize -loop-data-prefetch -scalarizer -functionattrs -loop-interchange -inject-tli-mappings -loop-sink -dce -newgvn -constprop -post-inline-ee-instrument -elim-avail-extern -coro-cleanup -correlated-propagation -mem2reg -guard-widening -lower-widenable-condition -globaldce -loop-distribute -instcombine -die -loop-load-elim -slsr -libcalls-shrinkwrap -mergefunc -ee-instrument -prune-eh -ee-instrument -coro-split -rewrite-statepoints-for-gc -tailcallelim -rpo-functionattrs -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9888059701492538,61.676395654678345,opt -loop-vectorize -slp-vectorizer -ee-instrument -float2int -called-value-propagation -loop-reroll -coro-elide -canonicalize-aliases -prune-eh -alignment-from-assumptions -inferattrs -indvars -indvars -globalsplit -partially-inline-libcalls -loop-unroll-and-jam -adce -indvars -inject-tli-mappings -name-anon-globals -globaldce -constprop -mldst-motion -sroa -loop-vectorize -rewrite-statepoints-for-gc -gvn -loop-sink -prune-eh -always-inline -mergereturn -mldst-motion -cross-dso-cfi -ipsccp -coro-elide -sink -separate-const-offset-from-gep -mergefunc -cross-dso-cfi -infer-address-spaces -always-inline -forceattrs -aggressive-instcombine -strip-debug-declare -partially-inline-libcalls -lower-matrix-intrinsics -instsimplify -break-crit-edges -lcssa -early-cse-memssa -loop-unroll -infer-address-spaces -strip-nondebug -jump-threading -alignment-from-assumptions -loop-vectorize -gvn -partially-inline-libcalls -constmerge -flattencfg -globaldce -mergeicmps -constmerge -loop-unroll-and-jam -partially-inline-libcalls -partial-inliner -inject-tli-mappings -globaldce -simplifycfg -mergereturn -inject-tli-mappings -speculative-execution -loop-distribute -rpo-functionattrs -indvars -lowerswitch -coro-elide -callsite-splitting -load-store-vectorizer -aggressive-instcombine -loop-predication -argpromotion -loop-guard-widening -insert-gcov-profiling -argpromotion -argpromotion -dse -partially-inline-libcalls -newgvn -lcssa -mldst-motion -lower-guard-intrinsic -simplifycfg -hotcoldsplit -load-store-vectorizer -dse -consthoist -dce -instcombine input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9888059701492538,64.41505336761475,opt -barrier -nary-reassociate -strip-debug-declare -strip-nondebug -loop-reduce -constmerge -deadargelim -ipsccp -float2int -instsimplify -coro-cleanup -break-crit-edges -speculative-execution -loop-deletion -loop-versioning -coro-split -coro-cleanup -globalsplit -callsite-splitting -strip-dead-prototypes -loop-guard-widening -prune-eh -loop-distribute -sroa -newgvn -always-inline -coro-elide -newgvn -correlated-propagation -dce -scalarizer -partially-inline-libcalls -loop-data-prefetch -strip-debug-declare -called-value-propagation -loop-deletion -loop-guard-widening -sink -lower-widenable-condition -constprop -barrier -reg2mem -instsimplify -reg2mem -loop-interchange -simple-loop-unswitch -ipconstprop -loop-sink -early-cse-memssa -rpo-functionattrs -lower-constant-intrinsics -sink -prune-eh -mergefunc -name-anon-globals -coro-early -loop-deletion -sink -loop-guard-widening -loop-versioning -strip -loop-unswitch -instnamer -lowerinvoke -guard-widening -nary-reassociate -ee-instrument -ipsccp -elim-avail-extern -correlated-propagation -canonicalize-aliases -strip-dead-prototypes -lower-guard-intrinsic -separate-const-offset-from-gep -loop-idiom -lower-constant-intrinsics -dce -globaldce -loop-instsimplify -prune-eh -forceattrs -scalarizer -strip-nondebug -rewrite-statepoints-for-gc -loop-interchange -lower-constant-intrinsics -lower-guard-intrinsic -sancov -partially-inline-libcalls -insert-gcov-profiling -constprop -libcalls-shrinkwrap -loop-guard-widening -inferattrs -loop-unroll-and-jam -memcpyopt -sroa -slp-vectorizer -coro-elide -strip-nondebug -strip-dead-prototypes -loop-versioning -deadargelim -globalopt -lcssa -slp-vectorizer -ee-instrument -loop-unswitch -loop-unroll-and-jam -loop-idiom -sroa -coro-elide -dce -load-store-vectorizer -lower-widenable-condition -redundant-dbg-inst-elim -redundant-dbg-inst-elim -canonicalize-aliases -redundant-dbg-inst-elim -early-cse-memssa -indvars -post-inline-ee-instrument -lower-constant-intrinsics -rpo-functionattrs -loop-predication -sancov -ee-instrument -callsite-splitting -loop-reroll -strip -partial-inliner -irce -strip-debug-declare -mem2reg -instcombine -loop-guard-widening -inferattrs -callsite-splitting -memcpyopt -early-cse-memssa -reassociate -strip-nondebug -functionattrs -reassociate -nary-reassociate -bdce -licm -partially-inline-libcalls -ipconstprop -globaldce -strip -coro-elide -simplifycfg -guard-widening -correlated-propagation input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9888059701492539,61.77658653259277,opt -always-inline -ipconstprop -libcalls-shrinkwrap -newgvn -inferattrs -elim-avail-extern -mem2reg -bdce -reassociate -gvn -strip -attributor -loop-guard-widening -guard-widening -reassociate -loop-idiom -forceattrs -die -aggressive-instcombine -memcpyopt -consthoist -mldst-motion -loop-vectorize -strip -rewrite-statepoints-for-gc -loop-idiom -name-anon-globals -strip -infer-address-spaces -instnamer -argpromotion -strip-nondebug -strip -lower-widenable-condition -ipsccp -callsite-splitting -slsr -memcpyopt -coro-elide -mergeicmps -aggressive-instcombine -indvars -always-inline -strip-debug-declare -functionattrs -insert-gcov-profiling -mem2reg -constmerge -mldst-motion -separate-const-offset-from-gep -memcpyopt -gvn -insert-gcov-profiling -elim-avail-extern -bdce -loop-distribute -sroa -coro-split -div-rem-pairs -slp-vectorizer -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.988805970149254,61.721890687942505,opt -mldst-motion -canonicalize-aliases -irce -infer-address-spaces -functionattrs -scalarizer -attributor -mldst-motion -licm -barrier -coro-split -rpo-functionattrs -nary-reassociate -separate-const-offset-from-gep -coro-elide -consthoist -loop-fusion -coro-elide -sroa -constmerge -inferattrs -instsimplify -coro-early -prune-eh -sink -sccp -instsimplify -lower-matrix-intrinsics -newgvn -coro-early -loop-guard-widening -sccp -barrier -mergereturn -loop-vectorize -tailcallelim -sancov -add-discriminators -loop-predication -coro-elide -instcombine -separate-const-offset-from-gep -indvars -libcalls-shrinkwrap -bdce -name-anon-globals -loop-deletion -lower-guard-intrinsic -tailcallelim -loop-guard-widening -cross-dso-cfi -strip-dead-prototypes -partially-inline-libcalls -simplifycfg -loop-distribute -pgo-memop-opt -globalsplit -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9925373134328358,61.8615505695343,opt -lower-constant-intrinsics -functionattrs -loop-reduce -instnamer -forceattrs -loop-guard-widening -die -strip-nondebug -lowerswitch -constprop -redundant-dbg-inst-elim -sancov -loop-unswitch -callsite-splitting -constmerge -lower-matrix-intrinsics -loop-simplify -lower-expect -mergeicmps -instsimplify -bdce -loop-predication -dse -reg2mem -called-value-propagation -guard-widening -loop-vectorize -speculative-execution -ipconstprop -mergefunc -globalopt -constprop -bdce -ipconstprop -tailcallelim -attributor -nary-reassociate -libcalls-shrinkwrap -loop-versioning-licm -cross-dso-cfi -sroa -speculative-execution -jump-threading -partial-inliner -prune-eh -loop-simplify -functionattrs -sink -loop-vectorize -loop-unswitch -mldst-motion -loop-reroll -consthoist -attributor -barrier -sink -tailcallelim -ipsccp -redundant-dbg-inst-elim -called-value-propagation -deadargelim -loop-idiom -canonicalize-aliases -lowerinvoke -loop-unswitch -adce -loop-data-prefetch -loop-data-prefetch -float2int -alignment-from-assumptions -mergeicmps -globaldce -simple-loop-unswitch -called-value-propagation -constmerge -partial-inliner -sancov -loop-versioning -inferattrs -reassociate -rpo-functionattrs -loop-interchange -globaldce -ipconstprop -instcombine -lower-guard-intrinsic -rpo-functionattrs -ipconstprop -lower-expect -insert-gcov-profiling -strip-debug-declare -functionattrs -loweratomic -strip-dead-prototypes -loop-versioning -lower-constant-intrinsics -mergefunc -gvn-hoist -loop-simplifycfg -instcombine -lower-constant-intrinsics -correlated-propagation -lowerswitch -coro-early -mergeicmps -nary-reassociate -slp-vectorizer -load-store-vectorizer -load-store-vectorizer -early-cse-memssa -mergefunc -coro-cleanup -simple-loop-unswitch -flattencfg -bdce -flattencfg -gvn -separate-const-offset-from-gep -loweratomic -aggressive-instcombine -flattencfg -add-discriminators -mem2reg -strip-nondebug -lower-widenable-condition -loweratomic -instnamer -forceattrs -gvn-hoist -bdce -div-rem-pairs -simplifycfg -callsite-splitting -dse -lower-constant-intrinsics -load-store-vectorizer -coro-early -break-crit-edges -partial-inliner -lower-constant-intrinsics -consthoist -inject-tli-mappings -instcombine -div-rem-pairs -mem2reg -argpromotion -loop-predication -sccp -globaldce -elim-avail-extern -inject-tli-mappings -simplifycfg -globaldce -mergereturn -loweratomic -die -die -loweratomic -memcpyopt -scalarizer -sink -alignment-from-assumptions -irce -indvars -ipconstprop -aggressive-instcombine -jump-threading -aggressive-instcombine -globalsplit -mergefunc -globalsplit -gvn-hoist -loop-versioning-licm -guard-widening -coro-early -newgvn -sroa -constprop -inject-tli-mappings -alignment-from-assumptions -add-discriminators -instnamer -globalopt -speculative-execution -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.9962686567164178,61.62188148498535,opt -load-store-vectorizer -loop-interchange -loop-simplify -constmerge -loop-unroll-and-jam -ipsccp -sroa -dce -loop-sink -constprop -rpo-functionattrs -slp-vectorizer -loop-load-elim -die -barrier -slp-vectorizer -loop-sink -div-rem-pairs -gvn-hoist -dce -loop-distribute -loop-fusion -name-anon-globals -licm -rpo-functionattrs -scalarizer -sink -barrier -sroa -loop-sink -irce -correlated-propagation -strip-debug-declare -mergereturn -canonicalize-aliases -early-cse-memssa -sroa -inferattrs -loop-distribute -instcombine -deadargelim -early-cse-memssa -strip-dead-prototypes -strip-dead-prototypes -sink -irce -always-inline -early-cse-memssa -functionattrs -loop-idiom -slp-vectorizer -lower-guard-intrinsic -indvars -loop-sink -lcssa -dce -add-discriminators -sancov -lowerswitch -mldst-motion -deadargelim -jump-threading -gvn -ee-instrument -loop-deletion -coro-split -correlated-propagation -name-anon-globals -lower-expect -globalopt -attributor -loop-instsimplify -elim-avail-extern -coro-early -loop-interchange -loop-guard-widening -tailcallelim -simplifycfg -strip-nondebug -guard-widening -globalopt -barrier -lower-matrix-intrinsics -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.996268656716418,61.765552043914795,opt -cross-dso-cfi -loop-interchange -elim-avail-extern -insert-gcov-profiling -partially-inline-libcalls -mldst-motion -slp-vectorizer -loop-idiom -deadargelim -lower-constant-intrinsics -speculative-execution -sccp -coro-early -correlated-propagation -adce -loop-unroll-and-jam -nary-reassociate -insert-gcov-profiling -separate-const-offset-from-gep -newgvn -correlated-propagation -loop-simplifycfg -strip-nondebug -dse -attributor -gvn -functionattrs -called-value-propagation -newgvn -ee-instrument -instcombine -div-rem-pairs -pgo-memop-opt -partially-inline-libcalls -mergereturn -dce -newgvn -gvn-hoist -mergereturn -loop-simplify -insert-gcov-profiling -inferattrs -loop-deletion -strip-debug-declare -indvars -globalopt -simple-loop-unswitch -newgvn -loop-interchange -add-discriminators -irce -newgvn -nary-reassociate -ipsccp -canonicalize-aliases -mem2reg -correlated-propagation -break-crit-edges -partially-inline-libcalls -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,0.996268656716418,61.78978753089905,opt -simplifycfg -newgvn -mem2reg -indvars -mergeicmps -inferattrs -aggressive-instcombine -rpo-functionattrs -constprop -loop-versioning -slp-vectorizer -inject-tli-mappings -loop-simplifycfg -insert-gcov-profiling -rpo-functionattrs -indvars -coro-elide -tailcallelim -attributor -coro-cleanup -instcombine -ipconstprop -div-rem-pairs -lower-expect -strip-dead-prototypes -insert-gcov-profiling -coro-early -rpo-functionattrs -argpromotion -loop-versioning-licm -constprop -reassociate -loop-simplifycfg -mergereturn -partial-inliner -partially-inline-libcalls -ipconstprop -float2int -instsimplify -partially-inline-libcalls -slp-vectorizer -redundant-dbg-inst-elim -mem2reg -gvn -sink -loweratomic -coro-split -loop-interchange -gvn -elim-avail-extern -gvn -dce -mergeicmps -rewrite-statepoints-for-gc -aggressive-instcombine -lower-matrix-intrinsics -scalarizer -memcpyopt -loop-unswitch -tailcallelim -loop-vectorize -inject-tli-mappings -libcalls-shrinkwrap -loop-deletion -inject-tli-mappings -instcombine -mldst-motion -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/susan,1.0008958280010236,63.07995295524597,opt -loop-sink -mem2reg -nary-reassociate -indvars -loop-load-elim -loop-simplify -insert-gcov-profiling -loop-simplifycfg -irce -loop-deletion -div-rem-pairs -loop-unroll-and-jam -add-discriminators -rewrite-statepoints-for-gc -simplifycfg -coro-early -lower-expect -loop-interchange -partial-inliner -gvn -loop-data-prefetch -functionattrs -simple-loop-unswitch -guard-widening -mergeicmps -gvn -dse -mldst-motion -lower-guard-intrinsic -loop-simplify -lower-constant-intrinsics -loop-fusion -newgvn -rpo-functionattrs -simplifycfg -inferattrs -partially-inline-libcalls -separate-const-offset-from-gep -loop-load-elim -separate-const-offset-from-gep -loop-guard-widening -loop-predication -instcombine -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/susan,1.0012797542871767,66.32646870613098,opt -instcombine -sroa -partial-inliner -licm -early-cse-memssa -lower-constant-intrinsics -load-store-vectorizer -loop-vectorize -loop-guard-widening -flattencfg -guard-widening -partial-inliner -dse -gvn-hoist -sink -lower-widenable-condition -strip-nondebug -loop-versioning -forceattrs -loop-idiom -loop-versioning-licm -licm -libcalls-shrinkwrap -memcpyopt -loop-simplify -sroa -die -irce -simplifycfg -simple-loop-unswitch -strip-dead-prototypes -instcombine -functionattrs -speculative-execution -mergefunc -jump-threading -consthoist -tailcallelim -alignment-from-assumptions -lcssa -sccp -lower-guard-intrinsic -mldst-motion -loop-unroll-and-jam -jump-threading -partial-inliner -pgo-memop-opt -slsr -simple-loop-unswitch -sroa -loop-simplify -mergereturn -sroa -loop-deletion -coro-cleanup -sancov -jump-threading -mem2reg -slsr -add-discriminators -early-cse-memssa -infer-address-spaces -loop-guard-widening -mergereturn -partially-inline-libcalls -mldst-motion -dce -flattencfg -sroa -newgvn -lower-constant-intrinsics -loop-sink -loop-vectorize -loweratomic -libcalls-shrinkwrap -jump-threading -guard-widening -nary-reassociate -constprop -instnamer -correlated-propagation -loop-versioning-licm -coro-early -simple-loop-unswitch -libcalls-shrinkwrap -loop-versioning-licm -licm -div-rem-pairs -coro-cleanup -coro-split -instsimplify -always-inline -mergefunc -globaldce -rpo-functionattrs -elim-avail-extern -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/susan,1.0051190171487074,63.4972939491272,opt -simplifycfg -ipconstprop -sroa -mem2reg -nary-reassociate -loop-data-prefetch -globalopt -loop-instsimplify -flattencfg -canonicalize-aliases -gvn -pgo-memop-opt -memcpyopt -inferattrs -flattencfg -redundant-dbg-inst-elim -coro-early -deadargelim -loop-unroll -rpo-functionattrs -mergeicmps -dce -post-inline-ee-instrument -strip-dead-prototypes -inject-tli-mappings -loop-instsimplify -lowerswitch -lcssa -alignment-from-assumptions -callsite-splitting -simplifycfg -memcpyopt -reassociate -jump-threading -sroa -strip-debug-declare -guard-widening -lower-guard-intrinsic -loop-idiom -coro-early -strip -sroa -globalopt -mergereturn -libcalls-shrinkwrap -nary-reassociate -separate-const-offset-from-gep -partial-inliner -attributor -slsr -slsr -newgvn -loop-reroll -licm -forceattrs -ipsccp -ipconstprop -loop-reroll -lowerinvoke -instcombine -post-inline-ee-instrument -newgvn -loop-load-elim -rewrite-statepoints-for-gc -redundant-dbg-inst-elim -barrier -strip-nondebug -rpo-functionattrs -loop-simplify -loop-data-prefetch -scalarizer -cross-dso-cfi -libcalls-shrinkwrap -memcpyopt -loop-deletion -nary-reassociate -mergefunc -loop-idiom -instnamer -correlated-propagation -loop-fusion -alignment-from-assumptions -correlated-propagation -cross-dso-cfi -strip-debug-declare -rpo-functionattrs -functionattrs -sancov -called-value-propagation -canonicalize-aliases -indvars -insert-gcov-profiling -separate-const-offset-from-gep -loop-data-prefetch -indvars -gvn-hoist -sancov -guard-widening -add-discriminators -insert-gcov-profiling -nary-reassociate -loop-unroll-and-jam -dce -correlated-propagation -loop-instsimplify -partially-inline-libcalls -mem2reg -loop-interchange -elim-avail-extern -slp-vectorizer -loop-reroll -argpromotion -elim-avail-extern -partial-inliner -instcombine -constmerge -instcombine -canonicalize-aliases -sccp -redundant-dbg-inst-elim -sink -guard-widening -simplifycfg -redundant-dbg-inst-elim -canonicalize-aliases -speculative-execution -alignment-from-assumptions -sroa -inferattrs -add-discriminators -partially-inline-libcalls -speculative-execution -gvn-hoist -div-rem-pairs -loop-versioning -mergefunc -slp-vectorizer -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/susan,1.0051190171487077,63.2826771736145,opt -sancov -libcalls-shrinkwrap -loweratomic -sroa -guard-widening -insert-gcov-profiling -loop-instsimplify -guard-widening -mergereturn -rewrite-statepoints-for-gc -redundant-dbg-inst-elim -nary-reassociate -always-inline -coro-split -cross-dso-cfi -functionattrs -gvn -loop-reroll -mergefunc -mergeicmps -instsimplify -memcpyopt -loop-interchange -loop-predication -alignment-from-assumptions -loop-vectorize -loop-simplify -mem2reg -libcalls-shrinkwrap -strip-debug-declare -mldst-motion -attributor -loop-sink -loop-fusion -called-value-propagation -mldst-motion -mergeicmps -strip-dead-prototypes -loop-deletion -coro-early -gvn -canonicalize-aliases -sink -barrier -inferattrs -loop-deletion -load-store-vectorizer -loop-deletion -nary-reassociate -reassociate -loop-versioning -ee-instrument -attributor -prune-eh -lower-widenable-condition -called-value-propagation -post-inline-ee-instrument -dce -lowerinvoke -slp-vectorizer -elim-avail-extern -load-store-vectorizer -strip -ee-instrument -canonicalize-aliases -strip-dead-prototypes -loop-load-elim -early-cse-memssa -sccp -argpromotion -infer-address-spaces -loop-data-prefetch -dce -loop-load-elim -constmerge -called-value-propagation -loop-vectorize -flattencfg -instnamer -loop-unroll -loweratomic -gvn-hoist -prune-eh -memcpyopt -mldst-motion -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v1/susan,1.005758894292296,310.464004278183,opt -tailcallelim -break-crit-edges -strip-dead-prototypes -die -loop-vectorize -slp-vectorizer -prune-eh -speculative-execution -newgvn -hotcoldsplit -called-value-propagation -lcssa -strip-dead-prototypes -tailcallelim -dce -redundant-dbg-inst-elim -sroa -jump-threading -loop-versioning-licm -loop-deletion -infer-address-spaces -elim-avail-extern -functionattrs -alignment-from-assumptions -infer-address-spaces -slp-vectorizer -mergefunc -sancov -scalarizer -separate-const-offset-from-gep -functionattrs -sancov -reassociate -loop-unroll -constprop -mergeicmps -globalopt -rewrite-statepoints-for-gc -float2int -barrier -partial-inliner -mldst-motion -deadargelim -memcpyopt -loop-guard-widening -mergefunc -irce -loop-versioning -deadargelim -inferattrs -loop-interchange -loop-simplify -loop-predication -lcssa -functionattrs -coro-elide -load-store-vectorizer -strip-debug-declare -always-inline -insert-gcov-profiling -newgvn -add-discriminators -consthoist -licm -consthoist -prune-eh -elim-avail-extern -indvars -prune-eh -reassociate -functionattrs -rewrite-statepoints-for-gc -simplifycfg -libcalls-shrinkwrap -lower-widenable-condition -newgvn -lower-guard-intrinsic -lower-constant-intrinsics -elim-avail-extern -flattencfg -irce -hotcoldsplit -strip -insert-gcov-profiling -sroa -reassociate -instcombine -sink -lower-matrix-intrinsics -insert-gcov-profiling -sccp -libcalls-shrinkwrap -licm -name-anon-globals -correlated-propagation -lower-matrix-intrinsics -loop-load-elim -coro-elide -adce -loweratomic -cross-dso-cfi -mem2reg -insert-gcov-profiling -lower-constant-intrinsics -strip-debug-declare -strip-nondebug -instnamer -lower-widenable-condition -lower-guard-intrinsic -mergefunc -canonicalize-aliases -dse -loop-simplifycfg -loop-unroll-and-jam -alignment-from-assumptions -libcalls-shrinkwrap -loop-data-prefetch -globalsplit -newgvn input.bc -o output.bc -benchmark://cBench-v1/susan,1.0112618377271563,66.1175889968872,opt -callsite-splitting -deadargelim -simple-loop-unswitch -tailcallelim -simple-loop-unswitch -adce -globalopt -aggressive-instcombine -sroa -inject-tli-mappings -add-discriminators -dce -elim-avail-extern -float2int -strip-dead-prototypes -loop-load-elim -mergereturn -lower-guard-intrinsic -loop-vectorize -libcalls-shrinkwrap -instcombine -licm -correlated-propagation -indvars -strip-debug-declare -strip-debug-declare -instsimplify -infer-address-spaces -float2int -always-inline -flattencfg -dce -newgvn -partial-inliner -jump-threading -lower-matrix-intrinsics -rpo-functionattrs -speculative-execution -loop-sink -globalsplit -lowerinvoke -gvn-hoist -elim-avail-extern -name-anon-globals -lower-guard-intrinsic -lowerinvoke -early-cse-memssa -always-inline -lower-guard-intrinsic -mergeicmps -loop-instsimplify -consthoist -jump-threading -argpromotion -newgvn -loop-distribute -loop-guard-widening -prune-eh -separate-const-offset-from-gep -sancov -inferattrs -lowerinvoke -early-cse-memssa -loweratomic -loop-load-elim -lower-guard-intrinsic -loop-unroll -loop-instsimplify -loop-versioning -div-rem-pairs -ipsccp -strip-debug-declare -prune-eh -mldst-motion -licm -bdce -loop-simplify -loweratomic -add-discriminators -lower-widenable-condition -loop-versioning -simplifycfg -functionattrs -loop-versioning-licm -loop-distribute -mem2reg -adce -strip -float2int -break-crit-edges -loop-data-prefetch -memcpyopt -ee-instrument -sccp -post-inline-ee-instrument -attributor -libcalls-shrinkwrap -cross-dso-cfi -loop-idiom -loop-guard-widening -die -attributor -coro-split -gvn -break-crit-edges -float2int -loop-versioning-licm -always-inline -coro-split -break-crit-edges -argpromotion -attributor -simplifycfg -constmerge -newgvn -instcombine -lowerswitch -canonicalize-aliases -float2int -pgo-memop-opt -infer-address-spaces -die -strip -nary-reassociate -reassociate -forceattrs -partial-inliner -add-discriminators -lowerinvoke -mem2reg -lower-constant-intrinsics -libcalls-shrinkwrap -loop-unroll -loop-deletion -callsite-splitting -loop-simplify -flattencfg -mldst-motion -adce -mergereturn -lowerinvoke -canonicalize-aliases -simplifycfg -strip-nondebug -constprop -coro-early -bdce -reassociate -newgvn -attributor -loop-data-prefetch -slsr -instcombine -lower-matrix-intrinsics -slsr -coro-cleanup -always-inline -loop-guard-widening -lower-matrix-intrinsics -sroa -div-rem-pairs -partially-inline-libcalls -indvars -forceattrs -ipsccp -loweratomic -nary-reassociate input.bc -o output.bc -benchmark://cBench-v1/susan,1.013437420015357,141.09184956550598,opt -sancov -loop-idiom -flattencfg -partially-inline-libcalls -guard-widening -loop-instsimplify -partial-inliner -ipconstprop -sink -strip -partial-inliner -early-cse-memssa -mergereturn -loop-distribute -inferattrs -loop-versioning -jump-threading -globaldce -inferattrs -loop-simplifycfg -licm -mergereturn -slp-vectorizer -strip -post-inline-ee-instrument -coro-early -adce -strip-debug-declare -sccp -correlated-propagation -canonicalize-aliases -rpo-functionattrs -rewrite-statepoints-for-gc -functionattrs -float2int -sroa -reg2mem -loop-sink -loop-unroll-and-jam -pgo-memop-opt -partial-inliner -constprop -loop-deletion -alignment-from-assumptions -strip -loop-sink -called-value-propagation -callsite-splitting -argpromotion -loop-versioning -instcombine -instcombine -instsimplify -coro-split -partial-inliner -consthoist -globalsplit -inject-tli-mappings -loop-unroll -lower-constant-intrinsics -break-crit-edges -rewrite-statepoints-for-gc -loop-versioning-licm -bdce -globalsplit -slp-vectorizer -newgvn -loop-guard-widening -simplifycfg -argpromotion -loop-simplifycfg -gvn -jump-threading -newgvn -inferattrs -loop-idiom -canonicalize-aliases -bdce -forceattrs -bdce -instnamer -reassociate -sroa -instsimplify -lower-constant-intrinsics -lower-widenable-condition -globalsplit -loop-simplify -gvn -instnamer -tailcallelim -instcombine -called-value-propagation -lower-expect -loop-predication -libcalls-shrinkwrap -licm -tailcallelim -dce -break-crit-edges -loop-idiom -tailcallelim -libcalls-shrinkwrap -coro-cleanup -separate-const-offset-from-gep -irce -loop-simplifycfg -lowerinvoke -slp-vectorizer -add-discriminators -cross-dso-cfi -alignment-from-assumptions -loop-idiom -coro-cleanup -guard-widening -globalopt -speculative-execution -loop-instsimplify -loop-simplify -reg2mem -lowerinvoke -loop-vectorize -instcombine -simple-loop-unswitch -elim-avail-extern -inject-tli-mappings -elim-avail-extern -sroa -newgvn input.bc -o output.bc -benchmark://cBench-v1/susan,1.0167647811620169,63.417919397354126,opt -mergefunc -flattencfg -aggressive-instcombine -always-inline -jump-threading -loop-unroll-and-jam -lower-guard-intrinsic -mem2reg -globalsplit -always-inline -strip-debug-declare -mergereturn -instnamer -always-inline -jump-threading -mergeicmps -scalarizer -coro-early -post-inline-ee-instrument -argpromotion -loop-deletion -strip -loop-versioning -mergereturn -constmerge -mergeicmps -loop-unroll -speculative-execution -infer-address-spaces -coro-early -forceattrs -loop-load-elim -lower-expect -scalarizer -libcalls-shrinkwrap -instnamer -post-inline-ee-instrument -loop-guard-widening -loop-instsimplify -loop-unroll-and-jam -ipconstprop -die -globalsplit -slsr -prune-eh -coro-split -gvn -lcssa -called-value-propagation -loop-interchange -barrier -inline -inferattrs -adce -insert-gcov-profiling -always-inline -globalopt -inferattrs -mergefunc -loop-reroll -barrier -functionattrs -callsite-splitting -simple-loop-unswitch -insert-gcov-profiling -hotcoldsplit -instnamer -constmerge -slsr -lower-widenable-condition -loop-instsimplify -callsite-splitting -loop-unroll -die -scalarizer -globaldce -loop-simplify -always-inline -called-value-propagation -rpo-functionattrs -div-rem-pairs -infer-address-spaces -name-anon-globals -div-rem-pairs -loop-load-elim -loop-interchange -forceattrs -functionattrs -post-inline-ee-instrument -deadargelim -load-store-vectorizer -constmerge -inferattrs -loop-distribute -canonicalize-aliases -loop-predication -lowerinvoke -elim-avail-extern -slsr -lower-constant-intrinsics -jump-threading -loop-deletion -instcombine -slsr -loop-reroll -newgvn -loop-versioning-licm -sink -loop-unswitch -sccp -simplifycfg -loweratomic -add-discriminators -reg2mem -instsimplify -coro-cleanup -bdce -loop-sink -simplifycfg -loop-vectorize -gvn -loop-deletion -strip -aggressive-instcombine -loop-sink -speculative-execution -name-anon-globals -loop-unswitch -loop-instsimplify -separate-const-offset-from-gep -lower-matrix-intrinsics -loop-instsimplify -constmerge -instcombine -redundant-dbg-inst-elim -tailcallelim -lower-guard-intrinsic -newgvn -coro-cleanup -coro-elide -loop-fusion -lower-widenable-condition -simplifycfg -loop-simplify -cross-dso-cfi -inject-tli-mappings -strip-debug-declare -bdce -loop-predication -lowerinvoke -load-store-vectorizer -partially-inline-libcalls -speculative-execution -forceattrs -loop-idiom -inject-tli-mappings -guard-widening -loop-predication -partially-inline-libcalls -lower-matrix-intrinsics -loop-unroll -memcpyopt -loweratomic -ipsccp -hotcoldsplit -dce -lower-widenable-condition -lower-matrix-intrinsics -guard-widening -infer-address-spaces -callsite-splitting -lower-matrix-intrinsics -div-rem-pairs -indvars -loop-distribute -loop-idiom -reassociate -lower-constant-intrinsics -loop-instsimplify -instcombine input.bc -o output.bc -benchmark://cBench-v1/susan,1.023931405170207,63.62526869773865,opt -rewrite-statepoints-for-gc -dce -reassociate -infer-address-spaces -loop-unswitch -called-value-propagation -strip-debug-declare -lower-matrix-intrinsics -constprop -strip-dead-prototypes -mldst-motion -mergereturn -functionattrs -loop-unroll-and-jam -globaldce -insert-gcov-profiling -partial-inliner -inject-tli-mappings -loop-reduce -ee-instrument -partial-inliner -loop-data-prefetch -redundant-dbg-inst-elim -loweratomic -loop-versioning-licm -loweratomic -separate-const-offset-from-gep -mergefunc -strip-debug-declare -mergeicmps -slp-vectorizer -indvars -loop-sink -alignment-from-assumptions -rpo-functionattrs -callsite-splitting -post-inline-ee-instrument -loop-distribute -always-inline -mem2reg -redundant-dbg-inst-elim -loop-versioning -loop-fusion -redundant-dbg-inst-elim -coro-early -gvn -loop-versioning-licm -loop-distribute -coro-early -loop-data-prefetch -instnamer -forceattrs -callsite-splitting -loop-guard-widening -load-store-vectorizer -sccp -libcalls-shrinkwrap -loop-unswitch -lower-expect -slsr -float2int -add-discriminators -slp-vectorizer -coro-split -functionattrs -name-anon-globals -separate-const-offset-from-gep -inferattrs -insert-gcov-profiling -prune-eh -lower-guard-intrinsic -inject-tli-mappings -redundant-dbg-inst-elim -newgvn -slsr -name-anon-globals -instsimplify -loop-guard-widening -loop-simplify -lowerswitch -constprop -consthoist -reg2mem -libcalls-shrinkwrap -sccp -inferattrs -simplifycfg -loop-predication -memcpyopt -flattencfg -loop-predication -adce -speculative-execution -consthoist -reg2mem -instsimplify -ipsccp -loop-simplify -div-rem-pairs -globalsplit -flattencfg -nary-reassociate -loop-data-prefetch -loop-fusion -guard-widening -loop-guard-widening -simplifycfg -simple-loop-unswitch -strip-dead-prototypes -gvn-hoist -coro-cleanup -loop-simplify -loop-load-elim -name-anon-globals -argpromotion -deadargelim -rewrite-statepoints-for-gc -correlated-propagation -ipsccp -instcombine -loop-data-prefetch -gvn -newgvn -strip-dead-prototypes -reassociate -simplifycfg -guard-widening -ee-instrument -globaldce -rpo-functionattrs -flattencfg -instcombine input.bc -o output.bc -benchmark://cBench-v1/susan,1.0476068594829784,63.81288194656372,opt -adce -coro-split -mergereturn -loop-idiom -always-inline -strip-debug-declare -memcpyopt -guard-widening -barrier -cross-dso-cfi -loop-instsimplify -loop-versioning -hotcoldsplit -die -loop-simplifycfg -loop-fusion -loop-instsimplify -flattencfg -functionattrs -die -instsimplify -alignment-from-assumptions -loop-unswitch -irce -alignment-from-assumptions -load-store-vectorizer -scalarizer -loop-fusion -flattencfg -argpromotion -partially-inline-libcalls -pgo-memop-opt -consthoist -constmerge -dce -lower-expect -coro-split -callsite-splitting -ipconstprop -inject-tli-mappings -mem2reg -adce -guard-widening -elim-avail-extern -aggressive-instcombine -elim-avail-extern -pgo-memop-opt -loop-sink -adce -canonicalize-aliases -sancov -instsimplify -sroa -sccp -loop-sink -loop-distribute -strip-debug-declare -loop-reroll -dse -always-inline -sccp -strip-dead-prototypes -slp-vectorizer -argpromotion -instsimplify -redundant-dbg-inst-elim -mldst-motion -strip -loop-fusion -aggressive-instcombine -globaldce -sroa -simple-loop-unswitch -loop-simplify -lower-expect -constprop -infer-address-spaces -nary-reassociate -memcpyopt -scalarizer -jump-threading -sccp -coro-elide -early-cse-memssa -strip-debug-declare -bdce -globalopt -attributor -separate-const-offset-from-gep -globaldce -ipconstprop -lower-widenable-condition -loop-instsimplify -callsite-splitting -consthoist -add-discriminators -globalopt -guard-widening -slsr -jump-threading -loop-instsimplify -rewrite-statepoints-for-gc -early-cse-memssa -indvars -gvn-hoist -instcombine -instsimplify -inferattrs -separate-const-offset-from-gep -dse -redundant-dbg-inst-elim -globalsplit -slp-vectorizer -loop-versioning -ipsccp -partially-inline-libcalls -simple-loop-unswitch -load-store-vectorizer -reg2mem -speculative-execution -functionattrs -gvn -newgvn -globaldce -instcombine -partial-inliner -callsite-splitting -ee-instrument -loop-rotate -name-anon-globals -constprop -name-anon-globals -canonicalize-aliases -guard-widening -strip-debug-declare -scalarizer -simple-loop-unswitch -strip-nondebug -strip-nondebug -libcalls-shrinkwrap -loop-interchange -barrier -prune-eh -break-crit-edges -loop-rotate -forceattrs -loop-sink -lower-constant-intrinsics -gvn -attributor -slsr -loop-data-prefetch -loweratomic -rpo-functionattrs -globaldce -div-rem-pairs -mldst-motion -gvn -sink -callsite-splitting -reassociate -globalsplit -instcombine -partial-inliner -coro-cleanup -cross-dso-cfi -sroa -guard-widening -deadargelim -jump-threading -dse -loop-reroll -div-rem-pairs -lower-constant-intrinsics -always-inline -loop-vectorize -nary-reassociate -loop-versioning-licm -libcalls-shrinkwrap -barrier -scalarizer -mergereturn -reassociate -adce -gvn -loop-predication -forceattrs -mergereturn -strip-dead-prototypes -post-inline-ee-instrument -ipsccp -loop-idiom -rpo-functionattrs -deadargelim -indvars -ipsccp -speculative-execution -mldst-motion -globaldce -libcalls-shrinkwrap -consthoist -simple-loop-unswitch -infer-address-spaces -loop-sink -gvn -loop-interchange -dce -instcombine input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.014864429241735,74.9220666885376,opt -loop-sink -strip -loop-interchange -canonicalize-aliases -instsimplify -licm -correlated-propagation -speculative-execution -loop-load-elim -nary-reassociate -guard-widening -ipconstprop -coro-split -loop-deletion -inferattrs -correlated-propagation -licm -newgvn -strip-nondebug -globalsplit -inject-tli-mappings -elim-avail-extern -barrier -licm -instsimplify -lower-widenable-condition -loweratomic -prune-eh -coro-early -lower-matrix-intrinsics -lower-guard-intrinsic -coro-elide -ipconstprop -gvn-hoist -loop-fusion -die -strip -loop-instsimplify -coro-cleanup -canonicalize-aliases -loop-data-prefetch -loop-versioning -name-anon-globals -sroa -globaldce -lowerinvoke -indvars -loop-distribute -gvn-hoist -sancov -gvn-hoist -scalarizer -sroa -sccp -adce -flattencfg -indvars -separate-const-offset-from-gep -instcombine -coro-early -instnamer -div-rem-pairs -coro-cleanup -loop-unroll -reassociate -simple-loop-unswitch -float2int -redundant-dbg-inst-elim -mergereturn -partially-inline-libcalls -pgo-memop-opt -dce -correlated-propagation -early-cse-memssa -gvn-hoist -loop-unroll -add-discriminators -pgo-memop-opt -forceattrs -gvn-hoist -lower-widenable-condition -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.0191625774562125,74.73441576957703,opt -instsimplify -elim-avail-extern -flattencfg -indvars -strip-debug-declare -loop-rotate -loop-instsimplify -reg2mem -partially-inline-libcalls -cross-dso-cfi -instsimplify -simple-loop-unswitch -alignment-from-assumptions -lower-matrix-intrinsics -coro-elide -simple-loop-unswitch -loop-guard-widening -loop-unroll-and-jam -functionattrs -globalsplit -hotcoldsplit -scalarizer -loop-versioning-licm -float2int -infer-address-spaces -post-inline-ee-instrument -strip -argpromotion -die -loop-simplifycfg -redundant-dbg-inst-elim -jump-threading -tailcallelim -mergeicmps -globalsplit -globalopt -lower-widenable-condition -infer-address-spaces -sink -rpo-functionattrs -break-crit-edges -rpo-functionattrs -simple-loop-unswitch -ipconstprop -sroa -loop-instsimplify -inject-tli-mappings -loop-versioning-licm -mergefunc -licm -instcombine -newgvn -loop-simplify -simplifycfg -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.0203445682151937,75.50654411315918,opt -argpromotion -lcssa -newgvn -lower-matrix-intrinsics -rewrite-statepoints-for-gc -alignment-from-assumptions -loop-reroll -lower-guard-intrinsic -lower-guard-intrinsic -functionattrs -strip-dead-prototypes -inject-tli-mappings -consthoist -correlated-propagation -bdce -pgo-memop-opt -jump-threading -loop-sink -mldst-motion -loop-vectorize -callsite-splitting -partially-inline-libcalls -div-rem-pairs -flattencfg -loop-simplify -ee-instrument -sink -libcalls-shrinkwrap -mem2reg -speculative-execution -constprop -loop-fusion -prune-eh -constmerge -loop-simplifycfg -sink -strip-dead-prototypes -constprop -sink -instnamer -barrier -callsite-splitting -loop-load-elim -loop-reroll -insert-gcov-profiling -loweratomic -irce -instcombine -infer-address-spaces -irce -bdce -jump-threading -newgvn -elim-avail-extern -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.0219921916974106,139.76473093032837,opt -lcssa -reg2mem -loop-reroll -globalopt -coro-cleanup -adce -inferattrs -coro-cleanup -always-inline -loop-unroll -loweratomic -slsr -correlated-propagation -coro-elide -loop-fusion -insert-gcov-profiling -name-anon-globals -loop-data-prefetch -ee-instrument -forceattrs -coro-split -rewrite-statepoints-for-gc -partial-inliner -strip-nondebug -cross-dso-cfi -reassociate -elim-avail-extern -inferattrs -loop-deletion -deadargelim -instsimplify -lower-widenable-condition -slsr -loop-unroll-and-jam -memcpyopt -strip -adce -jump-threading -lower-widenable-condition -callsite-splitting -rpo-functionattrs -mem2reg -callsite-splitting -guard-widening -slsr -instnamer -jump-threading -hotcoldsplit -coro-cleanup -strip -separate-const-offset-from-gep -rpo-functionattrs -constprop -always-inline -name-anon-globals -instsimplify -irce -inject-tli-mappings -ipconstprop -loop-vectorize -gvn -mergereturn -div-rem-pairs -loop-vectorize -loop-idiom -loop-vectorize -ee-instrument -simple-loop-unswitch -strip-nondebug -lcssa -simplifycfg -loweratomic -rewrite-statepoints-for-gc -rpo-functionattrs -instnamer -lower-widenable-condition -mergereturn -slsr -instcombine input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.022171281206347,73.88120555877686,opt -inferattrs -prune-eh -sroa -ipconstprop -redundant-dbg-inst-elim -post-inline-ee-instrument -mergereturn -licm -simplifycfg -correlated-propagation -mergereturn -always-inline -inferattrs -instnamer -newgvn -sroa -die -coro-split -alignment-from-assumptions -infer-address-spaces -tailcallelim -coro-elide -strip -mldst-motion -callsite-splitting -newgvn -constprop -rpo-functionattrs -loop-instsimplify -inferattrs -reassociate -loop-reroll -indvars -constprop -barrier -always-inline -redundant-dbg-inst-elim -coro-elide -instcombine -slp-vectorizer input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.0225652781260075,74.9262228012085,opt -alignment-from-assumptions -pgo-memop-opt -loop-deletion -loop-fusion -constmerge -tailcallelim -nary-reassociate -loop-instsimplify -prune-eh -loop-predication -die -break-crit-edges -sancov -instnamer -loop-simplifycfg -lower-constant-intrinsics -strip-nondebug -lcssa -lower-expect -sancov -dce -loop-instsimplify -sroa -indvars -early-cse-memssa -barrier -loop-guard-widening -mem2reg -mergefunc -hotcoldsplit -slp-vectorizer -rpo-functionattrs -die -newgvn -loop-unroll-and-jam -called-value-propagation -mergereturn -mergereturn -instsimplify -tailcallelim -instcombine -loop-idiom -strip -lower-guard-intrinsic -memcpyopt -hotcoldsplit -ipconstprop -strip -lcssa -forceattrs -simplifycfg -lower-constant-intrinsics -loop-vectorize -inject-tli-mappings -strip-debug-declare -loop-vectorize -coro-early -loop-data-prefetch -simple-loop-unswitch -lcssa -simplifycfg -coro-cleanup -sink -simplifycfg -reassociate -lower-widenable-condition -slsr -loop-deletion -instcombine -name-anon-globals -loop-unroll -consthoist -adce -newgvn input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.024033812099287,77.53979635238647,opt -lowerinvoke -float2int -mem2reg -lower-guard-intrinsic -break-crit-edges -sroa -partial-inliner -instcombine -loop-guard-widening -div-rem-pairs -inject-tli-mappings -rpo-functionattrs -coro-split -loop-load-elim -sroa -prune-eh -loop-deletion -coro-elide -loop-simplify -correlated-propagation -inferattrs -div-rem-pairs -jump-threading -instsimplify -adce -instsimplify -slp-vectorizer -dse -globalsplit -guard-widening -add-discriminators -jump-threading -lower-widenable-condition -attributor -ipconstprop -coro-split -loop-simplify -prune-eh -reg2mem -loop-unroll-and-jam -alignment-from-assumptions -argpromotion -lowerinvoke -called-value-propagation -early-cse-memssa -called-value-propagation -sroa -prune-eh -pgo-memop-opt -dse -sroa -attributor -loop-predication -sink -bdce -mergefunc -instsimplify -mergeicmps -loop-simplifycfg -name-anon-globals -loop-unroll-and-jam -indvars -barrier -die -licm -float2int -loop-load-elim -inferattrs -canonicalize-aliases -alignment-from-assumptions -coro-split -reassociate -constmerge -cross-dso-cfi -ee-instrument -lower-expect -strip-nondebug -libcalls-shrinkwrap -loop-guard-widening -nary-reassociate -dce -always-inline -load-store-vectorizer -instcombine -loop-guard-widening -hotcoldsplit -name-anon-globals -die -ipsccp -prune-eh -barrier -instnamer -gvn -coro-elide -loop-instsimplify -name-anon-globals -loop-load-elim -coro-split -loop-guard-widening -instsimplify -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.0244994448225224,74.15848064422607,opt -sroa -loop-versioning -strip-debug-declare -hotcoldsplit -name-anon-globals -slsr -name-anon-globals -instsimplify -loop-unswitch -rpo-functionattrs -deadargelim -rewrite-statepoints-for-gc -indvars -loop-guard-widening -early-cse-memssa -inject-tli-mappings -simplifycfg -loop-guard-widening -loop-interchange -ipconstprop -indvars -coro-cleanup -correlated-propagation -mem2reg -coro-early -loop-data-prefetch -sink -coro-cleanup -argpromotion -inferattrs -lower-widenable-condition -functionattrs -flattencfg -newgvn -ipsccp -mergereturn -barrier -constprop -newgvn -cross-dso-cfi -gvn-hoist -globalopt -nary-reassociate -forceattrs -insert-gcov-profiling -instcombine -globaldce -bdce -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.0286901393316379,74.36752319335938,opt -break-crit-edges -instsimplify -instsimplify -mldst-motion -ee-instrument -simplifycfg -hotcoldsplit -rpo-functionattrs -strip-nondebug -early-cse-memssa -mem2reg -gvn-hoist -dce -instcombine -loop-unroll -ipconstprop -load-store-vectorizer -callsite-splitting -nary-reassociate -float2int -mem2reg -instsimplify -memcpyopt -ipconstprop -loop-idiom -instsimplify -newgvn -loop-simplifycfg -lower-widenable-condition -reassociate -sroa -functionattrs -guard-widening -sroa -globalsplit -loop-distribute -loop-simplifycfg -dse -reassociate -instcombine -attributor -canonicalize-aliases -loop-fusion -instnamer -ipsccp -always-inline -lcssa -rewrite-statepoints-for-gc -slsr -mergefunc -loweratomic -simplifycfg -lower-matrix-intrinsics -add-discriminators -loop-unroll -redundant-dbg-inst-elim -argpromotion -loop-deletion -guard-widening -simple-loop-unswitch -gvn-hoist -loop-unroll-and-jam -loop-idiom -flattencfg -dse -loop-reroll -slp-vectorizer -hotcoldsplit -instsimplify -loop-vectorize -speculative-execution -load-store-vectorizer -loop-idiom -loop-distribute -loop-guard-widening -loop-idiom -coro-elide -globaldce -loop-unroll -loweratomic -loop-simplifycfg -scalarizer -nary-reassociate -alignment-from-assumptions -partially-inline-libcalls -elim-avail-extern -pgo-memop-opt -gvn-hoist -jump-threading -nary-reassociate -jump-threading -jump-threading -strip-nondebug -correlated-propagation -float2int -partially-inline-libcalls -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,1.031555571474623,75.60634303092957,opt -libcalls-shrinkwrap -loop-interchange -loop-distribute -rpo-functionattrs -flattencfg -jump-threading -loop-versioning -strip -rewrite-statepoints-for-gc -sink -loop-versioning-licm -strip-nondebug -coro-elide -loop-instsimplify -deadargelim -strip-dead-prototypes -indvars -reassociate -loop-reduce -loop-distribute -memcpyopt -lower-widenable-condition -elim-avail-extern -loop-versioning-licm -nary-reassociate -post-inline-ee-instrument -consthoist -lower-matrix-intrinsics -coro-early -sancov -irce -lowerinvoke -loop-guard-widening -lower-guard-intrinsic -attributor -loop-unroll -loop-sink -instnamer -instnamer -loop-versioning-licm -loop-vectorize -reg2mem -irce -post-inline-ee-instrument -ipconstprop -instsimplify -inject-tli-mappings -callsite-splitting -name-anon-globals -strip-debug-declare -hotcoldsplit -loop-sink -loop-data-prefetch -globalopt -strip-debug-declare -lower-constant-intrinsics -flattencfg -mem2reg -pgo-memop-opt -sccp -rpo-functionattrs -prune-eh -separate-const-offset-from-gep -strip-dead-prototypes -deadargelim -flattencfg -gvn-hoist -ipconstprop -infer-address-spaces -early-cse-memssa -lower-expect -sroa -post-inline-ee-instrument -libcalls-shrinkwrap -gvn-hoist -consthoist -die -libcalls-shrinkwrap -lower-widenable-condition -ipsccp -loop-instsimplify -loop-versioning -break-crit-edges -loop-deletion -constmerge -canonicalize-aliases -slp-vectorizer -post-inline-ee-instrument -inferattrs -lower-widenable-condition -prune-eh -argpromotion -dce -lowerinvoke -called-value-propagation -loop-reroll -rewrite-statepoints-for-gc -loop-interchange -loop-load-elim -cross-dso-cfi -simplifycfg -float2int -correlated-propagation -loweratomic -sancov -functionattrs -instcombine -deadargelim -bdce -lowerinvoke -memcpyopt -argpromotion -hotcoldsplit -coro-elide -strip-debug-declare -argpromotion -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.000753985351142,77.92356705665588,opt -ee-instrument -loop-load-elim -functionattrs -early-cse-memssa -sccp -attributor -canonicalize-aliases -libcalls-shrinkwrap -loop-guard-widening -irce -sroa -loop-reroll -ee-instrument -irce -nary-reassociate -add-discriminators -loop-sink -post-inline-ee-instrument -globalopt -early-cse-memssa -globalopt -loop-data-prefetch -loop-guard-widening -float2int -lower-widenable-condition -indvars -strip-dead-prototypes -scalarizer -redundant-dbg-inst-elim -load-store-vectorizer -globalopt -redundant-dbg-inst-elim -name-anon-globals -break-crit-edges -div-rem-pairs -inject-tli-mappings -loop-distribute -attributor -mergereturn -coro-split -rewrite-statepoints-for-gc -coro-cleanup -loop-deletion -speculative-execution -loop-reduce -loop-instsimplify -scalarizer -instsimplify -attributor -elim-avail-extern -bdce -scalarizer -strip-dead-prototypes -gvn -consthoist -loop-versioning -aggressive-instcombine -newgvn -cross-dso-cfi -memcpyopt -lcssa -lower-guard-intrinsic -mergeicmps -loop-distribute -loop-deletion -tailcallelim -loop-data-prefetch -separate-const-offset-from-gep -ee-instrument -insert-gcov-profiling -indvars -lower-guard-intrinsic -memcpyopt -loop-idiom -slp-vectorizer -elim-avail-extern -jump-threading -alignment-from-assumptions -loop-unroll-and-jam -loop-load-elim -rpo-functionattrs -strip-dead-prototypes -guard-widening -loop-idiom -mergefunc -gvn -rewrite-statepoints-for-gc -break-crit-edges -coro-early -pgo-memop-opt -cross-dso-cfi -mldst-motion -loop-sink -jump-threading -lcssa -jump-threading -guard-widening -bdce -instnamer -lower-guard-intrinsic -reg2mem -insert-gcov-profiling -loop-interchange -mem2reg -simple-loop-unswitch -hotcoldsplit -loop-unswitch -gvn-hoist -loop-unswitch -constmerge -add-discriminators -instcombine -slsr -loop-predication -loop-data-prefetch -barrier -simplifycfg -barrier -globaldce -instsimplify input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.0105557949159845,74.41571712493896,opt -partially-inline-libcalls -sccp -loop-idiom -flattencfg -div-rem-pairs -globalopt -coro-cleanup -elim-avail-extern -called-value-propagation -loop-unswitch -loop-vectorize -attributor -always-inline -loop-simplifycfg -prune-eh -mergeicmps -loop-fusion -elim-avail-extern -adce -post-inline-ee-instrument -div-rem-pairs -argpromotion -simplifycfg -loop-simplifycfg -loop-data-prefetch -lower-matrix-intrinsics -loop-idiom -gvn-hoist -alignment-from-assumptions -deadargelim -mldst-motion -correlated-propagation -lower-matrix-intrinsics -memcpyopt -functionattrs -die -loop-instsimplify -loop-versioning-licm -die -sccp -coro-cleanup -sink -loop-fusion -memcpyopt -nary-reassociate -cross-dso-cfi -reassociate -coro-early -infer-address-spaces -float2int -guard-widening -rpo-functionattrs -aggressive-instcombine -float2int -simple-loop-unswitch -loop-unroll -indvars -lowerinvoke -scalarizer -prune-eh -ipsccp -inferattrs -strip-debug-declare -sroa -bdce -loop-deletion -lowerinvoke -forceattrs -rpo-functionattrs -load-store-vectorizer -rewrite-statepoints-for-gc -coro-elide -libcalls-shrinkwrap -strip -loop-deletion -die -speculative-execution -aggressive-instcombine -loop-fusion -sink -loop-vectorize -loop-versioning-licm -slp-vectorizer -prune-eh -separate-const-offset-from-gep -loop-versioning-licm -instsimplify -simplifycfg -mergefunc -canonicalize-aliases -correlated-propagation -float2int -coro-early -globaldce -gvn-hoist -loop-vectorize -simple-loop-unswitch -loop-predication -prune-eh -loop-simplifycfg -memcpyopt -inferattrs -always-inline -functionattrs -simple-loop-unswitch -loop-guard-widening -consthoist -indvars -instsimplify -slp-vectorizer -aggressive-instcombine -instcombine -aggressive-instcombine -gvn input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.0111661640097658,76.2009334564209,opt -slp-vectorizer -correlated-propagation -adce -partially-inline-libcalls -loop-versioning-licm -loweratomic -speculative-execution -ee-instrument -jump-threading -inferattrs -elim-avail-extern -simplifycfg -loop-data-prefetch -break-crit-edges -newgvn -div-rem-pairs -loop-reduce -prune-eh -bdce -die -loop-predication -reassociate -break-crit-edges -lower-matrix-intrinsics -rewrite-statepoints-for-gc -coro-cleanup -loop-idiom -bdce -mergereturn -indvars -always-inline -constprop -prune-eh -mergeicmps -separate-const-offset-from-gep -adce -lower-matrix-intrinsics -partial-inliner -slp-vectorizer -loop-fusion -coro-early -insert-gcov-profiling -strip -post-inline-ee-instrument -globalopt -loop-simplify -guard-widening -post-inline-ee-instrument -canonicalize-aliases -tailcallelim -lcssa -name-anon-globals -adce -coro-cleanup -break-crit-edges -loop-simplifycfg -reg2mem -loop-unroll -nary-reassociate -simple-loop-unswitch -strip -mem2reg -lower-constant-intrinsics -memcpyopt -div-rem-pairs -correlated-propagation -prune-eh -forceattrs -pgo-memop-opt -loop-unswitch -lcssa -constprop -loop-deletion -deadargelim -ipsccp -loop-simplifycfg -loop-sink -separate-const-offset-from-gep -slp-vectorizer -coro-cleanup -called-value-propagation -strip-dead-prototypes -simple-loop-unswitch -ipconstprop -div-rem-pairs -strip-debug-declare -speculative-execution -scalarizer -loop-versioning-licm -coro-cleanup -partial-inliner -loop-versioning-licm -called-value-propagation -functionattrs -slp-vectorizer -float2int -ipsccp -scalarizer -coro-early -adce -callsite-splitting -slsr -elim-avail-extern -tailcallelim -name-anon-globals -memcpyopt -coro-elide -forceattrs -lowerinvoke -libcalls-shrinkwrap -sink -lower-guard-intrinsic -prune-eh -nary-reassociate -forceattrs -rpo-functionattrs -cross-dso-cfi -bdce -correlated-propagation -loop-data-prefetch -loop-distribute -always-inline -sroa -loop-unroll -loop-versioning -loop-versioning-licm -globaldce -coro-cleanup -slsr -loweratomic -coro-split -loop-simplify -insert-gcov-profiling -die -instsimplify -loop-distribute -called-value-propagation -slp-vectorizer -sccp -libcalls-shrinkwrap -loop-unroll -slp-vectorizer -early-cse-memssa -loop-interchange -lower-widenable-condition -strip -strip-dead-prototypes -dse -coro-elide -constprop -pgo-memop-opt -coro-elide -add-discriminators -loop-distribute -simplifycfg -guard-widening -loop-versioning-licm -slp-vectorizer -lcssa -coro-early -loop-guard-widening -gvn -instcombine -correlated-propagation -lower-expect -functionattrs -lcssa -adce -instcombine -sccp -ipsccp -tailcallelim -ipconstprop -strip-dead-prototypes -rpo-functionattrs -forceattrs -newgvn input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.0149360907654748,74.06858968734741,opt -dce -constprop -attributor -loop-reroll -slsr -always-inline -instsimplify -inject-tli-mappings -inject-tli-mappings -sroa -loop-versioning-licm -float2int -lower-widenable-condition -loop-sink -coro-elide -speculative-execution -loweratomic -strip-dead-prototypes -flattencfg -simplifycfg -loop-reroll -slsr -loop-deletion -div-rem-pairs -reassociate -mergefunc -scalarizer -callsite-splitting -simple-loop-unswitch -prune-eh -loop-instsimplify -guard-widening -loop-idiom -bdce -constprop -loop-predication -die -mem2reg -newgvn -mem2reg -mergeicmps -deadargelim -early-cse-memssa -correlated-propagation -called-value-propagation -reassociate -mergefunc -div-rem-pairs -loop-versioning -post-inline-ee-instrument -mem2reg -loop-versioning -gvn-hoist -early-cse-memssa -rewrite-statepoints-for-gc -strip-dead-prototypes -simple-loop-unswitch -coro-split -sink -strip-dead-prototypes -jump-threading -sccp -break-crit-edges -scalarizer -loop-load-elim -loop-guard-widening -memcpyopt -ipconstprop -coro-elide -mergereturn -globalopt -mldst-motion -div-rem-pairs -speculative-execution -simple-loop-unswitch -callsite-splitting -infer-address-spaces -licm -simplifycfg -cross-dso-cfi -strip-debug-declare -early-cse-memssa -mldst-motion -lcssa -slsr -functionattrs -sancov -rpo-functionattrs -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.0156541720522767,76.2298526763916,opt -loop-load-elim -mem2reg -rpo-functionattrs -ee-instrument -ipsccp -strip-debug-declare -licm -sccp -dce -loop-simplifycfg -post-inline-ee-instrument -globaldce -reassociate -coro-cleanup -slsr -simplifycfg -constmerge -loop-predication -constprop -sroa -mergefunc -coro-elide -forceattrs -constprop -sroa -loop-unswitch -called-value-propagation -simple-loop-unswitch -memcpyopt -strip-dead-prototypes -loop-simplify -pgo-memop-opt -die -globaldce -guard-widening -instcombine -cross-dso-cfi -infer-address-spaces -div-rem-pairs -simple-loop-unswitch -loop-instsimplify -instcombine -coro-elide -loop-fusion -mergefunc -consthoist -callsite-splitting -called-value-propagation -globalopt -memcpyopt -lower-expect -sancov -instcombine -strip-debug-declare -elim-avail-extern -scalarizer -coro-early -loop-fusion -loop-idiom -inject-tli-mappings -loop-instsimplify -newgvn -break-crit-edges -barrier -loop-unroll-and-jam -loop-simplifycfg -gvn-hoist -strip-debug-declare -licm -canonicalize-aliases -inject-tli-mappings -sancov -reassociate -rewrite-statepoints-for-gc -simple-loop-unswitch -loop-instsimplify -loop-deletion -speculative-execution -mem2reg -correlated-propagation -mergereturn -rewrite-statepoints-for-gc -loop-predication -jump-threading -gvn-hoist -licm -ipconstprop -loop-unroll -flattencfg -functionattrs -loop-simplifycfg -lower-constant-intrinsics -instcombine input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.0159414045669974,77.51045274734497,opt -strip-debug-declare -sroa -jump-threading -partially-inline-libcalls -sink -dse -globaldce -mem2reg -argpromotion -consthoist -loop-reduce -tailcallelim -libcalls-shrinkwrap -lower-matrix-intrinsics -loop-load-elim -simple-loop-unswitch -mergeicmps -sancov -gvn-hoist -break-crit-edges -break-crit-edges -early-cse-memssa -argpromotion -scalarizer -always-inline -add-discriminators -guard-widening -callsite-splitting -loop-simplify -globaldce -loop-unroll-and-jam -insert-gcov-profiling -float2int -indvars -separate-const-offset-from-gep -loop-interchange -jump-threading -inferattrs -loop-unroll-and-jam -strip-dead-prototypes -div-rem-pairs -attributor -mergereturn -sancov -loop-versioning-licm -simple-loop-unswitch -tailcallelim -inferattrs -float2int -forceattrs -float2int -instcombine -loop-versioning -inferattrs -callsite-splitting -loop-guard-widening -speculative-execution -correlated-propagation -simplifycfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.0213270142180093,75.81489181518555,opt -loop-idiom -div-rem-pairs -mem2reg -simple-loop-unswitch -mem2reg -mergefunc -loop-idiom -loop-instsimplify -irce -sroa -loop-distribute -libcalls-shrinkwrap -newgvn -memcpyopt -coro-elide -simplifycfg -ipconstprop -loop-unroll-and-jam -forceattrs -loweratomic -loop-reroll -barrier -lcssa -libcalls-shrinkwrap -mergereturn -name-anon-globals -flattencfg -instsimplify -loop-fusion -loop-versioning -early-cse-memssa -instcombine input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.0244506678155967,76.34029912948608,opt -ee-instrument -globaldce -mem2reg -rpo-functionattrs -loop-vectorize -instcombine -strip -callsite-splitting -infer-address-spaces -alignment-from-assumptions -mldst-motion -redundant-dbg-inst-elim -strip-dead-prototypes -loop-data-prefetch -pgo-memop-opt -die -bdce -early-cse-memssa -loop-predication -reassociate -lowerinvoke -instnamer -indvars -sroa -cross-dso-cfi -mergefunc -deadargelim -gvn-hoist -instcombine -post-inline-ee-instrument -loop-data-prefetch -nary-reassociate -irce -lowerinvoke -sancov -elim-avail-extern -nary-reassociate -loop-distribute -aggressive-instcombine -tailcallelim -correlated-propagation -early-cse-memssa -loop-idiom -loop-predication -slsr -mldst-motion -loop-reroll -newgvn -coro-elide -reassociate -loop-distribute -simplifycfg -inject-tli-mappings -memcpyopt input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.0263535832256214,76.55784583091736,opt -loop-distribute -speculative-execution -inferattrs -die -instnamer -loop-versioning -name-anon-globals -rewrite-statepoints-for-gc -loop-instsimplify -correlated-propagation -indvars -loop-idiom -libcalls-shrinkwrap -strip-nondebug -load-store-vectorizer -canonicalize-aliases -indvars -scalarizer -coro-elide -globalsplit -sroa -ipconstprop -lower-guard-intrinsic -nary-reassociate -mem2reg -loop-versioning -newgvn -instnamer -instsimplify -tailcallelim -memcpyopt -mergefunc -die -partially-inline-libcalls -loop-predication -loop-distribute -aggressive-instcombine -sccp -reg2mem -scalarizer -forceattrs -die -guard-widening -libcalls-shrinkwrap -libcalls-shrinkwrap -gvn-hoist -coro-cleanup -mem2reg -memcpyopt -loop-predication -scalarizer -inferattrs -loop-simplify -flattencfg -scalarizer -loop-distribute -mldst-motion -coro-early -scalarizer -infer-address-spaces -instnamer -reassociate -break-crit-edges -lowerinvoke -early-cse-memssa -ee-instrument -globalopt -called-value-propagation -guard-widening -correlated-propagation -guard-widening -loop-unroll-and-jam -partial-inliner -partial-inliner -loop-predication -loop-idiom -loop-reduce -loop-deletion -correlated-propagation -functionattrs -loop-versioning-licm -deadargelim -die -gvn-hoist -globalopt -argpromotion -strip-dead-prototypes -irce -strip-nondebug -globalopt -lower-constant-intrinsics -rpo-functionattrs -sccp -div-rem-pairs -globalopt -loop-unswitch -lower-guard-intrinsic -ipsccp -loop-predication -scalarizer -loop-reroll -licm -mergereturn -elim-avail-extern -loop-fusion -simple-loop-unswitch -loop-interchange -simplifycfg -ipsccp -dce -lcssa -sccp -strip-debug-declare -loop-versioning-licm -hotcoldsplit -coro-cleanup -add-discriminators -break-crit-edges -ee-instrument -loop-data-prefetch -functionattrs -reassociate -inject-tli-mappings -load-store-vectorizer -loop-load-elim -simple-loop-unswitch -loop-unroll -strip -pgo-memop-opt -instcombine -dce -newgvn -lower-matrix-intrinsics -hotcoldsplit -argpromotion -prune-eh -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,1.0282564986356453,76.88841128349304,opt -aggressive-instcombine -float2int -inject-tli-mappings -post-inline-ee-instrument -coro-elide -called-value-propagation -reg2mem -constprop -functionattrs -adce -dce -add-discriminators -pgo-memop-opt -prune-eh -attributor -mem2reg -argpromotion -coro-early -adce -mergefunc -strip -indvars -rpo-functionattrs -deadargelim -post-inline-ee-instrument -mergeicmps -coro-early -functionattrs -loop-versioning-licm -irce -mergefunc -loop-predication -lower-matrix-intrinsics -adce -strip-nondebug -gvn -dse -gvn-hoist -sancov -lower-widenable-condition -ee-instrument -rewrite-statepoints-for-gc -strip-debug-declare -barrier -insert-gcov-profiling -load-store-vectorizer -rewrite-statepoints-for-gc -hotcoldsplit -strip-debug-declare -called-value-propagation -instnamer -lower-widenable-condition -mergereturn -loop-unroll -slsr -speculative-execution -partially-inline-libcalls -jump-threading -lower-constant-intrinsics -constmerge -barrier -gvn -loop-reroll -attributor -reassociate -lower-guard-intrinsic -licm -redundant-dbg-inst-elim -guard-widening -tailcallelim -lcssa -dse -mem2reg -sroa -break-crit-edges -loop-interchange -mergeicmps -indvars -loweratomic -mergefunc -gvn-hoist -aggressive-instcombine -tailcallelim -loop-interchange -rpo-functionattrs -libcalls-shrinkwrap -lower-matrix-intrinsics -consthoist -loop-unroll-and-jam -alignment-from-assumptions -globalsplit -pgo-memop-opt -ee-instrument -coro-early -attributor -constprop -loweratomic -instnamer -prune-eh -loop-simplify -nary-reassociate -mem2reg -called-value-propagation -partial-inliner -loop-fusion -indvars -coro-elide -elim-avail-extern -strip -loop-distribute -rpo-functionattrs -loop-sink -float2int -globalopt -sink -dce -float2int -loop-reroll -forceattrs -slp-vectorizer -loop-instsimplify -mergeicmps -globaldce -load-store-vectorizer -loop-unroll-and-jam -lcssa -loop-simplify -coro-cleanup -lower-matrix-intrinsics -lower-matrix-intrinsics -loop-reroll -sroa -sink -hotcoldsplit -break-crit-edges -tailcallelim -mldst-motion -tailcallelim -globalsplit -deadargelim -lower-matrix-intrinsics -barrier -loop-distribute -name-anon-globals -instcombine -lower-guard-intrinsic -coro-elide -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.0113177623990772,77.15600180625916,opt -loop-load-elim -div-rem-pairs -prune-eh -gvn -argpromotion -div-rem-pairs -mem2reg -strip-debug-declare -add-discriminators -coro-early -attributor -dce -guard-widening -inject-tli-mappings -loop-predication -ee-instrument -simplifycfg -lower-widenable-condition -strip -cross-dso-cfi -loop-unswitch -loop-unroll -lower-widenable-condition -redundant-dbg-inst-elim -load-store-vectorizer -strip -correlated-propagation -consthoist -memcpyopt -lowerinvoke -instnamer -licm -sink -lower-matrix-intrinsics -lower-matrix-intrinsics -lower-widenable-condition -loop-unswitch -lower-guard-intrinsic -flattencfg -indvars -dce -lcssa -loop-unroll-and-jam -dce -hotcoldsplit -gvn-hoist -alignment-from-assumptions -callsite-splitting -libcalls-shrinkwrap -load-store-vectorizer -strip -break-crit-edges -lower-widenable-condition -sink -coro-early -ipsccp -lcssa -licm -load-store-vectorizer -strip-dead-prototypes -called-value-propagation -gvn -early-cse-memssa -lowerinvoke -inject-tli-mappings -early-cse-memssa -insert-gcov-profiling -aggressive-instcombine -loop-interchange -consthoist -loop-load-elim -coro-elide -prune-eh -bdce -lcssa -scalarizer -correlated-propagation -flattencfg -coro-split -licm -early-cse-memssa -ipconstprop -licm -lowerinvoke -lower-constant-intrinsics -callsite-splitting -constprop -prune-eh -guard-widening -simple-loop-unswitch -insert-gcov-profiling -break-crit-edges -strip -newgvn -correlated-propagation -loop-simplify -barrier -ipsccp -ipconstprop -loop-idiom -ipconstprop -loop-vectorize -partial-inliner -lower-expect -ipsccp -ipconstprop -simplifycfg -loop-versioning -mergeicmps -called-value-propagation -flattencfg -sink -early-cse-memssa -libcalls-shrinkwrap -loop-simplifycfg -loop-guard-widening -loop-predication -always-inline -loop-instsimplify -load-store-vectorizer -mergeicmps -instsimplify -gvn -instsimplify -mem2reg -loop-interchange -forceattrs -mem2reg -libcalls-shrinkwrap -instsimplify -lcssa -loop-sink -callsite-splitting -load-store-vectorizer -ipconstprop -die -inferattrs -loop-guard-widening -div-rem-pairs -insert-gcov-profiling -scalarizer -called-value-propagation -loop-versioning -div-rem-pairs -loop-reduce -pgo-memop-opt -ipsccp -correlated-propagation -sink -loop-versioning-licm -functionattrs -newgvn -ipconstprop -aggressive-instcombine -loop-simplify -name-anon-globals -lcssa -licm -cross-dso-cfi -loop-interchange -lower-matrix-intrinsics -mem2reg -reassociate -hotcoldsplit -add-discriminators -tailcallelim -always-inline -slsr -loweratomic -lower-matrix-intrinsics -instcombine -tailcallelim -strip -post-inline-ee-instrument -lowerinvoke -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.0122909457900806,381.1352982521057,opt -name-anon-globals -libcalls-shrinkwrap -loop-data-prefetch -float2int -lcssa -gvn -coro-elide -loop-interchange -separate-const-offset-from-gep -sroa -rewrite-statepoints-for-gc -ipconstprop -cross-dso-cfi -argpromotion -aggressive-instcombine -separate-const-offset-from-gep -functionattrs -instnamer -mldst-motion -rewrite-statepoints-for-gc -loop-predication -globaldce -gvn-hoist -loop-data-prefetch -ipsccp -hotcoldsplit -mergereturn -rewrite-statepoints-for-gc -libcalls-shrinkwrap -add-discriminators -mldst-motion -globalopt -indvars -constmerge -prune-eh -partially-inline-libcalls -loop-reroll -loop-instsimplify -adce -tailcallelim -aggressive-instcombine -mergereturn -libcalls-shrinkwrap -mergefunc -simple-loop-unswitch -post-inline-ee-instrument -name-anon-globals -barrier -coro-early -partially-inline-libcalls -licm -loop-interchange -lowerinvoke -sink -sink -simple-loop-unswitch -lower-constant-intrinsics -consthoist -loop-data-prefetch -loop-unroll -instcombine -nary-reassociate -forceattrs -scalarizer -float2int -dse -early-cse-memssa -memcpyopt -loop-interchange -div-rem-pairs -lower-matrix-intrinsics -memcpyopt -scalarizer -instcombine -simple-loop-unswitch -post-inline-ee-instrument -instsimplify -instnamer -mergeicmps -globalsplit -callsite-splitting -ipsccp -globalopt -rpo-functionattrs -ipconstprop -callsite-splitting -insert-gcov-profiling -loop-reduce -loop-simplifycfg -strip-nondebug -barrier -inject-tli-mappings -loop-distribute -licm -libcalls-shrinkwrap -coro-cleanup -name-anon-globals -post-inline-ee-instrument -strip-debug-declare -sink -lcssa -ee-instrument -loop-instsimplify -simple-loop-unswitch -simplifycfg -canonicalize-aliases -newgvn input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.0167243367935412,88.61051821708679,opt -correlated-propagation -instnamer -redundant-dbg-inst-elim -loop-idiom -loop-simplify -globalsplit -div-rem-pairs -break-crit-edges -constmerge -ipconstprop -loop-instsimplify -alignment-from-assumptions -canonicalize-aliases -coro-split -consthoist -sroa -irce -loop-versioning -lower-matrix-intrinsics -gvn -mldst-motion -coro-cleanup -loop-guard-widening -insert-gcov-profiling -load-store-vectorizer -elim-avail-extern -constprop -instcombine -gvn-hoist -die -called-value-propagation -lower-widenable-condition -newgvn -pgo-memop-opt -called-value-propagation -functionattrs -forceattrs -instcombine -guard-widening -callsite-splitting -coro-early -loop-load-elim -aggressive-instcombine -lcssa -constprop -reassociate -mem2reg -always-inline -newgvn -scalarizer -consthoist -constmerge -loop-load-elim -consthoist -coro-elide -barrier -guard-widening -loop-versioning -lower-widenable-condition -scalarizer -mldst-motion -argpromotion -adce -scalarizer -scalarizer -correlated-propagation -forceattrs -correlated-propagation -gvn -coro-elide -hotcoldsplit -jump-threading -lowerinvoke -slsr -loop-distribute -constprop -loop-sink -correlated-propagation -coro-split -break-crit-edges -loweratomic -barrier -elim-avail-extern -elim-avail-extern -dce -mem2reg -strip-dead-prototypes -lower-expect -break-crit-edges -lcssa -consthoist -adce -loop-vectorize -div-rem-pairs -correlated-propagation -lower-widenable-condition -constprop -sancov -loop-unroll-and-jam -loop-reduce -lower-constant-intrinsics -deadargelim -infer-address-spaces -coro-cleanup -deadargelim -loop-idiom -coro-early -lower-matrix-intrinsics -globalsplit -globaldce -loop-deletion -mldst-motion -nary-reassociate -coro-split -die -simplifycfg -instcombine input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.0197159746251443,78.524822473526,opt -pgo-memop-opt -consthoist -simplifycfg -gvn-hoist -nary-reassociate -instnamer -gvn-hoist -redundant-dbg-inst-elim -post-inline-ee-instrument -loop-guard-widening -lower-matrix-intrinsics -hotcoldsplit -canonicalize-aliases -simplifycfg -nary-reassociate -cross-dso-cfi -loop-versioning -instsimplify -constmerge -lowerinvoke -adce -scalarizer -pgo-memop-opt -argpromotion -hotcoldsplit -correlated-propagation -loop-idiom -loop-deletion -barrier -dse -partially-inline-libcalls -loop-simplifycfg -coro-split -lower-expect -redundant-dbg-inst-elim -loop-interchange -reg2mem -separate-const-offset-from-gep -newgvn -globaldce -elim-avail-extern -loop-sink -lcssa -coro-cleanup -strip-debug-declare -mem2reg -gvn-hoist -loop-versioning-licm -forceattrs -mldst-motion -strip-dead-prototypes -strip-dead-prototypes -instcombine -sroa -jump-threading -tailcallelim -speculative-execution -loop-unroll-and-jam -adce -mergefunc -loop-versioning -dse -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.0200043252595157,76.91719341278076,opt -loop-simplify -strip -gvn -lcssa -functionattrs -argpromotion -strip -correlated-propagation -lower-expect -prune-eh -cross-dso-cfi -tailcallelim -lower-matrix-intrinsics -simple-loop-unswitch -instcombine -instsimplify -guard-widening -inject-tli-mappings -speculative-execution -strip-debug-declare -loop-instsimplify -sink -strip-nondebug -lcssa -sccp -strip -instnamer -gvn -gvn-hoist -loop-unroll-and-jam -strip-dead-prototypes -always-inline -lower-guard-intrinsic -elim-avail-extern -lcssa -tailcallelim -constmerge -strip -rpo-functionattrs -reassociate -loop-data-prefetch -loop-reduce -elim-avail-extern -simplifycfg -lowerinvoke -coro-cleanup -break-crit-edges -cross-dso-cfi -globalopt -coro-elide -sroa -gvn-hoist -argpromotion -loweratomic -speculative-execution -guard-widening -insert-gcov-profiling -bdce -lower-widenable-condition -mergefunc -slsr -simple-loop-unswitch -called-value-propagation -partial-inliner -div-rem-pairs -instcombine -dce -add-discriminators -coro-early -canonicalize-aliases -newgvn -globaldce -name-anon-globals -simple-loop-unswitch -dce -correlated-propagation -loop-unroll -rewrite-statepoints-for-gc -loop-instsimplify -nary-reassociate -loweratomic -loop-predication -licm -constprop -instsimplify -inject-tli-mappings -tailcallelim -pgo-memop-opt -prune-eh -name-anon-globals -lower-widenable-condition -globalopt -slsr -loop-instsimplify -early-cse-memssa -deadargelim -insert-gcov-profiling -guard-widening -sroa -deadargelim -mldst-motion -alignment-from-assumptions -alignment-from-assumptions -strip-dead-prototypes -lower-expect -coro-elide -flattencfg -globalsplit -lower-widenable-condition -always-inline -forceattrs -flattencfg -always-inline -sancov -lower-constant-intrinsics -instcombine -attributor -jump-threading input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.0214821222606691,74.76235461235046,opt -inferattrs -gvn-hoist -globaldce -loop-deletion -sccp -loop-guard-widening -ipconstprop -canonicalize-aliases -coro-split -mergeicmps -insert-gcov-profiling -lower-guard-intrinsic -lower-matrix-intrinsics -adce -argpromotion -loweratomic -newgvn -strip-dead-prototypes -flattencfg -lowerinvoke -name-anon-globals -functionattrs -strip-dead-prototypes -nary-reassociate -ee-instrument -rpo-functionattrs -loop-unroll -break-crit-edges -loop-predication -dse -reassociate -sroa -instcombine -lower-widenable-condition -loop-fusion -indvars -newgvn -lower-guard-intrinsic -float2int -nary-reassociate -memcpyopt -canonicalize-aliases -inject-tli-mappings -loop-vectorize -callsite-splitting -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.021914648212226,76.11744666099548,opt -constmerge -mergereturn -early-cse-memssa -instsimplify -always-inline -libcalls-shrinkwrap -float2int -adce -simplifycfg -mldst-motion -adce -constmerge -gvn -constprop -callsite-splitting -loop-deletion -loop-simplify -coro-cleanup -infer-address-spaces -libcalls-shrinkwrap -deadargelim -memcpyopt -globalopt -speculative-execution -name-anon-globals -break-crit-edges -memcpyopt -nary-reassociate -canonicalize-aliases -loop-interchange -post-inline-ee-instrument -add-discriminators -argpromotion -indvars -gvn -dce -loop-instsimplify -libcalls-shrinkwrap -lowerinvoke -loop-reroll -lower-matrix-intrinsics -loop-deletion -aggressive-instcombine -gvn -redundant-dbg-inst-elim -globaldce -lower-widenable-condition -loop-load-elim -aggressive-instcombine -deadargelim -loop-versioning-licm -lcssa -post-inline-ee-instrument -globalsplit -sink -loop-fusion -mem2reg -irce -simple-loop-unswitch -ipsccp -coro-early -pgo-memop-opt -memcpyopt -separate-const-offset-from-gep -libcalls-shrinkwrap -nary-reassociate -rewrite-statepoints-for-gc -functionattrs -strip-debug-declare -lower-matrix-intrinsics -coro-split -instsimplify -loop-versioning -strip-nondebug -instcombine -bdce -nary-reassociate -loweratomic -loop-simplifycfg -lower-widenable-condition -hotcoldsplit -loop-unroll-and-jam -coro-elide -constprop -loop-unroll -instcombine -simplifycfg -separate-const-offset-from-gep -jump-threading -canonicalize-aliases -loop-simplifycfg -loop-sink -early-cse-memssa -prune-eh -div-rem-pairs -strip-debug-declare -memcpyopt -mergereturn -simple-loop-unswitch -lower-constant-intrinsics -die -indvars -strip-dead-prototypes -strip -lowerinvoke -loop-simplify -lower-expect -scalarizer -loweratomic -mldst-motion -lowerinvoke -loop-guard-widening -flattencfg -div-rem-pairs -forceattrs -mergefunc -newgvn input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.024617935409458,75.6703040599823,opt -reg2mem -callsite-splitting -sroa -constmerge -lower-guard-intrinsic -constprop -loop-predication -strip-nondebug -loop-unroll -adce -coro-early -scalarizer -globalopt -indvars -loweratomic -loop-simplify -mldst-motion -constprop -div-rem-pairs -loop-instsimplify -dce -partial-inliner -loop-simplify -barrier -functionattrs -gvn -speculative-execution -loop-distribute -loop-versioning-licm -lower-widenable-condition -infer-address-spaces -simple-loop-unswitch -coro-elide -speculative-execution -lower-guard-intrinsic -dce -loop-data-prefetch -instcombine -inferattrs -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.0302768166089966,115.1228277683258,opt -instnamer -loop-idiom -rewrite-statepoints-for-gc -post-inline-ee-instrument -loop-interchange -ipsccp -elim-avail-extern -ipsccp -cross-dso-cfi -name-anon-globals -tailcallelim -loop-deletion -argpromotion -reassociate -loop-simplify -lcssa -rpo-functionattrs -aggressive-instcombine -instnamer -float2int -correlated-propagation -strip-debug-declare -correlated-propagation -consthoist -prune-eh -canonicalize-aliases -loop-simplifycfg -irce -loop-data-prefetch -lower-matrix-intrinsics -called-value-propagation -add-discriminators -partially-inline-libcalls -loop-versioning-licm -strip-nondebug -jump-threading -argpromotion -inject-tli-mappings -correlated-propagation -dce -inject-tli-mappings -coro-cleanup -simplifycfg -inject-tli-mappings -mergeicmps -insert-gcov-profiling -strip-dead-prototypes -lowerinvoke -coro-elide -break-crit-edges -loop-unroll-and-jam -sccp -functionattrs -partially-inline-libcalls -mem2reg -constprop -prune-eh -loop-idiom -slsr -callsite-splitting -strip-debug-declare -redundant-dbg-inst-elim -loop-fusion -lower-matrix-intrinsics -gvn -scalarizer -rpo-functionattrs -coro-elide -loop-simplifycfg -elim-avail-extern -instcombine -add-discriminators -lower-widenable-condition -loop-reroll -break-crit-edges -loop-data-prefetch -ipsccp -load-store-vectorizer -newgvn -flattencfg -reg2mem -mem2reg -coro-cleanup -gvn-hoist -coro-elide -partial-inliner -loop-unroll -constprop -loop-distribute -gvn-hoist -sancov -instnamer -nary-reassociate -ee-instrument -loop-fusion -loop-vectorize -lower-widenable-condition -ee-instrument -correlated-propagation -gvn -loop-guard-widening -constprop -add-discriminators -barrier -infer-address-spaces -loop-reroll -sink -globalopt -ee-instrument -callsite-splitting -mergefunc -rewrite-statepoints-for-gc -loop-predication -loop-interchange -cross-dso-cfi -loop-simplifycfg -reassociate -correlated-propagation -bdce -loop-reroll -loweratomic -loop-unroll -sink -pgo-memop-opt -speculative-execution -deadargelim -irce -instnamer -instnamer -add-discriminators -lowerinvoke -sancov -guard-widening -sancov -instcombine -add-discriminators -prune-eh -cross-dso-cfi -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiffdither,1.0309616493656286,74.79893708229065,opt -alignment-from-assumptions -callsite-splitting -correlated-propagation -simplifycfg -sccp -callsite-splitting -scalarizer -loop-vectorize -adce -sccp -lower-constant-intrinsics -loop-idiom -loop-unswitch -simplifycfg -partially-inline-libcalls -slsr -loop-instsimplify -pgo-memop-opt -loop-simplify -strip-dead-prototypes -instnamer -reassociate -guard-widening -rewrite-statepoints-for-gc -correlated-propagation -canonicalize-aliases -mergefunc -loweratomic -reassociate -instsimplify -pgo-memop-opt -loop-idiom -reg2mem -loop-load-elim -reg2mem -loop-deletion -post-inline-ee-instrument -scalarizer -strip-dead-prototypes -mergeicmps -loop-predication -flattencfg -loop-simplify -mldst-motion -loop-deletion -indvars -loop-load-elim -ipsccp -loop-unswitch -add-discriminators -break-crit-edges -sink -hotcoldsplit -mem2reg -globalsplit -loop-guard-widening -attributor -memcpyopt -callsite-splitting -inject-tli-mappings -loweratomic -loop-distribute -ipsccp -partially-inline-libcalls -early-cse-memssa -rewrite-statepoints-for-gc -consthoist -forceattrs -partial-inliner -coro-early -irce -float2int -libcalls-shrinkwrap -flattencfg -loop-data-prefetch -constprop -irce -instcombine -instsimplify -rewrite-statepoints-for-gc -loop-distribute -slsr -cross-dso-cfi -canonicalize-aliases -simplifycfg -inject-tli-mappings -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.0072743417233017,77.22859692573547,opt -rpo-functionattrs -coro-split -loop-unroll-and-jam -mem2reg -loop-fusion -correlated-propagation -deadargelim -loop-load-elim -speculative-execution -instsimplify -mldst-motion -mergeicmps -loop-instsimplify -scalarizer -correlated-propagation -instnamer -simplifycfg -name-anon-globals -slsr -strip -strip-nondebug -post-inline-ee-instrument -inferattrs -separate-const-offset-from-gep -pgo-memop-opt -strip-dead-prototypes -argpromotion -simple-loop-unswitch -barrier -deadargelim -constprop -instcombine -loop-interchange -tailcallelim -bdce -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.0072743417233019,73.91927719116211,opt -irce -elim-avail-extern -irce -called-value-propagation -slsr -inject-tli-mappings -redundant-dbg-inst-elim -scalarizer -coro-split -instsimplify -sroa -dse -rewrite-statepoints-for-gc -loop-vectorize -gvn-hoist -add-discriminators -load-store-vectorizer -sancov -irce -loop-simplify -instcombine -memcpyopt -lower-matrix-intrinsics -simple-loop-unswitch -constprop -partially-inline-libcalls -lcssa -loop-reroll -loop-load-elim -pgo-memop-opt -licm -prune-eh -rpo-functionattrs -redundant-dbg-inst-elim -attributor -nary-reassociate -lower-expect -simplifycfg -loop-sink -loop-instsimplify -instcombine -reassociate -loop-interchange -alignment-from-assumptions -loop-deletion -mem2reg -globaldce -rpo-functionattrs -loop-instsimplify -instnamer -add-discriminators -early-cse-memssa input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.0106895256309552,74.7277250289917,opt -newgvn -sroa -mergefunc -strip -nary-reassociate -cross-dso-cfi -always-inline -name-anon-globals -loop-reroll -inject-tli-mappings -strip-debug-declare -coro-early -lower-guard-intrinsic -argpromotion -argpromotion -barrier -tailcallelim -callsite-splitting -div-rem-pairs -strip-nondebug -ipsccp -dce -reassociate -simplifycfg -loop-fusion -globaldce -partially-inline-libcalls -strip-debug-declare -lower-widenable-condition -elim-avail-extern -early-cse-memssa -loop-unroll-and-jam -name-anon-globals -dse -coro-cleanup -post-inline-ee-instrument -instsimplify -lower-matrix-intrinsics -cross-dso-cfi -newgvn -lower-guard-intrinsic -inject-tli-mappings -gvn -lower-matrix-intrinsics -loop-simplifycfg -loop-simplifycfg -die -coro-cleanup -name-anon-globals -tailcallelim -sink -loop-predication -hotcoldsplit -tailcallelim -ipsccp -gvn -called-value-propagation -float2int -lower-matrix-intrinsics -sink -partially-inline-libcalls -simple-loop-unswitch -loop-simplifycfg -rewrite-statepoints-for-gc -instcombine input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.0140364058604556,77.69796371459961,opt -loop-unroll-and-jam -deadargelim -sancov -partially-inline-libcalls -inject-tli-mappings -loweratomic -loop-reduce -barrier -slsr -name-anon-globals -flattencfg -libcalls-shrinkwrap -pgo-memop-opt -coro-early -lower-expect -div-rem-pairs -loop-sink -loop-distribute -inject-tli-mappings -alignment-from-assumptions -globalsplit -jump-threading -instsimplify -partially-inline-libcalls -speculative-execution -loop-reduce -dse -early-cse-memssa -loop-predication -name-anon-globals -lower-expect -break-crit-edges -loop-predication -infer-address-spaces -loop-deletion -globaldce -constmerge -rewrite-statepoints-for-gc -separate-const-offset-from-gep -loweratomic -bdce -loop-distribute -alignment-from-assumptions -barrier -instsimplify -insert-gcov-profiling -strip-dead-prototypes -loop-distribute -correlated-propagation -strip-dead-prototypes -ipconstprop -attributor -post-inline-ee-instrument -sroa -flattencfg -sink -jump-threading -inject-tli-mappings -scalarizer -constprop -partially-inline-libcalls -always-inline -lower-matrix-intrinsics -slsr -attributor -indvars -loop-distribute -constmerge -gvn-hoist -slp-vectorizer -instcombine -mergereturn -insert-gcov-profiling -sink -mldst-motion -strip-dead-prototypes -ipconstprop -coro-elide -rewrite-statepoints-for-gc -redundant-dbg-inst-elim -nary-reassociate -float2int -barrier -sancov -consthoist -slp-vectorizer -correlated-propagation -lower-constant-intrinsics -lcssa -loop-data-prefetch -ipconstprop -loop-reroll -lower-expect -globalsplit -mergereturn -functionattrs -die -loop-fusion -newgvn -lower-widenable-condition -flattencfg -newgvn input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.0168027048256547,74.16467475891113,opt -sroa -gvn-hoist -sroa -globaldce -hotcoldsplit -float2int -mem2reg -strip-dead-prototypes -name-anon-globals -name-anon-globals -barrier -callsite-splitting -mldst-motion -libcalls-shrinkwrap -instcombine -loop-distribute -correlated-propagation -reg2mem -lcssa -constmerge -nary-reassociate -callsite-splitting -partial-inliner -called-value-propagation -die -slsr -alignment-from-assumptions -cross-dso-cfi -dse -die -early-cse-memssa -loop-load-elim -indvars -indvars -loop-load-elim -instsimplify -loop-predication -loop-interchange -deadargelim -coro-elide -sroa -loop-vectorize -mergereturn -licm -callsite-splitting -guard-widening -infer-address-spaces -deadargelim -strip-debug-declare -globalopt -lower-matrix-intrinsics -inject-tli-mappings -jump-threading -nary-reassociate -partially-inline-libcalls -gvn input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.018066322871487,358.7716484069824,opt -loop-deletion -add-discriminators -loop-unswitch -die -callsite-splitting -strip-debug-declare -libcalls-shrinkwrap -float2int -lower-widenable-condition -argpromotion -mem2reg -newgvn -early-cse-memssa -dce -lower-matrix-intrinsics -nary-reassociate -early-cse-memssa -loop-simplifycfg -loop-deletion -instcombine -speculative-execution -pgo-memop-opt -inject-tli-mappings -loop-sink -loop-deletion -jump-threading -hotcoldsplit -globalopt -libcalls-shrinkwrap -deadargelim -callsite-splitting -lower-expect -always-inline -float2int -sroa -sccp -elim-avail-extern -early-cse-memssa -nary-reassociate input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.0195007001127012,76.38189339637756,opt -lower-widenable-condition -barrier -loop-distribute -constmerge -lower-constant-intrinsics -newgvn -inferattrs -inject-tli-mappings -mldst-motion -speculative-execution -libcalls-shrinkwrap -guard-widening -hotcoldsplit -loweratomic -coro-elide -partially-inline-libcalls -break-crit-edges -attributor -mldst-motion -guard-widening -jump-threading -infer-address-spaces -hotcoldsplit -bdce -sancov -strip-dead-prototypes -coro-early -loop-idiom -name-anon-globals -lower-constant-intrinsics -loop-predication -mergefunc -irce -strip-dead-prototypes -loop-data-prefetch -reg2mem -float2int -irce -sroa -loop-data-prefetch -load-store-vectorizer -called-value-propagation -loop-versioning-licm -ipconstprop -memcpyopt -instcombine -libcalls-shrinkwrap -loop-simplify -sancov -always-inline -coro-split -lower-constant-intrinsics -strip -loop-reroll -strip -loop-interchange -loop-interchange -die -lower-constant-intrinsics -callsite-splitting -cross-dso-cfi -separate-const-offset-from-gep -redundant-dbg-inst-elim -strip-nondebug -sink -inject-tli-mappings -simplifycfg -inferattrs -loop-vectorize -mergereturn -loop-fusion -mergereturn -load-store-vectorizer -speculative-execution -early-cse-memssa -hotcoldsplit -always-inline -mergefunc -coro-early -mldst-motion -loop-unroll -sroa -loop-simplifycfg -sroa -slp-vectorizer -loop-distribute -lower-guard-intrinsic -strip-debug-declare -loop-vectorize -rewrite-statepoints-for-gc -loop-reroll -strip-dead-prototypes -hotcoldsplit -lcssa -alignment-from-assumptions -loweratomic -loop-reroll -correlated-propagation -loop-deletion -loop-load-elim -prune-eh -rewrite-statepoints-for-gc -guard-widening -loop-unroll -loop-idiom -bdce -called-value-propagation -consthoist -simplifycfg -deadargelim -instsimplify input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.0216864178135994,76.33752155303955,opt -elim-avail-extern -bdce -speculative-execution -bdce -consthoist -elim-avail-extern -loop-predication -coro-cleanup -globalsplit -inject-tli-mappings -loop-versioning-licm -mergeicmps -callsite-splitting -rewrite-statepoints-for-gc -jump-threading -loweratomic -sancov -dse -loop-sink -mem2reg -instcombine -hotcoldsplit -gvn -forceattrs -post-inline-ee-instrument -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.025579727468324,74.7141592502594,opt -lower-guard-intrinsic -lower-guard-intrinsic -sancov -sink -callsite-splitting -loop-simplifycfg -guard-widening -libcalls-shrinkwrap -loop-reroll -ee-instrument -prune-eh -argpromotion -loop-reduce -argpromotion -loop-simplifycfg -loop-unroll-and-jam -loop-versioning-licm -float2int -scalarizer -infer-address-spaces -simple-loop-unswitch -deadargelim -loop-idiom -loop-reroll -lower-expect -lower-expect -mergeicmps -mergefunc -coro-cleanup -canonicalize-aliases -scalarizer -gvn-hoist -redundant-dbg-inst-elim -add-discriminators -deadargelim -post-inline-ee-instrument -indvars -name-anon-globals -mem2reg -loop-simplifycfg -speculative-execution -separate-const-offset-from-gep -lowerinvoke -float2int -load-store-vectorizer -consthoist -strip -always-inline -slp-vectorizer -correlated-propagation -slsr -coro-early -callsite-splitting -lower-guard-intrinsic -lower-widenable-condition -redundant-dbg-inst-elim -globalsplit -loop-distribute -loop-deletion -rewrite-statepoints-for-gc -instnamer -licm -loop-distribute -instcombine -simplifycfg -mldst-motion -guard-widening -loop-instsimplify -simplifycfg -newgvn -reassociate input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,1.0331955875823913,76.41833972930908,opt -separate-const-offset-from-gep -coro-cleanup -die -coro-cleanup -called-value-propagation -adce -cross-dso-cfi -inject-tli-mappings -rpo-functionattrs -add-discriminators -lower-matrix-intrinsics -simplifycfg -simple-loop-unswitch -memcpyopt -instnamer -attributor -scalarizer -adce -loop-unroll-and-jam -post-inline-ee-instrument -reg2mem -flattencfg -lower-expect -loop-load-elim -strip-dead-prototypes -mergefunc -tailcallelim -barrier -inject-tli-mappings -loop-unroll -canonicalize-aliases -loop-distribute -loop-unswitch -slsr -partial-inliner -name-anon-globals -loop-interchange -lcssa -slsr -nary-reassociate -lower-constant-intrinsics -sink -loop-versioning-licm -coro-early -loop-instsimplify -pgo-memop-opt -post-inline-ee-instrument -tailcallelim -loop-distribute -loop-fusion -loop-reduce -loop-versioning -sancov -partially-inline-libcalls -instsimplify -early-cse-memssa -early-cse-memssa -coro-early -hotcoldsplit -early-cse-memssa -loop-simplify -memcpyopt -irce -mem2reg -guard-widening -canonicalize-aliases -attributor -cross-dso-cfi -attributor -globalsplit -functionattrs -strip-nondebug -instsimplify -loop-interchange -loop-predication -instcombine -gvn-hoist -globaldce -slsr -always-inline -lcssa -dce -mldst-motion -instsimplify -simple-loop-unswitch -mergefunc -lower-constant-intrinsics -newgvn -prune-eh -mergefunc -lcssa -cross-dso-cfi -loop-unroll -hotcoldsplit -loop-vectorize -loop-guard-widening -insert-gcov-profiling -name-anon-globals -early-cse-memssa -strip -loweratomic -simplifycfg -jump-threading input.bc -o output.bc +benchmark://cbench-v1/adpcm,1.0000000000000002,62.01178193092346,opt -strip-debug-declare -sroa -add-discriminators -speculative-execution -loop-versioning -loop-fusion -post-inline-ee-instrument -deadargelim -loop-unroll -instcombine -memcpyopt -loop-reduce -forceattrs -loop-vectorize -gvn -coro-elide -libcalls-shrinkwrap -loop-predication -loop-versioning-licm -instsimplify -dce -simplifycfg -pgo-memop-opt -scalarizer -loop-unroll-and-jam -break-crit-edges -loop-predication -instcombine -jump-threading -lower-matrix-intrinsics -sroa -instcombine -lower-constant-intrinsics -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/adpcm,1.0027932960893853,61.84229135513306,opt -loop-versioning-licm -lower-widenable-condition -lowerswitch -die -loop-unroll-and-jam -barrier -ipconstprop -mergereturn -gvn-hoist -instsimplify -argpromotion -mergeicmps -licm -pgo-memop-opt -sink -load-store-vectorizer -simplifycfg -loop-distribute -callsite-splitting -instnamer -globaldce -coro-early -deadargelim -strip-dead-prototypes -cross-dso-cfi -loweratomic -die -inline -rewrite-statepoints-for-gc -instcombine -consthoist -lower-matrix-intrinsics -lcssa -irce -loop-data-prefetch -loop-idiom -flattencfg -ipsccp -coro-cleanup -pgo-memop-opt -flattencfg -globalopt -loop-deletion -constprop -post-inline-ee-instrument -constprop -rpo-functionattrs -adce -coro-elide -loop-sink -gvn -inject-tli-mappings -mem2reg -sroa -load-store-vectorizer -loop-reroll -instnamer -post-inline-ee-instrument -lower-constant-intrinsics -rewrite-statepoints-for-gc -called-value-propagation -sink -loop-unswitch -loop-predication -aggressive-instcombine -lower-matrix-intrinsics -simple-loop-unswitch -licm -early-cse-memssa -loop-data-prefetch -loweratomic -loop-unroll-and-jam -coro-cleanup -tailcallelim -loop-predication -post-inline-ee-instrument -add-discriminators -dse -jump-threading -strip-debug-declare -mergefunc -nary-reassociate -lowerswitch -coro-cleanup -post-inline-ee-instrument -loop-interchange -inject-tli-mappings -nary-reassociate -loop-distribute -lower-constant-intrinsics -loop-versioning-licm -instsimplify input.bc -o output.bc +benchmark://cbench-v1/adpcm,1.0027932960893857,61.92401933670044,opt -pgo-memop-opt -functionattrs -sroa -loop-load-elim -memcpyopt -alignment-from-assumptions -speculative-execution -reassociate -ipconstprop -globaldce -lower-constant-intrinsics -indvars -loop-versioning -bdce -loop-deletion -post-inline-ee-instrument -reassociate -simplifycfg -cross-dso-cfi -memcpyopt -reassociate -dse -loop-unroll-and-jam -memcpyopt -tailcallelim -instcombine -sccp -div-rem-pairs -coro-elide -loop-guard-widening -loop-predication -sroa -nary-reassociate -loop-instsimplify -separate-const-offset-from-gep -name-anon-globals -flattencfg -partially-inline-libcalls -licm -lcssa -lower-constant-intrinsics -instsimplify -inline -coro-split -indvars -deadargelim -mldst-motion -loop-data-prefetch -loop-simplifycfg -pgo-memop-opt -coro-cleanup -loop-idiom -mergeicmps -name-anon-globals -gvn -rewrite-statepoints-for-gc -ipconstprop -always-inline -libcalls-shrinkwrap -lowerinvoke -name-anon-globals -dse -loop-unroll -loop-guard-widening -loop-vectorize -strip-debug-declare -strip-debug-declare -die -die -loop-fusion -lower-widenable-condition -attributor -coro-elide -libcalls-shrinkwrap -loop-predication -rewrite-statepoints-for-gc -redundant-dbg-inst-elim -correlated-propagation -globaldce -loop-data-prefetch -redundant-dbg-inst-elim -instsimplify -inject-tli-mappings -slsr -correlated-propagation -ipsccp -strip-dead-prototypes -slsr -inject-tli-mappings -sroa -loweratomic -adce -constprop -simple-loop-unswitch -inferattrs -constprop -rpo-functionattrs -loop-data-prefetch -lower-guard-intrinsic -mergereturn -scalarizer -reassociate -simplifycfg -add-discriminators -insert-gcov-profiling -correlated-propagation input.bc -o output.bc +benchmark://cbench-v1/adpcm,1.0027932960893857,61.99663496017456,opt -sink -globalopt -gvn-hoist -hotcoldsplit -sroa -add-discriminators -forceattrs -redundant-dbg-inst-elim -flattencfg -forceattrs -loop-idiom -loop-reduce -speculative-execution -memcpyopt -sccp -sancov -ipsccp -sancov -loop-load-elim -loop-fusion -coro-cleanup -strip-dead-prototypes -sink -coro-elide -loop-predication -loop-predication -constmerge -mergeicmps -constmerge -ipconstprop -libcalls-shrinkwrap -canonicalize-aliases -loweratomic -prune-eh -memcpyopt -loop-vectorize -adce -strip-debug-declare -argpromotion -lower-widenable-condition -lowerswitch -called-value-propagation -loop-instsimplify -libcalls-shrinkwrap -post-inline-ee-instrument -mldst-motion -instsimplify -sccp -flattencfg -mergeicmps -tailcallelim -simplifycfg -inline -name-anon-globals -instnamer -scalarizer -dce -insert-gcov-profiling -nary-reassociate -sccp -mergereturn -globaldce -coro-split -nary-reassociate -add-discriminators -inferattrs -div-rem-pairs -break-crit-edges -strip-nondebug -licm -simple-loop-unswitch -ipconstprop -slp-vectorizer -gvn-hoist -partial-inliner -adce -float2int -strip-debug-declare -speculative-execution -alignment-from-assumptions -flattencfg -rewrite-statepoints-for-gc -loop-unroll -callsite-splitting -constprop -mem2reg -partial-inliner -called-value-propagation -post-inline-ee-instrument -redundant-dbg-inst-elim -instcombine -memcpyopt -prune-eh -newgvn -constmerge -add-discriminators -libcalls-shrinkwrap -strip-nondebug -deadargelim -callsite-splitting -irce -gvn -loweratomic -lowerinvoke -slsr -globalopt -coro-split -loop-guard-widening -irce -argpromotion -break-crit-edges -coro-elide -mergefunc -loweratomic -jump-threading -consthoist -loop-versioning -ee-instrument -sccp -loop-vectorize -instnamer -guard-widening -loop-deletion -loop-instsimplify -div-rem-pairs -inject-tli-mappings -newgvn -loop-sink -licm -loop-unroll-and-jam -loop-unroll -lower-widenable-condition -correlated-propagation -nary-reassociate -nary-reassociate -aggressive-instcombine -ee-instrument -aggressive-instcombine -loop-sink -prune-eh -loweratomic -loop-versioning -early-cse-memssa -inferattrs -sccp -loweratomic -loop-fusion -memcpyopt -globalopt -die -inferattrs -partial-inliner -globaldce -loop-load-elim -mergereturn -mergeicmps -slp-vectorizer -strip-debug-declare -elim-avail-extern -partial-inliner -bdce -loweratomic -dce -constprop -load-store-vectorizer -insert-gcov-profiling -jump-threading -die -consthoist -lowerinvoke -indvars -loop-unroll-and-jam -loop-predication -simple-loop-unswitch -globalopt -lowerswitch -jump-threading -coro-early -cross-dso-cfi -inline -irce -loop-versioning -aggressive-instcombine -libcalls-shrinkwrap -lowerinvoke -pgo-memop-opt -instcombine input.bc -o output.bc +benchmark://cbench-v1/adpcm,1.005586592178771,61.88795065879822,opt -name-anon-globals -infer-address-spaces -lower-guard-intrinsic -reassociate -constmerge -separate-const-offset-from-gep -strip-debug-declare -coro-cleanup -loop-unroll-and-jam -add-discriminators -globaldce -barrier -name-anon-globals -reg2mem -infer-address-spaces -loop-versioning-licm -sancov -slsr -loop-unroll -loop-distribute -adce -argpromotion -lcssa -break-crit-edges -instnamer -coro-early -barrier -callsite-splitting -functionattrs -redundant-dbg-inst-elim -loop-idiom -loop-guard-widening -flattencfg -mem2reg -consthoist -called-value-propagation -mergeicmps -lower-matrix-intrinsics -indvars -lower-expect -simplifycfg -name-anon-globals -redundant-dbg-inst-elim -strip-debug-declare -inject-tli-mappings -indvars -separate-const-offset-from-gep -loop-interchange -infer-address-spaces -strip-nondebug -rewrite-statepoints-for-gc -loop-unswitch -separate-const-offset-from-gep -strip-nondebug -libcalls-shrinkwrap -deadargelim -gvn-hoist -barrier -barrier -guard-widening -loop-versioning-licm -lowerinvoke -argpromotion -mem2reg -instcombine -strip-dead-prototypes -loop-idiom -globalopt -attributor -aggressive-instcombine -bdce -consthoist -partially-inline-libcalls -loop-data-prefetch -mem2reg -loop-reduce -loop-versioning-licm -instcombine -slsr -lower-expect -inline -loop-load-elim -simple-loop-unswitch -simplifycfg -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/adpcm,1.005586592178771,61.90937900543213,opt -instcombine -loop-fusion -ipsccp -slsr -functionattrs -aggressive-instcombine -tailcallelim -nary-reassociate -guard-widening -loop-interchange -die -aggressive-instcombine -lower-widenable-condition -ee-instrument -dse -rpo-functionattrs -jump-threading -loop-simplify -canonicalize-aliases -alignment-from-assumptions -alignment-from-assumptions -constprop -libcalls-shrinkwrap -irce -load-store-vectorizer -separate-const-offset-from-gep -ee-instrument -loop-reduce -post-inline-ee-instrument -lower-widenable-condition -loop-deletion -licm -post-inline-ee-instrument -scalarizer -globalsplit -mergereturn -mem2reg -loop-sink -dce -licm -memcpyopt -load-store-vectorizer -barrier -called-value-propagation -memcpyopt -mergereturn -early-cse-memssa -mldst-motion -lower-guard-intrinsic -loop-load-elim -ee-instrument -load-store-vectorizer -loop-distribute -ipconstprop -deadargelim -gvn-hoist -inject-tli-mappings -deadargelim -mergeicmps -newgvn -loop-predication -loop-unroll-and-jam -guard-widening -ipconstprop -loop-reroll -loop-simplify -lower-constant-intrinsics -break-crit-edges -speculative-execution -break-crit-edges -loop-idiom -lower-expect -lowerswitch -scalarizer -ipconstprop -aggressive-instcombine -mldst-motion -mergefunc -ee-instrument -loop-reduce -always-inline -inferattrs -loop-instsimplify -barrier -tailcallelim -loop-guard-widening -gvn-hoist -ee-instrument -lcssa -tailcallelim -simplifycfg -irce -loop-predication -slsr -indvars -loweratomic -slsr -mergereturn -ipconstprop -sink -mem2reg -loop-load-elim -cross-dso-cfi -inferattrs -dse -loop-simplifycfg -loop-instsimplify -dse -inline -newgvn -lcssa -loop-unroll -loop-simplify -loop-data-prefetch -loop-unroll-and-jam -guard-widening -insert-gcov-profiling -licm -canonicalize-aliases -sancov -instsimplify -lower-matrix-intrinsics -name-anon-globals -newgvn -rpo-functionattrs -licm -coro-split -redundant-dbg-inst-elim -instnamer -loop-interchange -loop-interchange -lower-constant-intrinsics -loop-predication -loop-versioning-licm -gvn -alignment-from-assumptions -instcombine -name-anon-globals -insert-gcov-profiling -lowerswitch -forceattrs -lower-constant-intrinsics -speculative-execution -bdce -sroa -mergeicmps -tailcallelim -coro-elide -coro-elide -simplifycfg -mldst-motion -break-crit-edges -gvn-hoist -tailcallelim -loop-predication -lower-expect -loop-fusion -globaldce -irce -coro-early -pgo-memop-opt -simple-loop-unswitch -loop-unswitch -instnamer -loop-unroll-and-jam -bdce -loop-interchange -lower-constant-intrinsics -loop-simplifycfg -forceattrs -globalopt -globaldce -memcpyopt -loop-sink -sancov -loop-sink -loop-idiom -gvn -newgvn -tailcallelim -argpromotion -redundant-dbg-inst-elim -loop-distribute -inject-tli-mappings -jump-threading input.bc -o output.bc +benchmark://cbench-v1/adpcm,1.005586592178771,62.016544580459595,opt -mem2reg -newgvn -loop-unroll -ipconstprop -adce -strip-dead-prototypes -loop-deletion -inferattrs -strip-dead-prototypes -speculative-execution -reg2mem -forceattrs -aggressive-instcombine -mldst-motion -lower-expect -loop-versioning-licm -lower-matrix-intrinsics -pgo-memop-opt -loop-predication -irce -loop-interchange -loop-deletion -loop-distribute -coro-early -post-inline-ee-instrument -partial-inliner -forceattrs -loop-unswitch -loop-reduce -coro-elide -loop-idiom -correlated-propagation -post-inline-ee-instrument -slsr -loop-unroll -strip-nondebug -loop-deletion -lower-matrix-intrinsics -loop-versioning -alignment-from-assumptions -inject-tli-mappings -inject-tli-mappings -alignment-from-assumptions -lower-constant-intrinsics -rewrite-statepoints-for-gc -nary-reassociate -instnamer -flattencfg -hotcoldsplit -lower-expect -slp-vectorizer -always-inline -pgo-memop-opt -loop-sink -loop-sink -loop-load-elim -loop-reroll -insert-gcov-profiling -elim-avail-extern -memcpyopt -sroa -constmerge -instsimplify -reassociate -strip-nondebug -lcssa -globalsplit -ipconstprop -inject-tli-mappings -constprop -prune-eh -loop-vectorize -coro-early -ipconstprop -hotcoldsplit -strip-nondebug -lowerswitch -die -lower-matrix-intrinsics -aggressive-instcombine -lowerswitch -loop-simplifycfg -prune-eh -slp-vectorizer -called-value-propagation -correlated-propagation -rpo-functionattrs -functionattrs -loop-deletion -slsr -ee-instrument -loop-simplifycfg -early-cse-memssa -slsr -loop-unroll -simplifycfg -guard-widening -ee-instrument -slp-vectorizer -irce -strip -instsimplify -loop-interchange -load-store-vectorizer -ipsccp -globaldce -loop-predication -separate-const-offset-from-gep -gvn -loop-simplifycfg -loop-predication -mldst-motion -strip -early-cse-memssa -lower-widenable-condition -loop-predication -sink -instcombine -consthoist -instnamer -loop-interchange -loop-unswitch -loop-fusion -scalarizer -mldst-motion -coro-split -loop-data-prefetch -loweratomic -loop-unroll -sroa -loop-predication -alignment-from-assumptions -mergefunc -separate-const-offset-from-gep -simple-loop-unswitch -gvn -dce -consthoist -lowerswitch -reassociate -loop-instsimplify -partially-inline-libcalls -loop-reduce -barrier -lower-matrix-intrinsics -sink -sccp -tailcallelim -aggressive-instcombine -newgvn -slsr -redundant-dbg-inst-elim -lower-widenable-condition -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/adpcm,1.0055865921787712,61.891133546829224,opt -callsite-splitting -loop-unswitch -loop-interchange -gvn-hoist -deadargelim -mergefunc -barrier -attributor -loop-data-prefetch -inline -hotcoldsplit -sroa -callsite-splitting -jump-threading -separate-const-offset-from-gep -loop-simplifycfg -callsite-splitting -loop-instsimplify -lcssa -dse -barrier -loop-data-prefetch -lower-expect -lowerinvoke -name-anon-globals -rewrite-statepoints-for-gc -name-anon-globals -loop-simplifycfg -forceattrs -mergefunc -pgo-memop-opt -sccp -loop-unroll-and-jam -lower-expect -lowerinvoke -reassociate -loop-predication -gvn-hoist -loop-reroll -break-crit-edges -nary-reassociate -jump-threading -slsr -simplifycfg -globaldce -globalopt -loop-vectorize -forceattrs -loop-versioning -reassociate -loop-data-prefetch -loop-vectorize -prune-eh -lower-widenable-condition -coro-split -sancov -loop-versioning-licm -instsimplify -alignment-from-assumptions -lower-guard-intrinsic -constprop -sroa -elim-avail-extern -constmerge -elim-avail-extern -break-crit-edges -coro-cleanup -sroa -coro-early -sccp -load-store-vectorizer -add-discriminators -instcombine -name-anon-globals -scalarizer -loop-sink -bdce -insert-gcov-profiling -loop-vectorize -loop-deletion -post-inline-ee-instrument -loop-predication -infer-address-spaces -libcalls-shrinkwrap -prune-eh -dce -die -slp-vectorizer -loop-interchange -instcombine -always-inline -partial-inliner -loop-unroll -correlated-propagation -inject-tli-mappings -consthoist -lcssa -redundant-dbg-inst-elim -mergeicmps -insert-gcov-profiling -constprop -constprop -lower-widenable-condition -barrier -globalsplit -globalopt -canonicalize-aliases -float2int -loop-unroll -float2int -adce -dse -lowerinvoke -partial-inliner -inline -sink -redundant-dbg-inst-elim -die -loop-unswitch -div-rem-pairs -die -gvn-hoist -redundant-dbg-inst-elim -globaldce -lower-widenable-condition -newgvn -globaldce -lowerswitch -lower-expect -post-inline-ee-instrument -canonicalize-aliases -gvn-hoist -loop-idiom -lowerinvoke -div-rem-pairs -canonicalize-aliases -alignment-from-assumptions -elim-avail-extern -canonicalize-aliases -called-value-propagation -simplifycfg -rpo-functionattrs -lower-guard-intrinsic -loop-distribute -adce -nary-reassociate -loop-vectorize -separate-const-offset-from-gep -loop-versioning-licm -loop-simplifycfg -newgvn -name-anon-globals -strip-dead-prototypes -constprop -dse -cross-dso-cfi -lowerinvoke -deadargelim -loop-versioning -prune-eh -loop-guard-widening -separate-const-offset-from-gep -loop-predication -simple-loop-unswitch -rewrite-statepoints-for-gc -alignment-from-assumptions -sink -loop-versioning -loop-simplifycfg -licm -float2int -ee-instrument -inferattrs -elim-avail-extern -coro-elide -redundant-dbg-inst-elim -loop-reroll -instnamer -correlated-propagation -instcombine input.bc -o output.bc +benchmark://cbench-v1/adpcm,1.0055865921787712,61.928428411483765,opt -instsimplify -functionattrs -loop-unswitch -loop-simplifycfg -name-anon-globals -name-anon-globals -barrier -loop-distribute -sroa -loop-unswitch -insert-gcov-profiling -loop-unroll-and-jam -insert-gcov-profiling -callsite-splitting -rpo-functionattrs -called-value-propagation -instsimplify -memcpyopt -dce -globaldce -loop-deletion -loop-guard-widening -simple-loop-unswitch -die -instsimplify -alignment-from-assumptions -argpromotion -ipsccp -callsite-splitting -slsr -add-discriminators -lower-expect -loweratomic -memcpyopt -strip-nondebug -ee-instrument -newgvn -strip -constmerge -loop-load-elim -lower-guard-intrinsic -redundant-dbg-inst-elim -consthoist -partially-inline-libcalls -instnamer -reassociate -sancov -inline -alignment-from-assumptions -cross-dso-cfi -bdce -globalsplit -deadargelim -libcalls-shrinkwrap -strip-nondebug -speculative-execution -pgo-memop-opt -nary-reassociate -partial-inliner -loop-versioning-licm -memcpyopt -globalopt -loop-reroll -mem2reg -lcssa -instnamer -coro-elide -rpo-functionattrs -memcpyopt -alignment-from-assumptions -jump-threading -constprop -dce -sroa -lowerinvoke -always-inline -slp-vectorizer -strip -loop-sink -mergefunc -constmerge -consthoist -mergefunc -break-crit-edges -functionattrs -loop-guard-widening -loop-fusion -attributor -jump-threading -partially-inline-libcalls -mergeicmps -prune-eh -reassociate -loop-guard-widening -adce -simplifycfg -tailcallelim -flattencfg -called-value-propagation -forceattrs -memcpyopt -jump-threading -aggressive-instcombine -mldst-motion -hotcoldsplit -forceattrs -constmerge -libcalls-shrinkwrap -flattencfg -break-crit-edges -loop-unroll -sroa -loop-predication -ipsccp -loop-reroll -infer-address-spaces -slp-vectorizer -called-value-propagation -loop-simplifycfg -scalarizer -inline -loop-deletion -reg2mem -loop-instsimplify -sroa -redundant-dbg-inst-elim -early-cse-memssa -inline -prune-eh -scalarizer -simplifycfg -loop-versioning -bdce -correlated-propagation -alignment-from-assumptions -irce -elim-avail-extern -prune-eh -alignment-from-assumptions -nary-reassociate -inline -barrier -loop-instsimplify -strip-nondebug -loop-versioning-licm -rewrite-statepoints-for-gc -gvn -loop-deletion -lower-guard-intrinsic -early-cse-memssa -loop-interchange -loop-unswitch -elim-avail-extern -simplifycfg -loop-reroll -loop-reroll -loop-simplify -slsr -add-discriminators -loop-versioning-licm -instcombine -sink -ipsccp -mergeicmps -mergeicmps -barrier -always-inline -break-crit-edges -sink -lower-guard-intrinsic -prune-eh -loop-unroll -deadargelim -insert-gcov-profiling -globaldce -early-cse-memssa -tailcallelim -dce -loop-fusion -loop-simplify -reg2mem -globalsplit -loop-data-prefetch -loop-vectorize -jump-threading -rewrite-statepoints-for-gc -loop-idiom -prune-eh -loop-unroll -loop-simplifycfg -early-cse-memssa -gvn-hoist -loop-unroll-and-jam -loop-simplify -slp-vectorizer -lowerinvoke -partial-inliner -gvn-hoist -float2int -strip-debug-declare -load-store-vectorizer -sroa -break-crit-edges -rewrite-statepoints-for-gc -pgo-memop-opt -newgvn -memcpyopt -separate-const-offset-from-gep -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/adpcm,1.0055865921787712,61.9604275226593,opt -add-discriminators -indvars -speculative-execution -memcpyopt -coro-cleanup -licm -inject-tli-mappings -constmerge -slp-vectorizer -alignment-from-assumptions -barrier -deadargelim -loop-guard-widening -loop-unswitch -barrier -loop-fusion -strip -loop-unroll -loop-sink -simplifycfg -barrier -lowerinvoke -partial-inliner -loop-distribute -ee-instrument -pgo-memop-opt -coro-elide -inline -mergeicmps -strip-dead-prototypes -lcssa -globalopt -inferattrs -sroa -speculative-execution -memcpyopt -loop-unroll-and-jam -dce -ipsccp -loop-distribute -lowerinvoke -loop-interchange -correlated-propagation -inject-tli-mappings -inline -loop-data-prefetch -partial-inliner -loop-vectorize -ee-instrument -cross-dso-cfi -constprop -strip-dead-prototypes -separate-const-offset-from-gep -infer-address-spaces -div-rem-pairs -constmerge -load-store-vectorizer -called-value-propagation -rewrite-statepoints-for-gc -flattencfg -instcombine -libcalls-shrinkwrap -partially-inline-libcalls -slsr -always-inline -sancov -gvn-hoist -loop-vectorize -flattencfg -sccp -ee-instrument -callsite-splitting -licm -nary-reassociate -barrier -strip-debug-declare -deadargelim -irce -coro-cleanup -lower-matrix-intrinsics -alignment-from-assumptions -alignment-from-assumptions -loop-load-elim -dse -lowerswitch -inline -mldst-motion -coro-cleanup -always-inline -loop-reduce -loop-sink -globalopt -strip-dead-prototypes -bdce -functionattrs -jump-threading -correlated-propagation -barrier -sccp -load-store-vectorizer -loop-guard-widening -loop-reroll -lower-widenable-condition -insert-gcov-profiling -mem2reg -coro-split -loop-deletion -loop-guard-widening -coro-early -loop-reduce -speculative-execution -lower-matrix-intrinsics -correlated-propagation -reassociate -loweratomic -guard-widening -pgo-memop-opt -separate-const-offset-from-gep -argpromotion -slp-vectorizer -aggressive-instcombine -loop-interchange -attributor -speculative-execution -coro-split -tailcallelim -loop-simplifycfg -barrier -scalarizer -lower-constant-intrinsics -coro-cleanup -die -inferattrs -instsimplify -loop-simplifycfg -irce -loweratomic -slsr -gvn input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0044247787610618,61.726380825042725,opt -reassociate -lowerswitch -reg2mem -instnamer -guard-widening -loop-versioning -elim-avail-extern -indvars -rewrite-statepoints-for-gc -dse -reassociate -hotcoldsplit -dse -div-rem-pairs -loop-deletion -functionattrs -sccp -sccp -separate-const-offset-from-gep -lowerswitch -always-inline -dse -slsr -dse -name-anon-globals -strip -strip-debug-declare -indvars -post-inline-ee-instrument -sancov -load-store-vectorizer -cross-dso-cfi -correlated-propagation -post-inline-ee-instrument -newgvn -flattencfg -deadargelim -dse -flattencfg -instsimplify -sroa -adce -globaldce -constprop -indvars -nary-reassociate -lower-expect -instcombine -rpo-functionattrs -ipconstprop -dce -loop-simplifycfg -flattencfg -memcpyopt -tailcallelim -loop-distribute -loop-reduce -attributor -jump-threading -slp-vectorizer -lower-widenable-condition -early-cse-memssa -ee-instrument -loop-deletion -lcssa -add-discriminators -globalsplit -strip-dead-prototypes -die -mem2reg -simple-loop-unswitch -gvn-hoist -aggressive-instcombine -loop-instsimplify -guard-widening -inline -strip-dead-prototypes -loweratomic -partially-inline-libcalls -instsimplify -lower-expect -mem2reg -slsr -correlated-propagation -loop-versioning-licm -name-anon-globals -div-rem-pairs -mergefunc -gvn -loop-interchange -loop-unroll-and-jam -separate-const-offset-from-gep -loop-simplify -lower-guard-intrinsic -rewrite-statepoints-for-gc -libcalls-shrinkwrap -instcombine -forceattrs -newgvn -constprop -strip-nondebug -early-cse-memssa -loop-vectorize -dce -insert-gcov-profiling -always-inline -gvn -loop-guard-widening -loop-load-elim -loop-vectorize -instsimplify -ipsccp -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0066371681415929,61.671980142593384,opt -insert-gcov-profiling -gvn-hoist -callsite-splitting -partially-inline-libcalls -loop-idiom -ipconstprop -loop-load-elim -memcpyopt -partially-inline-libcalls -ee-instrument -argpromotion -reassociate -loop-unroll-and-jam -loop-instsimplify -loop-simplify -forceattrs -ipsccp -elim-avail-extern -dse -jump-threading -ipsccp -ipsccp -irce -lower-expect -argpromotion -irce -insert-gcov-profiling -die -sroa -newgvn -loop-versioning-licm -correlated-propagation -loop-deletion -early-cse-memssa -loop-data-prefetch -loop-unroll-and-jam -strip-nondebug -newgvn -lcssa -constprop -strip-dead-prototypes -lower-guard-intrinsic -always-inline -rpo-functionattrs -dse -loop-vectorize -name-anon-globals -slp-vectorizer -sink -globaldce -loop-versioning -flattencfg -sccp -nary-reassociate -loop-instsimplify -sccp -called-value-propagation -libcalls-shrinkwrap -gvn-hoist -nary-reassociate -loop-sink -dce -called-value-propagation -speculative-execution -globalopt -mergereturn -early-cse-memssa -pgo-memop-opt -hotcoldsplit -mldst-motion -constmerge -name-anon-globals -rewrite-statepoints-for-gc -loop-unroll -lowerinvoke -mldst-motion -rpo-functionattrs -correlated-propagation -irce -lower-expect -early-cse-memssa -rpo-functionattrs -instcombine -dce -argpromotion -sancov -attributor -ipconstprop -partial-inliner -mergefunc -add-discriminators -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0066371681415929,61.696775674819946,opt -lowerswitch -early-cse-memssa -lower-widenable-condition -lower-widenable-condition -aggressive-instcombine -div-rem-pairs -globalopt -loop-reduce -loop-idiom -bdce -float2int -elim-avail-extern -called-value-propagation -tailcallelim -inline -globalopt -bdce -loop-simplify -speculative-execution -redundant-dbg-inst-elim -lowerswitch -strip -loop-unroll-and-jam -globalopt -instcombine -constprop -strip-nondebug -argpromotion -indvars -ipconstprop -ipsccp -loop-reduce -globalsplit -libcalls-shrinkwrap -strip-dead-prototypes -loop-distribute -canonicalize-aliases -nary-reassociate -sroa -nary-reassociate -newgvn -sink -memcpyopt -loop-interchange -coro-elide -memcpyopt -attributor -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0088495575221237,61.81148862838745,opt -partially-inline-libcalls -rpo-functionattrs -mergereturn -rpo-functionattrs -globaldce -name-anon-globals -slp-vectorizer -partially-inline-libcalls -reassociate -lower-expect -dse -break-crit-edges -loop-simplify -inject-tli-mappings -loop-simplify -strip-nondebug -lower-widenable-condition -constprop -globalopt -indvars -lcssa -loop-versioning-licm -globalsplit -strip-nondebug -loop-fusion -strip-nondebug -rpo-functionattrs -loop-versioning -loop-simplify -reg2mem -break-crit-edges -dce -attributor -loop-versioning-licm -strip-debug-declare -instsimplify -rewrite-statepoints-for-gc -constmerge -slp-vectorizer -loop-distribute -aggressive-instcombine -strip-nondebug -strip-debug-declare -partial-inliner -mergeicmps -lower-expect -rewrite-statepoints-for-gc -simplifycfg -mergeicmps -flattencfg -redundant-dbg-inst-elim -adce -loop-guard-widening -early-cse-memssa -sroa -loop-deletion -loop-simplify -gvn-hoist -lower-guard-intrinsic -loop-reroll -loop-fusion -constmerge -coro-early -pgo-memop-opt -instcombine -coro-cleanup -coro-split -pgo-memop-opt -tailcallelim -prune-eh -lower-constant-intrinsics -instnamer -loop-reroll -jump-threading -tailcallelim -alignment-from-assumptions -partially-inline-libcalls -coro-split -lcssa -strip-nondebug -deadargelim -adce -alignment-from-assumptions -slp-vectorizer -globalopt -always-inline -elim-avail-extern -gvn -simplifycfg -name-anon-globals -jump-threading -loop-sink -lower-expect -loop-versioning -pgo-memop-opt -irce -flattencfg -argpromotion -post-inline-ee-instrument -loop-fusion -loop-simplify -simplifycfg -sink -die -nary-reassociate -lower-matrix-intrinsics -sroa -partially-inline-libcalls -functionattrs -newgvn input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.008849557522124,61.73530960083008,opt -sccp -licm -reg2mem -coro-split -simplifycfg -loop-unroll -dse -lowerswitch -elim-avail-extern -globalopt -post-inline-ee-instrument -simplifycfg -argpromotion -slsr -forceattrs -constmerge -guard-widening -loop-data-prefetch -loop-instsimplify -simplifycfg -nary-reassociate -speculative-execution -always-inline -speculative-execution -inject-tli-mappings -sancov -simplifycfg -consthoist -rpo-functionattrs -callsite-splitting -lower-guard-intrinsic -loop-sink -coro-split -constmerge -loop-interchange -guard-widening -lcssa -loop-interchange -simplifycfg -strip-nondebug -loop-predication -deadargelim -newgvn -add-discriminators -attributor -loop-guard-widening -coro-cleanup -inferattrs -globalopt -partial-inliner -coro-cleanup -alignment-from-assumptions -insert-gcov-profiling -strip -simplifycfg -loop-guard-widening -loop-instsimplify -name-anon-globals -deadargelim -lcssa -mergeicmps -hotcoldsplit -mem2reg -forceattrs -rewrite-statepoints-for-gc -indvars -infer-address-spaces -callsite-splitting -sccp -called-value-propagation -globaldce -coro-cleanup -dse -elim-avail-extern -name-anon-globals -lower-matrix-intrinsics -inject-tli-mappings -flattencfg -attributor -hotcoldsplit -guard-widening -strip-nondebug -coro-split -cross-dso-cfi -loop-versioning-licm -loop-simplifycfg -sink -float2int -loop-sink -loop-unroll-and-jam -insert-gcov-profiling -licm -reg2mem -loop-deletion -gvn-hoist -sancov -loop-vectorize -strip-dead-prototypes -post-inline-ee-instrument -simplifycfg -loop-unroll-and-jam -lower-guard-intrinsic -licm -callsite-splitting -partial-inliner -bdce -instsimplify -loop-deletion -correlated-propagation -lowerswitch -mem2reg -post-inline-ee-instrument -inject-tli-mappings -loop-idiom -loop-unroll-and-jam -reg2mem -lowerinvoke -barrier -break-crit-edges -scalarizer -slp-vectorizer -callsite-splitting -memcpyopt -loop-unroll-and-jam -forceattrs -guard-widening -globalsplit -globalsplit -loop-simplify -guard-widening -gvn-hoist -instsimplify -insert-gcov-profiling -loop-fusion -loop-data-prefetch -inject-tli-mappings -loop-fusion -loop-versioning -rewrite-statepoints-for-gc -loop-interchange -aggressive-instcombine -strip-nondebug -correlated-propagation -mem2reg -reassociate -name-anon-globals -sancov -add-discriminators -slp-vectorizer -libcalls-shrinkwrap -instcombine -prune-eh -loop-data-prefetch -consthoist -mergereturn -barrier -mergeicmps -name-anon-globals -jump-threading -sroa -instnamer -loop-predication -lowerswitch -mergefunc -separate-const-offset-from-gep -constprop -loop-guard-widening -barrier -gvn-hoist -loop-idiom -loop-data-prefetch -aggressive-instcombine -elim-avail-extern -insert-gcov-profiling -coro-split -slsr -name-anon-globals -constmerge -lower-matrix-intrinsics -instsimplify -slsr -sink -inferattrs -rpo-functionattrs -instcombine -post-inline-ee-instrument -loop-idiom -loop-reroll -mergeicmps -loop-vectorize -forceattrs -float2int -loop-data-prefetch -instcombine -speculative-execution -pgo-memop-opt -globaldce -always-inline -functionattrs -loop-fusion -partial-inliner -ipsccp -dce -called-value-propagation -deadargelim -slsr -jump-threading -lower-expect -instnamer -lowerswitch -loop-fusion -adce -forceattrs -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.008849557522124,61.8548686504364,opt -lower-widenable-condition -flattencfg -strip-nondebug -loop-distribute -lowerswitch -rewrite-statepoints-for-gc -loop-load-elim -loop-predication -inject-tli-mappings -partial-inliner -div-rem-pairs -constmerge -coro-early -insert-gcov-profiling -name-anon-globals -callsite-splitting -gvn-hoist -lowerinvoke -early-cse-memssa -jump-threading -strip-dead-prototypes -mergereturn -adce -attributor -consthoist -coro-elide -coro-elide -loop-distribute -memcpyopt -strip-dead-prototypes -constmerge -name-anon-globals -callsite-splitting -always-inline -canonicalize-aliases -loop-sink -dse -adce -mergeicmps -loop-predication -lower-expect -loop-data-prefetch -break-crit-edges -barrier -libcalls-shrinkwrap -consthoist -loop-idiom -forceattrs -inline -adce -coro-elide -mergeicmps -aggressive-instcombine -lowerswitch -early-cse-memssa -inferattrs -simplifycfg -float2int -mergeicmps -early-cse-memssa -coro-early -constmerge -lower-constant-intrinsics -aggressive-instcombine -separate-const-offset-from-gep -strip-dead-prototypes -lower-constant-intrinsics -jump-threading -memcpyopt -strip-nondebug -loop-reduce -loop-deletion -mergeicmps -mldst-motion -sroa -strip-nondebug -pgo-memop-opt -indvars -lower-guard-intrinsic -canonicalize-aliases -constprop -rewrite-statepoints-for-gc -irce -indvars -licm -pgo-memop-opt -separate-const-offset-from-gep -rewrite-statepoints-for-gc -instcombine -coro-early -cross-dso-cfi -div-rem-pairs -loop-vectorize -instcombine -die -attributor -loop-unroll-and-jam -always-inline -jump-threading -licm -loop-simplify -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.008849557522124,61.99087977409363,opt -constmerge -die -licm -pgo-memop-opt -loop-distribute -scalarizer -infer-address-spaces -libcalls-shrinkwrap -alignment-from-assumptions -callsite-splitting -post-inline-ee-instrument -newgvn -globalsplit -barrier -reassociate -elim-avail-extern -ipconstprop -licm -prune-eh -globaldce -partial-inliner -deadargelim -constmerge -functionattrs -inferattrs -coro-early -loop-simplify -irce -indvars -strip-dead-prototypes -mldst-motion -float2int -aggressive-instcombine -called-value-propagation -argpromotion -loop-predication -coro-early -redundant-dbg-inst-elim -loop-unroll -loop-instsimplify -sink -hotcoldsplit -bdce -canonicalize-aliases -insert-gcov-profiling -coro-cleanup -globaldce -guard-widening -callsite-splitting -slsr -loop-unroll-and-jam -loop-predication -constprop -loop-predication -loop-versioning -deadargelim -slsr -loop-simplifycfg -guard-widening -guard-widening -jump-threading -loop-deletion -slp-vectorizer -ee-instrument -speculative-execution -loop-versioning -mergeicmps -coro-split -consthoist -coro-early -functionattrs -lower-expect -loop-simplifycfg -sroa -loop-load-elim -speculative-execution -instcombine -bdce -redundant-dbg-inst-elim -simplifycfg -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0110619469026547,61.65555500984192,opt -early-cse-memssa -coro-early -elim-avail-extern -rpo-functionattrs -coro-early -separate-const-offset-from-gep -globalopt -loop-reroll -mergeicmps -globalopt -loop-predication -loop-interchange -mem2reg -strip-debug-declare -simple-loop-unswitch -mergeicmps -early-cse-memssa -ipsccp -jump-threading -nary-reassociate -canonicalize-aliases -insert-gcov-profiling -instsimplify -callsite-splitting -loop-idiom -strip -loop-deletion -strip-debug-declare -aggressive-instcombine -bdce -float2int -inject-tli-mappings -alignment-from-assumptions -redundant-dbg-inst-elim -pgo-memop-opt -separate-const-offset-from-gep -rewrite-statepoints-for-gc -guard-widening -indvars -insert-gcov-profiling -jump-threading -mergereturn -dse -globaldce -loop-unroll -canonicalize-aliases -gvn -rpo-functionattrs -loop-fusion -partially-inline-libcalls -partial-inliner -lower-guard-intrinsic -tailcallelim -loop-versioning -insert-gcov-profiling -attributor -coro-elide -name-anon-globals -mergefunc -pgo-memop-opt -adce -speculative-execution -instnamer -canonicalize-aliases -loop-deletion -instcombine -canonicalize-aliases -strip-dead-prototypes -lowerswitch -redundant-dbg-inst-elim -loop-fusion -dse -coro-split -tailcallelim -slsr -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.011061946902655,61.76593828201294,opt -inline -partial-inliner -memcpyopt -strip-dead-prototypes -lowerinvoke -correlated-propagation -lcssa -memcpyopt -globalopt -sink -simplifycfg -sancov -globalsplit -callsite-splitting -loop-reduce -deadargelim -sink -constmerge -break-crit-edges -lower-matrix-intrinsics -cross-dso-cfi -adce -sroa -deadargelim -consthoist -tailcallelim -mergeicmps -slp-vectorizer -loop-guard-widening -lower-guard-intrinsic -instcombine -loop-unroll -dse -coro-elide -globaldce -globalopt -correlated-propagation -memcpyopt -globaldce -early-cse-memssa -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/bitcount,1.0176991150442478,61.881062746047974,opt -loop-simplifycfg -strip-debug-declare -cross-dso-cfi -mem2reg -loop-guard-widening -canonicalize-aliases -loop-data-prefetch -loop-interchange -inferattrs -ipconstprop -loop-versioning-licm -loop-unswitch -lower-constant-intrinsics -simplifycfg -bdce -loop-reduce -partially-inline-libcalls -mem2reg -jump-threading -lcssa -loop-interchange -scalarizer -coro-split -alignment-from-assumptions -mergereturn -loop-unswitch -correlated-propagation -loop-vectorize -memcpyopt -mem2reg -post-inline-ee-instrument -coro-elide -mldst-motion -loop-unroll -prune-eh -tailcallelim -loop-simplify -argpromotion -indvars -scalarizer -sancov -partially-inline-libcalls -post-inline-ee-instrument -callsite-splitting -instcombine -deadargelim -ipsccp -loop-fusion -inline -bdce -libcalls-shrinkwrap -rewrite-statepoints-for-gc -partial-inliner -slsr -coro-early -barrier -jump-threading -mergefunc -partially-inline-libcalls -loop-idiom -adce -loop-predication -memcpyopt -correlated-propagation -early-cse-memssa -functionattrs -coro-elide -globaldce -rewrite-statepoints-for-gc -lower-constant-intrinsics -nary-reassociate -strip-debug-declare -callsite-splitting -instcombine -insert-gcov-profiling -globaldce -licm -loop-instsimplify -ipsccp -canonicalize-aliases -loop-reduce -instnamer -loop-simplify -instcombine -indvars -aggressive-instcombine -float2int -mem2reg -aggressive-instcombine -strip-debug-declare -attributor -irce -strip-debug-declare -loop-load-elim -loop-deletion -mldst-motion -lower-expect -strip-nondebug -simple-loop-unswitch -libcalls-shrinkwrap -loop-interchange -sancov -globalopt -sroa -lower-constant-intrinsics -globalopt -libcalls-shrinkwrap -globalopt -cross-dso-cfi -instcombine -sancov -instcombine -lower-matrix-intrinsics -loop-unroll -lowerinvoke -loop-simplify -aggressive-instcombine -nary-reassociate -ipsccp -loop-predication -partially-inline-libcalls -memcpyopt -loop-predication -post-inline-ee-instrument -loop-unswitch -consthoist -ipsccp -consthoist -coro-early -aggressive-instcombine -loop-deletion -licm -nary-reassociate -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0549618320610687,61.924893379211426,opt -loop-simplify -rewrite-statepoints-for-gc -coro-early -jump-threading -break-crit-edges -ipconstprop -globalopt -simple-loop-unswitch -prune-eh -mem2reg -barrier -loop-versioning-licm -rpo-functionattrs -loop-simplifycfg -newgvn -adce -mergeicmps -tailcallelim -redundant-dbg-inst-elim -post-inline-ee-instrument -constmerge -flattencfg -partially-inline-libcalls -attributor -lower-widenable-condition -loop-predication -nary-reassociate -loop-unroll -rpo-functionattrs -simple-loop-unswitch -callsite-splitting -constmerge -instcombine -newgvn -lower-constant-intrinsics -loop-sink -lower-guard-intrinsic -loop-sink -lower-expect -div-rem-pairs -loop-instsimplify -loop-reroll -post-inline-ee-instrument -flattencfg -loop-unroll-and-jam -break-crit-edges -consthoist -strip-dead-prototypes -name-anon-globals -sroa -elim-avail-extern -loop-data-prefetch -loop-vectorize -pgo-memop-opt -indvars -inline -insert-gcov-profiling -strip-nondebug -infer-address-spaces -loop-predication -partial-inliner -loop-predication -redundant-dbg-inst-elim -loop-reroll -coro-early -irce -strip -lower-expect -lower-constant-intrinsics -loop-interchange -speculative-execution -nary-reassociate -add-discriminators -load-store-vectorizer -loop-guard-widening -instnamer -callsite-splitting -name-anon-globals -loop-data-prefetch -coro-split -loop-load-elim -loop-reroll -post-inline-ee-instrument -attributor -always-inline -barrier -gvn-hoist -nary-reassociate -attributor -aggressive-instcombine -slp-vectorizer -mergefunc -libcalls-shrinkwrap -aggressive-instcombine -instcombine -lower-expect -add-discriminators -load-store-vectorizer -argpromotion -loop-unswitch -simple-loop-unswitch -loop-simplifycfg -canonicalize-aliases -gvn-hoist -lowerinvoke -loop-idiom -loop-predication -add-discriminators -loop-simplify -mergeicmps -indvars -coro-split -callsite-splitting -loop-simplify -libcalls-shrinkwrap -always-inline -argpromotion -div-rem-pairs -sancov -ee-instrument -loop-instsimplify -strip-nondebug -irce -load-store-vectorizer -deadargelim -reassociate -prune-eh -barrier -correlated-propagation -name-anon-globals -div-rem-pairs -redundant-dbg-inst-elim -load-store-vectorizer -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.055470737913486,61.863592863082886,opt -mldst-motion -argpromotion -libcalls-shrinkwrap -speculative-execution -lower-matrix-intrinsics -strip-dead-prototypes -redundant-dbg-inst-elim -loop-deletion -prune-eh -ipconstprop -pgo-memop-opt -simplifycfg -die -canonicalize-aliases -reassociate -scalarizer -mergeicmps -lower-guard-intrinsic -mem2reg -loop-fusion -rewrite-statepoints-for-gc -hotcoldsplit -loop-vectorize -strip-dead-prototypes -lowerinvoke -slp-vectorizer -lcssa -name-anon-globals -instnamer -guard-widening -reassociate -partial-inliner -rpo-functionattrs -barrier -inferattrs -strip -post-inline-ee-instrument -coro-early -ipconstprop -barrier -loop-reroll -instcombine -barrier -tailcallelim -ipconstprop -loop-data-prefetch -mem2reg -div-rem-pairs -lower-matrix-intrinsics -slp-vectorizer -mldst-motion -gvn-hoist -name-anon-globals -loop-fusion -dse -simple-loop-unswitch -lower-matrix-intrinsics -coro-elide -gvn -lower-widenable-condition -load-store-vectorizer -slp-vectorizer -tailcallelim -inferattrs -loop-unswitch -argpromotion -coro-early -loop-sink -reassociate -early-cse-memssa -loop-sink -add-discriminators -dse -ee-instrument -rewrite-statepoints-for-gc -strip -mergeicmps -early-cse-memssa -reassociate -loop-rotate -mergefunc -indvars -instnamer -elim-avail-extern -ipconstprop -tailcallelim -gvn-hoist -canonicalize-aliases -cross-dso-cfi -infer-address-spaces -constprop -nary-reassociate -aggressive-instcombine -mldst-motion -adce -instsimplify -sancov -loop-rotate -sancov -loop-vectorize -loop-unroll-and-jam -constmerge -partially-inline-libcalls -slsr -functionattrs -cross-dso-cfi -dse -loop-unswitch -loop-predication -separate-const-offset-from-gep -loop-rotate -coro-early -redundant-dbg-inst-elim -hotcoldsplit -simplifycfg -elim-avail-extern -lower-constant-intrinsics -lowerinvoke -argpromotion -slsr -loop-versioning-licm -redundant-dbg-inst-elim -nary-reassociate -loop-sink -lowerinvoke -ipconstprop -aggressive-instcombine -loop-reduce -post-inline-ee-instrument -indvars -add-discriminators -instcombine -indvars -instnamer -loop-interchange -loop-load-elim -globaldce -canonicalize-aliases -called-value-propagation -loop-unroll-and-jam -strip -div-rem-pairs -strip -jump-threading -hotcoldsplit -globalopt -inline -elim-avail-extern -cross-dso-cfi -early-cse-memssa -tailcallelim -coro-early -called-value-propagation -ee-instrument -instnamer -forceattrs -globaldce -adce -strip-debug-declare -mergefunc input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0569974554707382,62.10315656661987,opt -flattencfg -prune-eh -loweratomic -mem2reg -loop-distribute -instnamer -mergeicmps -argpromotion -loop-load-elim -lower-matrix-intrinsics -div-rem-pairs -loop-unroll-and-jam -instsimplify -constmerge -partial-inliner -coro-early -lower-expect -tailcallelim -globalopt -hotcoldsplit -instcombine -lower-expect -pgo-memop-opt -loop-sink -lowerswitch -guard-widening -indvars -inline -slp-vectorizer -licm -coro-elide -gvn-hoist -loop-interchange -lower-widenable-condition -loop-deletion -post-inline-ee-instrument -globalsplit -coro-elide -correlated-propagation -libcalls-shrinkwrap -coro-split -loop-deletion -load-store-vectorizer -nary-reassociate -mergereturn -float2int -float2int -dse -strip-debug-declare -loop-reroll -infer-address-spaces -die -loop-reduce -early-cse-memssa -constmerge -loop-versioning-licm -sink -div-rem-pairs -canonicalize-aliases -strip-nondebug -loop-versioning-licm -ee-instrument -loop-load-elim -forceattrs -irce -loop-idiom -lower-matrix-intrinsics -simplifycfg -cross-dso-cfi -scalarizer -lcssa -load-store-vectorizer -simplifycfg -forceattrs -lower-constant-intrinsics -loop-rotate -rewrite-statepoints-for-gc -loop-simplify -hotcoldsplit -deadargelim -guard-widening -lcssa -load-store-vectorizer -guard-widening -instnamer -licm -div-rem-pairs -slsr -newgvn -simple-loop-unswitch -gvn-hoist -elim-avail-extern -hotcoldsplit -slp-vectorizer -loop-vectorize -called-value-propagation -tailcallelim -partially-inline-libcalls -post-inline-ee-instrument -strip -post-inline-ee-instrument -aggressive-instcombine -dce -lowerinvoke -sink -loop-versioning-licm -loweratomic -ipsccp -attributor -lower-widenable-condition -lower-expect -dse -aggressive-instcombine -rewrite-statepoints-for-gc -lcssa -loop-fusion -loop-distribute -instsimplify -infer-address-spaces -lower-constant-intrinsics -canonicalize-aliases -instsimplify -flattencfg -hotcoldsplit -forceattrs -loop-data-prefetch -slp-vectorizer -dce -separate-const-offset-from-gep -globalopt -loop-versioning -reassociate -dce -elim-avail-extern -loweratomic -inferattrs -rewrite-statepoints-for-gc -lower-guard-intrinsic -lower-guard-intrinsic -constmerge -rewrite-statepoints-for-gc -pgo-memop-opt -coro-cleanup -lowerinvoke -memcpyopt -mergefunc -loop-predication -consthoist -libcalls-shrinkwrap -loop-simplify -early-cse-memssa -licm -sink -ipsccp -instcombine -rewrite-statepoints-for-gc -sink -forceattrs -loop-guard-widening -loop-sink -slsr -consthoist -partially-inline-libcalls -simple-loop-unswitch -separate-const-offset-from-gep -instnamer -loop-predication -libcalls-shrinkwrap -indvars -consthoist -nary-reassociate -ee-instrument -strip-nondebug -strip-dead-prototypes -add-discriminators -loop-sink -loop-load-elim -pgo-memop-opt -called-value-propagation -hotcoldsplit -early-cse-memssa -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0620865139949112,62.0668671131134,opt -mem2reg -mergefunc -reassociate -dse -loop-sink -infer-address-spaces -libcalls-shrinkwrap -instsimplify -simple-loop-unswitch -infer-address-spaces -tailcallelim -loop-guard-widening -deadargelim -callsite-splitting -pgo-memop-opt -sink -break-crit-edges -canonicalize-aliases -loop-instsimplify -strip -loop-predication -sccp -mldst-motion -div-rem-pairs -coro-cleanup -loop-distribute -loop-idiom -gvn -globalopt -attributor -loop-unroll-and-jam -loop-interchange -early-cse-memssa -break-crit-edges -loop-deletion -loop-guard-widening -loop-unroll-and-jam -lower-guard-intrinsic -sroa -loop-instsimplify -instnamer -memcpyopt -scalarizer -simple-loop-unswitch -callsite-splitting -sancov -argpromotion -add-discriminators -bdce -attributor -loop-unroll -loop-unroll -inferattrs -coro-cleanup -strip-dead-prototypes -instsimplify -loop-idiom -loop-fusion -always-inline -loweratomic -globalopt -loweratomic -float2int -loop-idiom -insert-gcov-profiling -gvn -lower-constant-intrinsics -callsite-splitting -coro-cleanup -lower-matrix-intrinsics -attributor -globalopt -loop-reroll -name-anon-globals -loop-reduce -sroa -constmerge -loop-unswitch -redundant-dbg-inst-elim -gvn -loop-simplify -aggressive-instcombine -flattencfg -inject-tli-mappings -cross-dso-cfi -simple-loop-unswitch -instcombine -ipsccp -argpromotion -correlated-propagation -sccp -barrier -hotcoldsplit -deadargelim -lower-guard-intrinsic -flattencfg -dse -lower-constant-intrinsics -elim-avail-extern -globaldce -aggressive-instcombine -reassociate -mldst-motion -instnamer -slsr -simplifycfg -sroa -lower-expect -argpromotion -dse -insert-gcov-profiling -loop-simplify -redundant-dbg-inst-elim -canonicalize-aliases -constmerge -rewrite-statepoints-for-gc -redundant-dbg-inst-elim -adce -pgo-memop-opt -strip -instcombine -ipconstprop -add-discriminators -aggressive-instcombine -partial-inliner -memcpyopt -canonicalize-aliases -constmerge -instnamer -loop-versioning -partially-inline-libcalls -sccp -inferattrs -gvn-hoist -loop-versioning-licm -sink -constprop -coro-elide -barrier -cross-dso-cfi -loop-idiom -speculative-execution -loop-deletion -lowerinvoke -loweratomic -gvn-hoist -coro-early -rewrite-statepoints-for-gc -loop-unswitch -loop-simplifycfg -loop-simplify -ipconstprop -mldst-motion -ipsccp -barrier -infer-address-spaces -ipsccp -sccp -alignment-from-assumptions -loop-load-elim -load-store-vectorizer -simplifycfg -loop-idiom -loop-idiom -irce -inferattrs -loop-vectorize -inject-tli-mappings -libcalls-shrinkwrap -instsimplify -loweratomic -simple-loop-unswitch -loop-reroll -separate-const-offset-from-gep -lower-guard-intrinsic -guard-widening -loop-sink -redundant-dbg-inst-elim -gvn -loop-instsimplify -mergefunc -deadargelim -hotcoldsplit -callsite-splitting -cross-dso-cfi -slp-vectorizer -licm -adce -slp-vectorizer -memcpyopt -sancov -ee-instrument -rewrite-statepoints-for-gc -rewrite-statepoints-for-gc -always-inline -loop-reroll -lcssa -jump-threading -called-value-propagation -loweratomic -lower-guard-intrinsic -lower-guard-intrinsic -lower-expect -libcalls-shrinkwrap -loop-reduce -slsr -argpromotion -loop-idiom -die -loop-reroll -dse -sancov -insert-gcov-profiling -jump-threading -loop-instsimplify -lowerinvoke -barrier -instcombine -loop-deletion -loop-unroll-and-jam -nary-reassociate -rpo-functionattrs -argpromotion -mldst-motion -partially-inline-libcalls -strip-dead-prototypes -strip-nondebug -hotcoldsplit -loop-reroll -loop-simplify -early-cse-memssa -lcssa -loop-reduce -always-inline -mergefunc -gvn -constprop -loop-distribute -gvn -coro-cleanup -loop-fusion -indvars -break-crit-edges -irce -separate-const-offset-from-gep -sccp -reg2mem -slsr -sroa -loop-deletion -barrier -die -newgvn -die -libcalls-shrinkwrap -partially-inline-libcalls -loop-simplify -loop-unroll-and-jam -called-value-propagation -newgvn -mldst-motion -jump-threading -redundant-dbg-inst-elim -newgvn -mergeicmps -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0641221374045802,62.110954999923706,opt -constmerge -name-anon-globals -cross-dso-cfi -elim-avail-extern -mergeicmps -lower-constant-intrinsics -mergeicmps -loop-versioning-licm -mem2reg -rpo-functionattrs -called-value-propagation -attributor -constmerge -instcombine -ipconstprop -loop-unroll-and-jam -coro-elide -coro-split -loop-unswitch -jump-threading -gvn -mldst-motion -loop-fusion -cross-dso-cfi -post-inline-ee-instrument -licm -indvars -early-cse-memssa -strip-debug-declare -strip -load-store-vectorizer -lower-guard-intrinsic -mergereturn -loop-deletion -slsr -indvars -ipsccp -loop-reroll -constprop -loop-predication -coro-early -bdce -loop-fusion -consthoist -globalopt -attributor -instcombine -name-anon-globals -scalarizer -newgvn -loop-data-prefetch -flattencfg -lcssa -rpo-functionattrs -instcombine -instcombine -strip-dead-prototypes -infer-address-spaces -indvars -sccp -coro-split -pgo-memop-opt -hotcoldsplit -coro-cleanup -argpromotion -simplifycfg -infer-address-spaces -irce -float2int -callsite-splitting -aggressive-instcombine -alignment-from-assumptions -mem2reg -consthoist -dse -loop-predication -load-store-vectorizer -always-inline -lower-constant-intrinsics -loop-guard-widening -mergereturn -mldst-motion -post-inline-ee-instrument -simplifycfg -inferattrs -strip -loop-sink -loop-predication -reg2mem -slsr -loop-data-prefetch -gvn-hoist -loop-deletion -gvn-hoist -coro-elide -indvars -loop-versioning-licm -flattencfg -name-anon-globals -flattencfg -simple-loop-unswitch -coro-early -float2int -coro-elide -aggressive-instcombine -reg2mem -prune-eh -ipsccp -flattencfg -loop-simplifycfg -loop-fusion -guard-widening -name-anon-globals -post-inline-ee-instrument -early-cse-memssa -break-crit-edges -globalsplit -dse -name-anon-globals -lower-matrix-intrinsics -loop-vectorize -prune-eh -nary-reassociate -lowerinvoke -loop-deletion -loop-load-elim -loop-predication -loweratomic -simplifycfg -strip-debug-declare -name-anon-globals -lowerinvoke -loweratomic -inline -loop-unswitch -slsr -newgvn -reg2mem -lower-constant-intrinsics -loop-versioning -licm -hotcoldsplit -alignment-from-assumptions -constprop -dse -functionattrs -loop-vectorize -slsr -called-value-propagation -loop-versioning -canonicalize-aliases -redundant-dbg-inst-elim -dce -consthoist -sink -add-discriminators -mergefunc -consthoist -rpo-functionattrs -always-inline -slsr -lower-widenable-condition -rpo-functionattrs -instnamer -loop-fusion -loop-idiom -barrier -bdce -loop-predication -elim-avail-extern -memcpyopt -gvn -strip -loop-versioning -separate-const-offset-from-gep -instsimplify -loop-data-prefetch -dse -loop-simplifycfg -separate-const-offset-from-gep -strip-debug-declare -reassociate -attributor -slp-vectorizer -gvn-hoist -instcombine -loop-reduce -loop-idiom -ee-instrument -inline -lower-guard-intrinsic -reassociate -instcombine -loop-vectorize -add-discriminators -elim-avail-extern -lowerinvoke -loop-rotate -sroa -reassociate -adce -coro-elide -consthoist -strip-nondebug -break-crit-edges -loop-load-elim -memcpyopt -strip -loop-fusion -loop-versioning -strip-debug-declare -adce -loop-simplify -name-anon-globals -loop-simplifycfg -newgvn -cross-dso-cfi -loop-versioning -globalopt -add-discriminators -deadargelim -load-store-vectorizer -forceattrs -cross-dso-cfi -lower-matrix-intrinsics -ipsccp -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0671755725190841,62.24016213417053,opt -constprop -lower-constant-intrinsics -lcssa -libcalls-shrinkwrap -deadargelim -always-inline -inferattrs -loop-unroll-and-jam -loop-fusion -prune-eh -loop-instsimplify -gvn -rewrite-statepoints-for-gc -strip-debug-declare -ee-instrument -loop-instsimplify -instcombine -mergefunc -name-anon-globals -reassociate -loop-unroll-and-jam -argpromotion -prune-eh -simple-loop-unswitch -instnamer -mem2reg -strip-dead-prototypes -coro-split -partially-inline-libcalls -reassociate -insert-gcov-profiling -loop-unswitch -break-crit-edges -flattencfg -aggressive-instcombine -barrier -slp-vectorizer -irce -libcalls-shrinkwrap -reassociate -name-anon-globals -inferattrs -canonicalize-aliases -simple-loop-unswitch -cross-dso-cfi -slp-vectorizer -loop-unroll-and-jam -add-discriminators -newgvn -loop-fusion -post-inline-ee-instrument -argpromotion -ipconstprop -slsr -mem2reg -irce -strip-dead-prototypes -globalsplit -loop-unroll -scalarizer -pgo-memop-opt -mem2reg -loop-simplifycfg -mergereturn -load-store-vectorizer -irce -libcalls-shrinkwrap -loop-instsimplify -simplifycfg -ipconstprop -partial-inliner -loop-guard-widening -canonicalize-aliases -aggressive-instcombine -inferattrs -mergefunc -gvn-hoist -consthoist -loop-reroll -sink -tailcallelim -float2int -loop-deletion -gvn -gvn -lcssa -post-inline-ee-instrument -load-store-vectorizer -loop-load-elim -loop-deletion -gvn-hoist -slsr -loop-simplify -aggressive-instcombine -memcpyopt -nary-reassociate -loop-unroll-and-jam -mergefunc -licm -alignment-from-assumptions -redundant-dbg-inst-elim -barrier -libcalls-shrinkwrap -sccp -mergeicmps -dce -prune-eh -callsite-splitting -ipconstprop -coro-split -partially-inline-libcalls -globalopt -div-rem-pairs -mergereturn -loop-unswitch -inferattrs -reassociate -barrier -licm -adce -infer-address-spaces -simplifycfg -ipsccp -libcalls-shrinkwrap -rewrite-statepoints-for-gc -loop-load-elim -loop-instsimplify -slsr -sccp -dce -ee-instrument -lower-widenable-condition -loop-load-elim -memcpyopt -loop-vectorize -alignment-from-assumptions -ipsccp -break-crit-edges -constprop -redundant-dbg-inst-elim -loop-unswitch -mldst-motion -slp-vectorizer -instsimplify -barrier -load-store-vectorizer -loop-sink -loop-instsimplify -strip-nondebug -loop-unroll-and-jam -loop-instsimplify -partial-inliner -strip -flattencfg -slsr -div-rem-pairs -partially-inline-libcalls -mergeicmps -loop-reroll -bdce -alignment-from-assumptions -simplifycfg -mem2reg -mem2reg -adce -cross-dso-cfi -tailcallelim -canonicalize-aliases -float2int -licm -globalsplit -mergeicmps -correlated-propagation -globaldce -lcssa -instcombine -globaldce -called-value-propagation -irce -strip-nondebug -instsimplify -early-cse-memssa -jump-threading input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0687022900763359,62.245200872421265,opt -loop-simplifycfg -simple-loop-unswitch -functionattrs -break-crit-edges -rpo-functionattrs -loop-fusion -dce -consthoist -die -loop-interchange -strip -licm -strip -lower-constant-intrinsics -functionattrs -lower-constant-intrinsics -speculative-execution -pgo-memop-opt -dce -strip -sroa -slp-vectorizer -early-cse-memssa -memcpyopt -instcombine -loop-interchange -loop-deletion -globalopt -loop-unroll -loop-versioning -instnamer -functionattrs -rewrite-statepoints-for-gc -loop-instsimplify -coro-split -sroa -loop-deletion -coro-early -instsimplify -simple-loop-unswitch -name-anon-globals -flattencfg -post-inline-ee-instrument -inline -bdce -load-store-vectorizer -load-store-vectorizer -loop-versioning -lower-constant-intrinsics -consthoist -load-store-vectorizer -instnamer -speculative-execution -loop-fusion -irce -irce -flattencfg -lower-guard-intrinsic -sroa -cross-dso-cfi -guard-widening -redundant-dbg-inst-elim -correlated-propagation -gvn-hoist -prune-eh -loop-data-prefetch -always-inline -irce -coro-early -newgvn -strip-dead-prototypes -coro-cleanup -infer-address-spaces -irce -adce -loop-simplify -globalsplit -dse -tailcallelim -loop-idiom -slp-vectorizer -tailcallelim -partial-inliner -mldst-motion -libcalls-shrinkwrap -load-store-vectorizer -strip-nondebug -gvn -loop-unswitch -always-inline -jump-threading -loweratomic -loop-sink -gvn-hoist -globalopt -flattencfg -simple-loop-unswitch -mldst-motion -mergefunc -globalsplit -deadargelim -loweratomic -loop-idiom -globaldce -separate-const-offset-from-gep -mergefunc -lcssa -add-discriminators -coro-cleanup -speculative-execution -infer-address-spaces -gvn -canonicalize-aliases -bdce -callsite-splitting -coro-elide -tailcallelim -lower-constant-intrinsics -loop-versioning -loop-sink -irce -argpromotion -loop-data-prefetch -attributor -simple-loop-unswitch -alignment-from-assumptions -barrier -early-cse-memssa -loop-idiom -simple-loop-unswitch -slp-vectorizer -loop-interchange -coro-early -loop-versioning -loop-simplify -rewrite-statepoints-for-gc -globalopt -alignment-from-assumptions -bdce -barrier -post-inline-ee-instrument -lowerinvoke -pgo-memop-opt -always-inline -newgvn -loweratomic -argpromotion -irce -sink -gvn -attributor -coro-cleanup -speculative-execution -lowerinvoke -aggressive-instcombine -loop-sink -early-cse-memssa -indvars -always-inline -add-discriminators -loop-unswitch -irce -attributor -early-cse-memssa -instcombine -bdce -die -loop-fusion -loop-distribute -ipsccp -lower-constant-intrinsics -slp-vectorizer input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.068702290076336,62.09459686279297,opt -strip-dead-prototypes -post-inline-ee-instrument -lowerinvoke -loop-deletion -lower-constant-intrinsics -ipconstprop -attributor -float2int -partially-inline-libcalls -elim-avail-extern -coro-cleanup -rewrite-statepoints-for-gc -prune-eh -lower-widenable-condition -div-rem-pairs -coro-elide -rpo-functionattrs -float2int -lower-guard-intrinsic -mergereturn -callsite-splitting -loop-predication -ipconstprop -globalsplit -lower-widenable-condition -barrier -partially-inline-libcalls -lower-expect -lower-expect -dce -ipsccp -lowerinvoke -inferattrs -bdce -loop-vectorize -add-discriminators -consthoist -argpromotion -lower-constant-intrinsics -mem2reg -dce -loop-instsimplify -constprop -lower-widenable-condition -reassociate -speculative-execution -rpo-functionattrs -libcalls-shrinkwrap -lower-guard-intrinsic -called-value-propagation -slsr -globalsplit -instcombine -mergeicmps -loop-reroll -loweratomic -hotcoldsplit -globalopt -globalsplit -loop-guard-widening -loop-versioning-licm -loop-sink -loop-versioning-licm -gvn -consthoist -canonicalize-aliases -lowerswitch -libcalls-shrinkwrap -irce -coro-cleanup -loop-versioning-licm -inline -inferattrs -irce -libcalls-shrinkwrap -coro-elide -loop-guard-widening -elim-avail-extern -alignment-from-assumptions -load-store-vectorizer -load-store-vectorizer -constprop -functionattrs -loop-idiom -loop-deletion -float2int -correlated-propagation -rpo-functionattrs -constprop -dce -coro-elide -load-store-vectorizer -lower-matrix-intrinsics -separate-const-offset-from-gep -aggressive-instcombine -tailcallelim -loweratomic -load-store-vectorizer -coro-early -argpromotion -alignment-from-assumptions -bdce -inferattrs -adce -sancov -globaldce -elim-avail-extern -loop-versioning-licm -adce -dce -reg2mem -name-anon-globals -load-store-vectorizer -loop-distribute -hotcoldsplit -always-inline -instsimplify -hotcoldsplit -loop-instsimplify -instsimplify -loop-interchange -loop-load-elim -newgvn -add-discriminators -jump-threading -loweratomic -prune-eh -tailcallelim -loop-load-elim -correlated-propagation -adce -tailcallelim -sccp -constprop -early-cse-memssa -prune-eh -alignment-from-assumptions -ipconstprop -loop-fusion -float2int -prune-eh -newgvn -gvn -early-cse-memssa -loop-versioning -loop-reroll -loop-vectorize -always-inline -redundant-dbg-inst-elim -newgvn -called-value-propagation -slp-vectorizer -alignment-from-assumptions -argpromotion -loop-data-prefetch -instcombine -redundant-dbg-inst-elim -break-crit-edges -jump-threading -loop-simplify -reassociate -sroa -simplifycfg -forceattrs -div-rem-pairs -loop-distribute -ee-instrument -gvn-hoist -prune-eh -tailcallelim -mergefunc -mergeicmps -instnamer -gvn input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0732824427480923,62.259055852890015,opt -forceattrs -jump-threading -forceattrs -dse -simple-loop-unswitch -consthoist -loop-interchange -alignment-from-assumptions -flattencfg -instsimplify -mergefunc -argpromotion -strip -flattencfg -lowerinvoke -simple-loop-unswitch -loop-simplifycfg -coro-elide -load-store-vectorizer -dse -loop-versioning-licm -pgo-memop-opt -cross-dso-cfi -slsr -nary-reassociate -coro-early -coro-elide -instsimplify -loop-vectorize -die -functionattrs -lower-constant-intrinsics -mldst-motion -consthoist -cross-dso-cfi -slsr -lcssa -float2int -globaldce -simplifycfg -licm -simple-loop-unswitch -post-inline-ee-instrument -loweratomic -alignment-from-assumptions -simplifycfg -strip-dead-prototypes -deadargelim -mldst-motion -coro-cleanup -instcombine -add-discriminators -ipsccp -loop-reroll -newgvn -canonicalize-aliases -ee-instrument -loop-versioning-licm -constprop -coro-cleanup -loop-reroll -always-inline -mem2reg -rpo-functionattrs -gvn -partial-inliner -strip -always-inline -sroa -prune-eh -loop-unswitch -slsr -lower-constant-intrinsics -sroa -irce -constprop -dse -slsr -lower-widenable-condition -loop-unroll-and-jam -lowerinvoke -speculative-execution -mldst-motion -loop-unroll -irce -early-cse-memssa -coro-split -argpromotion -loop-load-elim -mergeicmps -mem2reg -loop-interchange -separate-const-offset-from-gep -instcombine -forceattrs -globalopt -loop-idiom -globaldce -mem2reg -newgvn -called-value-propagation -strip-dead-prototypes -strip -name-anon-globals -newgvn -callsite-splitting -speculative-execution -ipsccp -coro-elide -barrier -slp-vectorizer -cross-dso-cfi -loop-sink -die -instcombine -hotcoldsplit -memcpyopt -inline -strip-nondebug -loop-versioning-licm -gvn-hoist -memcpyopt -inline -tailcallelim -loop-instsimplify -barrier -mergefunc -mergeicmps -loop-instsimplify -load-store-vectorizer -inferattrs -constmerge -div-rem-pairs -gvn-hoist -prune-eh -deadargelim -hotcoldsplit -memcpyopt -tailcallelim -loop-sink -loop-fusion -loop-deletion -name-anon-globals -coro-elide -newgvn -ipsccp -strip-dead-prototypes -die -redundant-dbg-inst-elim -ipconstprop -instcombine -called-value-propagation -coro-elide -slp-vectorizer -inferattrs -aggressive-instcombine -float2int -reassociate -newgvn -early-cse-memssa -loop-load-elim -slsr -dce -gvn-hoist -irce -jump-threading -rpo-functionattrs -nary-reassociate -loop-versioning -lowerinvoke -elim-avail-extern -loop-load-elim -bdce -memcpyopt -flattencfg -instcombine -coro-early -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/blowfish,1.0793893129770993,61.71475172042847,opt -slp-vectorizer -loop-reduce -post-inline-ee-instrument -cross-dso-cfi -elim-avail-extern -sroa -callsite-splitting -div-rem-pairs -constmerge -mergeicmps -lcssa -insert-gcov-profiling -mergefunc -tailcallelim -strip-debug-declare -loop-versioning-licm -add-discriminators -loop-distribute -strip -insert-gcov-profiling -prune-eh -coro-split -instcombine -coro-early -loop-interchange -jump-threading -lowerinvoke -prune-eh -loop-unswitch -attributor -called-value-propagation -lower-expect -mem2reg -speculative-execution -partially-inline-libcalls -dce -separate-const-offset-from-gep -jump-threading -ipsccp -sink -flattencfg -mergeicmps -ee-instrument -sink -consthoist -indvars -loop-vectorize -load-store-vectorizer -correlated-propagation -slp-vectorizer -loop-versioning-licm -guard-widening -simplifycfg -consthoist -aggressive-instcombine -called-value-propagation -barrier -loop-idiom -coro-early -ee-instrument -add-discriminators -mldst-motion -forceattrs -newgvn -always-inline -instsimplify -simplifycfg -adce -loop-unswitch -reassociate -strip-debug-declare -irce -div-rem-pairs -deadargelim -instcombine -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.1545071082643337,67.68773531913757,opt -loop-reduce -adce -coro-early -indvars -called-value-propagation -strip-debug-declare -pgo-memop-opt -licm -lcssa -bdce -loop-guard-widening -attributor -mergereturn -loop-idiom -loop-sink -forceattrs -instsimplify -strip -sancov -loop-vectorize -ipsccp -mergefunc -lower-matrix-intrinsics -sroa -loop-versioning-licm -lcssa -elim-avail-extern -lcssa -speculative-execution -bdce -hotcoldsplit -mldst-motion -called-value-propagation -globaldce -newgvn -load-store-vectorizer -break-crit-edges -sink -loop-vectorize -redundant-dbg-inst-elim -reg2mem -aggressive-instcombine -cross-dso-cfi -globalopt -strip-debug-declare -canonicalize-aliases -coro-elide -reassociate -loop-guard-widening -loop-predication -flattencfg -nary-reassociate -loop-fusion -memcpyopt -loop-instsimplify -coro-cleanup -mem2reg -ipsccp -simple-loop-unswitch -loop-data-prefetch -licm -globalopt -coro-early -slp-vectorizer -redundant-dbg-inst-elim -loop-predication -loop-unroll-and-jam -coro-cleanup -loop-fusion -pgo-memop-opt -simplifycfg -loop-unswitch -dce -aggressive-instcombine -simplifycfg -always-inline -loop-fusion -instcombine input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.160287455085143,322.17351841926575,opt -flattencfg -loweratomic -simplifycfg -constmerge -loop-versioning -reg2mem -globalsplit -mem2reg -loop-vectorize -canonicalize-aliases -mergeicmps -indvars -instnamer -correlated-propagation -loop-guard-widening -correlated-propagation -instcombine -alignment-from-assumptions -barrier -newgvn -strip-nondebug -reassociate -loop-fusion -simplifycfg -alignment-from-assumptions -ipsccp -instcombine input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.161927823777535,69.08962750434875,opt -loweratomic -lcssa -dce -called-value-propagation -loop-guard-widening -inferattrs -elim-avail-extern -consthoist -coro-early -globalsplit -add-discriminators -loop-unswitch -coro-cleanup -lowerinvoke -instnamer -aggressive-instcombine -simplifycfg -lower-matrix-intrinsics -called-value-propagation -globalopt -inject-tli-mappings -reg2mem -callsite-splitting -div-rem-pairs -irce -die -lower-guard-intrinsic -rewrite-statepoints-for-gc -nary-reassociate -functionattrs -ee-instrument -loop-data-prefetch -always-inline -elim-avail-extern -separate-const-offset-from-gep -globaldce -always-inline -called-value-propagation -prune-eh -licm -loop-unroll-and-jam -lcssa -mergeicmps -loop-reroll -mergeicmps -div-rem-pairs -elim-avail-extern -lcssa -dse -break-crit-edges -coro-cleanup -inject-tli-mappings -instsimplify -loop-simplifycfg -div-rem-pairs -functionattrs -strip -forceattrs -ipconstprop -loop-versioning-licm -mldst-motion -simple-loop-unswitch -loop-guard-widening -memcpyopt -sroa -functionattrs -insert-gcov-profiling -mldst-motion -loop-idiom -instnamer -add-discriminators -globalsplit -called-value-propagation -lower-constant-intrinsics -globaldce -slsr -redundant-dbg-inst-elim -coro-split -loop-load-elim -partially-inline-libcalls -globaldce -called-value-propagation -jump-threading -argpromotion -loop-fusion -mergereturn -nary-reassociate -constprop -early-cse-memssa -irce -sroa -canonicalize-aliases -loop-idiom -strip-nondebug -reassociate -inferattrs -instcombine -cross-dso-cfi -coro-split -partially-inline-libcalls -partially-inline-libcalls -licm -lowerswitch -aggressive-instcombine -loop-unroll-and-jam -lowerinvoke -bdce -lower-widenable-condition -lower-matrix-intrinsics -redundant-dbg-inst-elim -post-inline-ee-instrument -ee-instrument -coro-split -lower-matrix-intrinsics -functionattrs -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.1643493204186848,67.1374294757843,opt -aggressive-instcombine -lowerinvoke -memcpyopt -loop-sink -always-inline -lower-matrix-intrinsics -gvn-hoist -slsr -separate-const-offset-from-gep -speculative-execution -sroa -newgvn -lcssa -forceattrs -coro-split -hotcoldsplit -dse -memcpyopt -lowerinvoke -dce -reassociate -functionattrs -forceattrs -loop-unroll-and-jam -loop-interchange -coro-split -lower-widenable-condition -loop-vectorize -always-inline -load-store-vectorizer -slsr -post-inline-ee-instrument -partially-inline-libcalls -irce -instcombine -memcpyopt -consthoist -loop-load-elim -pgo-memop-opt -barrier -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.1674738322137166,69.87810277938843,opt -loop-versioning -loop-simplifycfg -loop-fusion -strip-debug-declare -ipsccp -simple-loop-unswitch -strip-dead-prototypes -gvn-hoist -simplifycfg -loop-sink -div-rem-pairs -prune-eh -post-inline-ee-instrument -loop-guard-widening -sink -speculative-execution -ee-instrument -lcssa -mldst-motion -lower-expect -sroa -dse -tailcallelim -loop-unroll-and-jam -flattencfg -loop-distribute -globalsplit -loop-reroll -loop-reroll -gvn -lower-constant-intrinsics -loop-predication -mergereturn -coro-split -loop-unswitch -simple-loop-unswitch -libcalls-shrinkwrap -sccp -loop-interchange -lowerinvoke -constprop -coro-elide -pgo-memop-opt -name-anon-globals -forceattrs -break-crit-edges -separate-const-offset-from-gep -lower-expect -prune-eh -bdce -attributor -scalarizer -loop-reroll -loweratomic -rewrite-statepoints-for-gc -cross-dso-cfi -scalarizer -nary-reassociate -jump-threading -insert-gcov-profiling -flattencfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.1680206217778468,68.25625967979431,opt -flattencfg -mldst-motion -newgvn -attributor -canonicalize-aliases -coro-elide -canonicalize-aliases -ipconstprop -licm -loop-instsimplify -loop-load-elim -attributor -instsimplify -loop-distribute -lower-widenable-condition -strip-dead-prototypes -elim-avail-extern -loop-versioning-licm -mergefunc -loop-unroll -callsite-splitting -irce -flattencfg -lowerswitch -load-store-vectorizer -globalsplit -reassociate -lowerswitch -lcssa -lower-widenable-condition -strip -gvn-hoist -strip -guard-widening -tailcallelim -instnamer -partially-inline-libcalls -strip-debug-declare -cross-dso-cfi -jump-threading -irce -jump-threading -prune-eh -reassociate -load-store-vectorizer -loop-reroll -loop-distribute -loop-versioning -newgvn -loop-simplify -mem2reg -alignment-from-assumptions -mergeicmps -lower-guard-intrinsic -functionattrs -simplifycfg -barrier -coro-early -constprop -globalsplit -loop-versioning -loop-guard-widening -lowerinvoke -libcalls-shrinkwrap -inject-tli-mappings -consthoist -ee-instrument -slp-vectorizer -nary-reassociate -lower-guard-intrinsic -speculative-execution -name-anon-globals -adce -callsite-splitting -dse -instcombine -sancov -lower-widenable-condition -gvn -simplifycfg -memcpyopt input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.1706764568036248,68.34867286682129,opt -mergeicmps -newgvn -loop-versioning-licm -dce -partial-inliner -load-store-vectorizer -mem2reg -functionattrs -sccp -functionattrs -strip-debug-declare -dce -mldst-motion -mergeicmps -float2int -infer-address-spaces -jump-threading -mem2reg -break-crit-edges -constprop -always-inline -div-rem-pairs -mergereturn -cross-dso-cfi -gvn -coro-elide -loop-interchange -float2int -loop-idiom -die -dce -instcombine -loop-vectorize -load-store-vectorizer -simplifycfg -attributor -sancov -nary-reassociate -guard-widening -loop-deletion -callsite-splitting -instnamer -coro-early -nary-reassociate -coro-cleanup -newgvn -loop-unroll-and-jam -simplifycfg -simplifycfg -strip -lcssa -jump-threading -lower-guard-intrinsic -slsr -redundant-dbg-inst-elim -correlated-propagation -slsr -load-store-vectorizer -loop-simplify -instnamer -globaldce -adce -redundant-dbg-inst-elim -early-cse-memssa -slp-vectorizer -slsr -irce -loop-data-prefetch -nary-reassociate -deadargelim -licm -separate-const-offset-from-gep -strip-nondebug -prune-eh -loop-deletion -mldst-motion -gvn -alignment-from-assumptions -ipsccp -jump-threading input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.172473051085768,70.48168897628784,opt -mergefunc -scalarizer -deadargelim -alignment-from-assumptions -loweratomic -loop-distribute -lower-matrix-intrinsics -nary-reassociate -loop-versioning -slp-vectorizer -name-anon-globals -constprop -scalarizer -deadargelim -gvn -strip-dead-prototypes -float2int -break-crit-edges -lower-constant-intrinsics -ee-instrument -add-discriminators -globalopt -slp-vectorizer -constmerge -lcssa -cross-dso-cfi -alignment-from-assumptions -early-cse-memssa -dce -loop-unroll-and-jam -cross-dso-cfi -simple-loop-unswitch -guard-widening -loop-sink -loop-fusion -coro-early -guard-widening -scalarizer -pgo-memop-opt -loop-interchange -mergereturn -mergefunc -break-crit-edges -aggressive-instcombine -strip-dead-prototypes -div-rem-pairs -mergereturn -name-anon-globals -always-inline -loweratomic -loop-data-prefetch -newgvn -coro-elide -strip-nondebug -globalopt -lower-matrix-intrinsics -pgo-memop-opt -die -slp-vectorizer -loop-sink -barrier -elim-avail-extern -attributor -loop-load-elim -slsr -ee-instrument -globaldce -early-cse-memssa -pgo-memop-opt -gvn-hoist -loweratomic -rewrite-statepoints-for-gc -canonicalize-aliases -partially-inline-libcalls -instnamer -simplifycfg -barrier -reassociate -insert-gcov-profiling -libcalls-shrinkwrap -loop-vectorize -add-discriminators -correlated-propagation -prune-eh -sroa -redundant-dbg-inst-elim -add-discriminators -simple-loop-unswitch -separate-const-offset-from-gep -strip-nondebug -nary-reassociate -globalsplit -name-anon-globals -strip-debug-declare -loop-deletion -loop-predication -loop-load-elim -called-value-propagation -lower-widenable-condition -loop-distribute -alignment-from-assumptions -coro-early -simplifycfg -div-rem-pairs -newgvn -simple-loop-unswitch -ee-instrument -loop-reroll -strip -aggressive-instcombine -flattencfg -called-value-propagation -inferattrs -tailcallelim -gvn -mergeicmps -strip-debug-declare -slp-vectorizer -loop-simplifycfg -lower-constant-intrinsics -functionattrs -instcombine -gvn-hoist -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.1809092329323547,365.934752702713,opt -pgo-memop-opt -loop-versioning-licm -inferattrs -functionattrs -guard-widening -functionattrs -tailcallelim -lower-matrix-intrinsics -barrier -rewrite-statepoints-for-gc -lcssa -inject-tli-mappings -lower-widenable-condition -mem2reg -scalarizer -mergereturn -partially-inline-libcalls -globalopt -dse -break-crit-edges -alignment-from-assumptions -bdce -loop-sink -hotcoldsplit -alignment-from-assumptions -flattencfg -partial-inliner -adce -float2int -callsite-splitting -div-rem-pairs -gvn-hoist -forceattrs -elim-avail-extern -infer-address-spaces -loop-versioning -newgvn -strip-nondebug -flattencfg -mem2reg -loop-load-elim -instcombine -globaldce -inferattrs -loop-distribute -mergereturn -constmerge -consthoist -dse -prune-eh -rpo-functionattrs -scalarizer -load-store-vectorizer -flattencfg -loop-interchange -ipconstprop -canonicalize-aliases -attributor -lower-matrix-intrinsics -mldst-motion -inferattrs -always-inline -mem2reg -loop-instsimplify -sccp -memcpyopt -strip-nondebug -nary-reassociate -lower-constant-intrinsics -die -mergereturn -infer-address-spaces -loop-versioning-licm -called-value-propagation -early-cse-memssa -lower-guard-intrinsic -ipsccp -sink -early-cse-memssa -strip -loop-idiom -instcombine -loop-vectorize -lowerinvoke -callsite-splitting -ipconstprop -libcalls-shrinkwrap -die -loop-interchange -ipconstprop -add-discriminators -alignment-from-assumptions -indvars -lower-widenable-condition -dce -simplifycfg -guard-widening -argpromotion -dce -ipsccp -dse -early-cse-memssa -float2int -newgvn input.bc -o output.bc +benchmark://cbench-v1/bzip2,1.1948914232151224,68.35258197784424,opt -mem2reg -globaldce -loop-unroll-and-jam -correlated-propagation -scalarizer -rpo-functionattrs -licm -flattencfg -loweratomic -libcalls-shrinkwrap -irce -tailcallelim -loop-instsimplify -functionattrs -mergeicmps -coro-early -loop-instsimplify -strip-debug-declare -dce -loop-versioning-licm -loop-unswitch -prune-eh -rpo-functionattrs -loop-versioning-licm -constmerge -div-rem-pairs -loop-guard-widening -ipconstprop -prune-eh -libcalls-shrinkwrap -indvars -lower-matrix-intrinsics -globalopt -strip-nondebug -coro-split -loop-instsimplify -lower-matrix-intrinsics -libcalls-shrinkwrap -loop-idiom -loop-data-prefetch -loop-guard-widening -nary-reassociate -flattencfg -loop-sink -cross-dso-cfi -always-inline -indvars -dce -always-inline -guard-widening -memcpyopt -instnamer -lower-guard-intrinsic -loop-versioning-licm -nary-reassociate -deadargelim -irce -post-inline-ee-instrument -lowerinvoke -sroa -coro-cleanup -simplifycfg -newgvn -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,61.635990619659424,opt -add-discriminators -loop-unroll-and-jam -lower-constant-intrinsics -mldst-motion -globaldce -add-discriminators -slp-vectorizer -mem2reg -mergereturn -infer-address-spaces -die -nary-reassociate -coro-split -redundant-dbg-inst-elim -barrier -loop-distribute -scalarizer -indvars -instcombine -separate-const-offset-from-gep -lower-constant-intrinsics -inferattrs -guard-widening -lower-widenable-condition -mergefunc -die -lcssa -strip -scalarizer -ipsccp -loop-unroll -loop-guard-widening -loop-instsimplify -coro-early -reassociate -tailcallelim -slp-vectorizer -gvn-hoist -flattencfg -gvn-hoist -forceattrs -mergeicmps -correlated-propagation -called-value-propagation -correlated-propagation -strip-debug-declare -pgo-memop-opt -rewrite-statepoints-for-gc -reassociate -gvn -guard-widening -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,61.67673325538635,opt -mldst-motion -aggressive-instcombine -loop-interchange -loop-idiom -gvn-hoist -simplifycfg -coro-split -speculative-execution -loop-idiom -load-store-vectorizer -separate-const-offset-from-gep -loop-fusion -inject-tli-mappings -coro-early -coro-early -loop-distribute -loop-load-elim -load-store-vectorizer -prune-eh -rpo-functionattrs -partially-inline-libcalls -ipconstprop -reg2mem -loop-versioning-licm -scalarizer -globalopt -loop-fusion -loop-unroll-and-jam -globalopt -adce -memcpyopt -libcalls-shrinkwrap -strip -coro-split -loop-simplifycfg -infer-address-spaces -partial-inliner -partial-inliner -early-cse-memssa -loop-deletion -licm -redundant-dbg-inst-elim -mergeicmps -ee-instrument -inferattrs -functionattrs -instcombine -indvars -sroa -die -newgvn -loop-distribute -scalarizer -pgo-memop-opt -instsimplify -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,61.70763802528381,opt -alignment-from-assumptions -mem2reg -dse -irce -loop-simplifycfg -adce -canonicalize-aliases -constprop -dse -newgvn -loop-unroll-and-jam -globalsplit -slp-vectorizer -loop-unroll -globalopt -scalarizer -mergeicmps -indvars -slsr -coro-cleanup -ee-instrument -partial-inliner -forceattrs -mergeicmps -indvars -simple-loop-unswitch -insert-gcov-profiling -simple-loop-unswitch -slsr -jump-threading -loop-sink -argpromotion -irce -lower-constant-intrinsics -loop-versioning -aggressive-instcombine -newgvn -lower-guard-intrinsic -cross-dso-cfi -ee-instrument -post-inline-ee-instrument -coro-elide -loop-fusion -forceattrs -coro-elide -adce -mergereturn -strip -lower-matrix-intrinsics -gvn-hoist -loop-unroll -rpo-functionattrs -mldst-motion -loweratomic -insert-gcov-profiling -simplifycfg -dse -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,61.71832275390625,opt -prune-eh -partially-inline-libcalls -slp-vectorizer -redundant-dbg-inst-elim -simplifycfg -prune-eh -loop-unroll -lowerinvoke -coro-elide -licm -loweratomic -gvn-hoist -lowerswitch -dse -loop-idiom -callsite-splitting -name-anon-globals -slsr -gvn -loop-unroll-and-jam -memcpyopt -break-crit-edges -sroa -dce -lower-constant-intrinsics -loop-unroll -sccp -aggressive-instcombine -instcombine -slp-vectorizer -attributor -reassociate -scalarizer -lower-matrix-intrinsics -guard-widening -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,61.74629616737366,opt -simple-loop-unswitch -early-cse-memssa -insert-gcov-profiling -loop-simplifycfg -lowerswitch -speculative-execution -float2int -separate-const-offset-from-gep -loop-data-prefetch -argpromotion -rewrite-statepoints-for-gc -strip-debug-declare -coro-cleanup -instcombine -called-value-propagation -loop-interchange -dse -libcalls-shrinkwrap -instcombine -jump-threading -aggressive-instcombine -functionattrs -loop-predication -sink -rewrite-statepoints-for-gc -redundant-dbg-inst-elim -always-inline -lowerswitch -gvn -simplifycfg -nary-reassociate -mergefunc -adce -cross-dso-cfi -separate-const-offset-from-gep -infer-address-spaces -loop-versioning-licm -partial-inliner -reassociate -loop-versioning-licm -dse -loop-sink -strip-debug-declare -gvn -float2int -loop-sink -attributor -lcssa -sroa -early-cse-memssa -gvn-hoist -jump-threading -redundant-dbg-inst-elim -simple-loop-unswitch -attributor -elim-avail-extern -guard-widening -loop-data-prefetch -aggressive-instcombine -constprop -lower-matrix-intrinsics -break-crit-edges -mem2reg -functionattrs -constprop -ipconstprop -loop-reroll -inject-tli-mappings -loop-data-prefetch -simple-loop-unswitch -loop-unroll-and-jam -rewrite-statepoints-for-gc -always-inline -inferattrs -lower-widenable-condition -licm -lower-matrix-intrinsics -strip -loop-fusion -callsite-splitting -sancov -strip-dead-prototypes -memcpyopt -globaldce -ipconstprop -adce -add-discriminators -instnamer -lower-widenable-condition -globaldce -loop-versioning-licm -pgo-memop-opt -loop-versioning -loop-versioning-licm -jump-threading -reassociate -memcpyopt -always-inline -insert-gcov-profiling -sink -simplifycfg -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,61.75835990905762,opt -partial-inliner -mem2reg -argpromotion -die -newgvn -globaldce -instcombine -called-value-propagation -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,61.77911853790283,opt -loweratomic -bdce -hotcoldsplit -loop-simplify -constmerge -sccp -libcalls-shrinkwrap -lower-matrix-intrinsics -slp-vectorizer -post-inline-ee-instrument -mergefunc -adce -callsite-splitting -coro-elide -instcombine -instnamer -libcalls-shrinkwrap -coro-elide -loop-predication -constmerge -lcssa -loop-vectorize -coro-elide -speculative-execution -sroa -gvn -break-crit-edges -strip-debug-declare -memcpyopt -correlated-propagation -newgvn -loop-reroll -sroa -gvn -prune-eh -mergereturn -lower-guard-intrinsic -coro-cleanup -scalarizer -mergeicmps -loop-unroll -instsimplify -mem2reg -sancov -mergeicmps -bdce -lowerswitch -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,61.824644327163696,opt -correlated-propagation -lower-matrix-intrinsics -canonicalize-aliases -reassociate -lower-matrix-intrinsics -loop-reroll -simplifycfg -loop-versioning-licm -lower-expect -loop-vectorize -loop-distribute -loop-data-prefetch -instnamer -strip-dead-prototypes -globaldce -post-inline-ee-instrument -mergefunc -loop-idiom -instnamer -lower-expect -coro-elide -lowerswitch -canonicalize-aliases -lower-constant-intrinsics -newgvn -bdce -mergereturn -loop-interchange -globalsplit -pgo-memop-opt -load-store-vectorizer -sancov -instsimplify -globaldce -infer-address-spaces -aggressive-instcombine -mergereturn -flattencfg -sroa -dse -loop-unroll-and-jam -callsite-splitting -nary-reassociate -coro-early -sroa -strip-dead-prototypes -bdce -bdce -guard-widening -indvars -break-crit-edges -libcalls-shrinkwrap -simplifycfg -sccp -coro-early -deadargelim -sancov -instcombine input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,61.877750396728516,opt -globalsplit -bdce -adce -loop-unswitch -ee-instrument -coro-cleanup -strip -loop-instsimplify -add-discriminators -globaldce -attributor -argpromotion -lowerinvoke -loop-vectorize -coro-elide -gvn -adce -bdce -loop-unroll -libcalls-shrinkwrap -callsite-splitting -partial-inliner -constprop -break-crit-edges -jump-threading -consthoist -loop-idiom -loop-instsimplify -globaldce -break-crit-edges -cross-dso-cfi -inject-tli-mappings -lower-matrix-intrinsics -libcalls-shrinkwrap -argpromotion -loop-idiom -coro-early -loop-predication -loop-reduce -gvn-hoist -always-inline -lower-constant-intrinsics -dse -strip-dead-prototypes -ipconstprop -reassociate -flattencfg -inferattrs -simple-loop-unswitch -redundant-dbg-inst-elim -gvn-hoist -speculative-execution -guard-widening -simple-loop-unswitch -separate-const-offset-from-gep -loop-sink -cross-dso-cfi -add-discriminators -alignment-from-assumptions -reassociate -adce -sancov -licm -forceattrs -loop-reroll -sroa -loop-load-elim -lower-matrix-intrinsics -loop-deletion -inferattrs -loop-interchange -infer-address-spaces -adce -load-store-vectorizer -lcssa -constmerge -coro-cleanup -aggressive-instcombine -early-cse-memssa -instcombine -canonicalize-aliases -mergefunc -alignment-from-assumptions -irce -alignment-from-assumptions -loop-instsimplify -sink -div-rem-pairs -instsimplify -constmerge -die -mem2reg -callsite-splitting -add-discriminators -instsimplify -loop-distribute -loop-guard-widening -mldst-motion -globaldce -infer-address-spaces -dse -pgo-memop-opt -mergefunc -ee-instrument -loop-unroll -break-crit-edges -strip -inject-tli-mappings -nary-reassociate -lcssa -loop-instsimplify -die -gvn-hoist -loop-simplify -strip-nondebug -loop-simplifycfg -rewrite-statepoints-for-gc -callsite-splitting -gvn-hoist -elim-avail-extern -lower-constant-intrinsics -alignment-from-assumptions -loop-idiom -reg2mem -loop-distribute -early-cse-memssa -always-inline -div-rem-pairs -add-discriminators -lower-widenable-condition -mergereturn -loop-reduce -strip-dead-prototypes -mldst-motion -mem2reg -slp-vectorizer -sroa -dse -reg2mem -partially-inline-libcalls -loop-versioning-licm -loop-deletion -lower-guard-intrinsic -constmerge -float2int -adce -callsite-splitting -loop-reroll -constmerge -loop-simplifycfg -mergereturn -loop-simplifycfg -mergefunc -loop-versioning-licm -cross-dso-cfi -infer-address-spaces -tailcallelim -lowerinvoke -loop-simplify -redundant-dbg-inst-elim -pgo-memop-opt -guard-widening -loop-sink -loop-interchange -gvn-hoist -loop-simplify -jump-threading -sancov -gvn -globaldce -globaldce -jump-threading -globaldce -inline -inline -float2int -loop-interchange -constprop -inject-tli-mappings -barrier -always-inline -insert-gcov-profiling -infer-address-spaces -coro-elide -dce -called-value-propagation -loop-sink -name-anon-globals -globaldce -strip -instcombine -functionattrs -mergereturn -loop-load-elim -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/crc32,1.0,61.91339898109436,opt -lower-expect -mem2reg -inferattrs -lower-guard-intrinsic -name-anon-globals -instsimplify -post-inline-ee-instrument -newgvn -loop-sink -hotcoldsplit -simplifycfg -add-discriminators -instcombine input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.9795918367346942,61.754926919937134,opt -prune-eh -separate-const-offset-from-gep -rpo-functionattrs -dce -argpromotion -name-anon-globals -loop-versioning -correlated-propagation -mem2reg -loop-deletion -simplifycfg -canonicalize-aliases -loop-versioning -lower-widenable-condition -gvn -tailcallelim -elim-avail-extern -gvn-hoist -argpromotion -loop-unroll -globaldce -loop-reroll -bdce -loop-guard-widening -correlated-propagation -reg2mem -prune-eh -redundant-dbg-inst-elim -argpromotion -loop-predication -loop-guard-widening -name-anon-globals -loop-unswitch -always-inline -flattencfg -simplifycfg -nary-reassociate -ipconstprop -forceattrs -partially-inline-libcalls -rpo-functionattrs -indvars -elim-avail-extern -always-inline -functionattrs -mem2reg -flattencfg -reassociate -adce -argpromotion -early-cse-memssa -globalsplit -slsr -early-cse-memssa -break-crit-edges -globalsplit -loop-predication -memcpyopt -load-store-vectorizer -libcalls-shrinkwrap -tailcallelim -insert-gcov-profiling -slp-vectorizer -consthoist -ipconstprop -strip-dead-prototypes -partially-inline-libcalls -separate-const-offset-from-gep -early-cse-memssa -correlated-propagation -load-store-vectorizer -instcombine -loop-idiom -loop-guard-widening -loop-data-prefetch -strip-dead-prototypes -always-inline -mldst-motion -gvn-hoist -loop-unswitch -partially-inline-libcalls -tailcallelim -deadargelim -instsimplify -lcssa -mem2reg -flattencfg -div-rem-pairs -strip-dead-prototypes -globalsplit -memcpyopt -strip-dead-prototypes -loop-instsimplify -loop-instsimplify -deadargelim -mergereturn -lower-matrix-intrinsics -simplifycfg -deadargelim -dse -loop-versioning -loop-simplify -globaldce -tailcallelim -break-crit-edges -break-crit-edges -lower-guard-intrinsic -infer-address-spaces -lower-matrix-intrinsics -rpo-functionattrs -coro-elide -forceattrs -called-value-propagation -loop-load-elim -loop-reduce -correlated-propagation -coro-early -newgvn -callsite-splitting -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.9795918367346942,61.764912128448486,opt -sancov -inferattrs -adce -loop-load-elim -argpromotion -redundant-dbg-inst-elim -constprop -rewrite-statepoints-for-gc -libcalls-shrinkwrap -always-inline -nary-reassociate -forceattrs -loop-simplifycfg -reassociate -lower-expect -coro-early -lowerswitch -jump-threading -globalsplit -reassociate -loop-load-elim -loop-versioning-licm -strip-debug-declare -coro-elide -sancov -barrier -loop-guard-widening -callsite-splitting -loop-data-prefetch -mem2reg -tailcallelim -float2int -insert-gcov-profiling -slsr -called-value-propagation -sccp -float2int -sroa -div-rem-pairs -mergefunc -loop-fusion -mergeicmps -libcalls-shrinkwrap -loop-load-elim -gvn-hoist -loop-sink -constmerge -instsimplify -pgo-memop-opt -mem2reg -loop-sink -flattencfg -lower-widenable-condition -flattencfg -load-store-vectorizer -memcpyopt -inferattrs -constmerge -loop-interchange -loop-reduce -rewrite-statepoints-for-gc -attributor -rpo-functionattrs -lower-expect -sancov -loop-distribute -strip -strip-nondebug -loop-interchange -gvn -scalarizer -insert-gcov-profiling -add-discriminators -add-discriminators -infer-address-spaces -break-crit-edges -bdce -loop-reroll -rpo-functionattrs -sroa -instnamer -constmerge -lower-widenable-condition -name-anon-globals -functionattrs -called-value-propagation -sccp -prune-eh -instcombine -lower-widenable-condition -canonicalize-aliases -mem2reg -globalsplit -slsr -partially-inline-libcalls -post-inline-ee-instrument -sroa -early-cse-memssa -add-discriminators -instsimplify -insert-gcov-profiling -mergereturn -always-inline -adce -lcssa -mergereturn -loop-idiom -indvars -libcalls-shrinkwrap -globaldce -coro-cleanup -coro-cleanup -mergefunc -canonicalize-aliases -sccp -inject-tli-mappings -lower-expect -loop-reroll -instnamer -simplifycfg -correlated-propagation input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.9285714285714286,62.132272481918335,opt -loop-guard-widening -consthoist -lower-expect -indvars -loop-reduce -simplifycfg -callsite-splitting -lower-matrix-intrinsics -correlated-propagation -reassociate -mldst-motion -ipconstprop -irce -lower-matrix-intrinsics -mergeicmps -globalopt -lowerswitch -bdce -strip-nondebug -partially-inline-libcalls -div-rem-pairs -forceattrs -globalsplit -barrier -functionattrs -loop-predication -loop-versioning-licm -libcalls-shrinkwrap -strip-debug-declare -constmerge -ipsccp -alignment-from-assumptions -ee-instrument -sancov -jump-threading -coro-split -gvn-hoist -die -bdce -loweratomic -dse -instsimplify -name-anon-globals -dce -tailcallelim -mergeicmps -callsite-splitting -speculative-execution -callsite-splitting -consthoist -irce -coro-early -mergereturn -loop-versioning-licm -loop-idiom -add-discriminators -globalsplit -loop-deletion -guard-widening -lower-expect -rewrite-statepoints-for-gc -loop-guard-widening -irce -nary-reassociate -dse -lowerinvoke -gvn -lower-constant-intrinsics -load-store-vectorizer -loop-simplify -lower-guard-intrinsic -partially-inline-libcalls -deadargelim -functionattrs -lower-widenable-condition -always-inline -ipconstprop -loop-simplify -aggressive-instcombine -sroa -div-rem-pairs -lower-guard-intrinsic -coro-elide -forceattrs -mergereturn -called-value-propagation -consthoist -lower-expect -simple-loop-unswitch -break-crit-edges -scalarizer -instcombine -mergereturn -loop-instsimplify -lower-widenable-condition -constprop -strip-dead-prototypes -flattencfg -loop-rotate -elim-avail-extern -slsr -rpo-functionattrs -forceattrs -strip-nondebug -tailcallelim -attributor -barrier -argpromotion -loop-unroll -nary-reassociate -die -libcalls-shrinkwrap -loop-versioning-licm -break-crit-edges -early-cse-memssa -rpo-functionattrs -correlated-propagation -rewrite-statepoints-for-gc -guard-widening -infer-address-spaces -reassociate -loop-deletion -callsite-splitting -die -simplifycfg -cross-dso-cfi -ipconstprop -inject-tli-mappings -barrier -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.9846938775510204,61.58521580696106,opt -hotcoldsplit -correlated-propagation -die -loop-versioning -mem2reg -early-cse-memssa -loop-load-elim -cross-dso-cfi -strip -tailcallelim -coro-cleanup -inferattrs -infer-address-spaces -functionattrs -loop-deletion -lower-expect -forceattrs -sroa -loop-simplifycfg -rpo-functionattrs -loop-simplifycfg -loop-distribute -mldst-motion -strip-debug-declare -div-rem-pairs -indvars -simple-loop-unswitch -lowerinvoke -lower-guard-intrinsic -globalopt -loop-data-prefetch -globaldce -always-inline -adce -lower-constant-intrinsics -newgvn -coro-cleanup -sccp -coro-cleanup -always-inline -ee-instrument -separate-const-offset-from-gep -tailcallelim -loop-idiom -adce -bdce -mergereturn -lower-matrix-intrinsics -redundant-dbg-inst-elim -loop-interchange -loop-simplifycfg -early-cse-memssa -nary-reassociate -alignment-from-assumptions -loop-deletion -loop-vectorize -strip -reassociate -break-crit-edges -load-store-vectorizer -elim-avail-extern -sccp -called-value-propagation -slsr -flattencfg -instcombine -cross-dso-cfi -name-anon-globals -simple-loop-unswitch -float2int -adce -correlated-propagation -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.9846938775510204,61.78147768974304,opt -loop-unroll-and-jam -simplifycfg -lower-guard-intrinsic -consthoist -lower-matrix-intrinsics -div-rem-pairs -loop-sink -early-cse-memssa -attributor -loop-unroll-and-jam -instnamer -globalopt -div-rem-pairs -dse -coro-early -licm -lowerswitch -loop-interchange -irce -loop-unswitch -called-value-propagation -canonicalize-aliases -loop-distribute -globalsplit -strip-nondebug -mldst-motion -lower-matrix-intrinsics -licm -mldst-motion -attributor -prune-eh -ipconstprop -loop-predication -div-rem-pairs -argpromotion -tailcallelim -consthoist -prune-eh -licm -loop-simplifycfg -die -loop-guard-widening -reassociate -consthoist -die -tailcallelim -ee-instrument -strip-debug-declare -consthoist -nary-reassociate -forceattrs -simplifycfg -strip-debug-declare -jump-threading -dse -sancov -mem2reg -irce -loop-guard-widening -mldst-motion -loop-idiom -loop-sink -prune-eh -deadargelim -separate-const-offset-from-gep -lowerinvoke -newgvn -elim-avail-extern -aggressive-instcombine -load-store-vectorizer -sroa -mldst-motion -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.9846938775510204,61.819502115249634,opt -elim-avail-extern -tailcallelim -indvars -loop-reduce -loop-reduce -loop-fusion -scalarizer -coro-elide -load-store-vectorizer -ipsccp -loop-simplifycfg -lower-expect -loop-interchange -argpromotion -memcpyopt -aggressive-instcombine -alignment-from-assumptions -aggressive-instcombine -loop-reduce -barrier -speculative-execution -speculative-execution -lower-guard-intrinsic -canonicalize-aliases -pgo-memop-opt -barrier -scalarizer -adce -ipsccp -loop-distribute -die -break-crit-edges -attributor -infer-address-spaces -loop-vectorize -mldst-motion -simple-loop-unswitch -mergefunc -break-crit-edges -simple-loop-unswitch -strip-nondebug -loop-simplifycfg -sroa -infer-address-spaces -sccp -bdce -globalsplit -loop-unroll -bdce -guard-widening -loop-simplify -rpo-functionattrs -redundant-dbg-inst-elim -argpromotion -lowerswitch -coro-split -forceattrs -lower-matrix-intrinsics -functionattrs -lower-constant-intrinsics -loop-idiom -post-inline-ee-instrument -mergefunc -loop-guard-widening -post-inline-ee-instrument -constmerge -deadargelim -pgo-memop-opt -loop-simplify -loop-sink -globalsplit -coro-cleanup -load-store-vectorizer -attributor -functionattrs -forceattrs -dse -forceattrs -constprop -correlated-propagation -gvn-hoist -licm -instsimplify -newgvn -mldst-motion -coro-cleanup -div-rem-pairs -separate-const-offset-from-gep -functionattrs -coro-split -name-anon-globals -mergereturn -strip-nondebug -canonicalize-aliases -cross-dso-cfi -instcombine -memcpyopt -coro-cleanup -globalopt -loop-predication -early-cse-memssa -pgo-memop-opt -sccp -sancov -early-cse-memssa -canonicalize-aliases -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.9846938775510206,61.72368288040161,opt -redundant-dbg-inst-elim -strip-debug-declare -float2int -coro-elide -coro-early -ipsccp -memcpyopt -indvars -jump-threading -loop-instsimplify -loop-reduce -mergefunc -div-rem-pairs -sroa -speculative-execution -lower-expect -callsite-splitting -loop-simplifycfg -correlated-propagation -dse -lcssa -redundant-dbg-inst-elim -memcpyopt -libcalls-shrinkwrap -partially-inline-libcalls -memcpyopt -coro-elide -loop-idiom -constmerge -loop-load-elim -loop-instsimplify -constmerge -sink -loop-interchange -correlated-propagation -attributor -rpo-functionattrs -aggressive-instcombine -mldst-motion -sancov -break-crit-edges -loop-fusion -consthoist -redundant-dbg-inst-elim -sccp -lower-matrix-intrinsics -loop-versioning-licm -lowerinvoke -called-value-propagation -cross-dso-cfi -sink -correlated-propagation -loop-fusion -globalsplit -coro-split -globaldce -name-anon-globals -tailcallelim -lowerswitch -globaldce -lowerswitch -reassociate -slp-vectorizer -reg2mem -functionattrs -lowerinvoke -barrier -elim-avail-extern -dce -load-store-vectorizer -coro-early -infer-address-spaces -sroa -scalarizer -loop-reroll -lower-expect -loop-versioning-licm -slsr -loop-reduce -libcalls-shrinkwrap -consthoist -attributor -loop-simplifycfg -loop-deletion -adce -infer-address-spaces -loop-versioning -attributor -lower-constant-intrinsics -load-store-vectorizer -loop-unroll-and-jam -dse -instsimplify -lower-constant-intrinsics -loop-unroll-and-jam -irce -prune-eh -newgvn -simplifycfg -break-crit-edges -irce -dse -lower-constant-intrinsics -always-inline -die -sroa -instcombine -inferattrs -coro-early -loop-reroll -simplifycfg -constprop -rewrite-statepoints-for-gc -redundant-dbg-inst-elim -bdce -float2int -canonicalize-aliases -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.9948979591836733,61.600799798965454,opt -argpromotion -irce -post-inline-ee-instrument -canonicalize-aliases -pgo-memop-opt -rpo-functionattrs -lower-constant-intrinsics -deadargelim -slp-vectorizer -name-anon-globals -loop-simplify -loop-load-elim -canonicalize-aliases -lower-constant-intrinsics -attributor -loop-deletion -globaldce -coro-early -mem2reg -adce -redundant-dbg-inst-elim -loop-versioning-licm -loweratomic -loop-interchange -partially-inline-libcalls -simplifycfg -coro-elide -globalopt -jump-threading -lowerinvoke -post-inline-ee-instrument -callsite-splitting -partially-inline-libcalls -infer-address-spaces -loop-distribute -redundant-dbg-inst-elim -called-value-propagation -mldst-motion -div-rem-pairs -attributor -strip-debug-declare -loop-versioning-licm -sroa -barrier -early-cse-memssa -loop-deletion -guard-widening -gvn-hoist -loop-predication -post-inline-ee-instrument -loop-unroll-and-jam -break-crit-edges -strip-dead-prototypes -strip-debug-declare -ipsccp -loop-unroll-and-jam -loop-fusion -callsite-splitting -loop-reroll -sink -loop-fusion -loop-unroll -early-cse-memssa -strip-dead-prototypes -elim-avail-extern -instsimplify -globalopt -deadargelim -die -argpromotion -called-value-propagation -ipsccp -attributor -argpromotion -loop-versioning-licm -load-store-vectorizer -lowerinvoke -separate-const-offset-from-gep -libcalls-shrinkwrap -loop-unroll -partial-inliner -scalarizer -sccp -callsite-splitting -elim-avail-extern -sroa -die -memcpyopt -deadargelim -slp-vectorizer -ipconstprop -name-anon-globals -sroa -loop-vectorize -loop-versioning-licm -coro-early -loop-reduce -constmerge -sink -loop-versioning -memcpyopt -loop-versioning -elim-avail-extern -loop-data-prefetch -barrier -simple-loop-unswitch -name-anon-globals -ee-instrument -add-discriminators -guard-widening -loop-reroll -loop-instsimplify -forceattrs -guard-widening -mldst-motion -mergefunc -barrier -mem2reg -redundant-dbg-inst-elim -guard-widening -instnamer -loop-reroll -instcombine -irce -mergefunc -strip-debug-declare -partial-inliner -lower-constant-intrinsics -loop-vectorize -instsimplify -newgvn -strip -strip-dead-prototypes -reassociate -functionattrs -tailcallelim -rewrite-statepoints-for-gc -loop-distribute -add-discriminators -lower-constant-intrinsics -functionattrs -guard-widening -loop-versioning -loop-load-elim -mem2reg -lowerinvoke -div-rem-pairs -gvn-hoist -callsite-splitting -constmerge -argpromotion -pgo-memop-opt -tailcallelim -rpo-functionattrs -slp-vectorizer -break-crit-edges -lower-constant-intrinsics -guard-widening -lower-expect -deadargelim -libcalls-shrinkwrap -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.9948979591836736,61.76611328125,opt -loop-idiom -pgo-memop-opt -flattencfg -attributor -flattencfg -strip -loop-deletion -elim-avail-extern -jump-threading -loop-data-prefetch -lower-expect -load-store-vectorizer -strip-debug-declare -partially-inline-libcalls -consthoist -mem2reg -loop-deletion -licm -lowerswitch -gvn-hoist -loop-simplify -mergereturn -alignment-from-assumptions -loop-simplify -mergefunc -loop-fusion -strip-debug-declare -deadargelim -constmerge -strip-debug-declare -consthoist -libcalls-shrinkwrap -partially-inline-libcalls -early-cse-memssa -loop-sink -newgvn -constmerge -strip-nondebug -speculative-execution -load-store-vectorizer -lowerinvoke -adce -always-inline -bdce -always-inline -lower-constant-intrinsics -dce -constprop -coro-early -strip-debug-declare -constprop -pgo-memop-opt -strip-nondebug -loop-sink -memcpyopt -forceattrs -rewrite-statepoints-for-gc -strip-nondebug -loop-vectorize -load-store-vectorizer -coro-elide -coro-cleanup -simple-loop-unswitch -pgo-memop-opt -always-inline -lower-expect -loop-unroll -indvars -loop-data-prefetch -loop-data-prefetch -post-inline-ee-instrument -dce -lower-matrix-intrinsics -canonicalize-aliases -instcombine -loop-instsimplify -irce -loop-guard-widening -mem2reg -correlated-propagation -instsimplify -loop-predication -barrier -callsite-splitting -coro-split -mem2reg -reassociate -reassociate -bdce -loop-data-prefetch -loop-reroll -rpo-functionattrs -correlated-propagation -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/dijkstra,0.9948979591836736,61.780680894851685,opt -tailcallelim -pgo-memop-opt -loop-simplifycfg -loop-instsimplify -coro-elide -hotcoldsplit -correlated-propagation -newgvn -coro-cleanup -nary-reassociate -constprop -coro-early -always-inline -strip-nondebug -functionattrs -lowerswitch -separate-const-offset-from-gep -mergeicmps -simplifycfg -loop-instsimplify -die -ee-instrument -loop-simplifycfg -redundant-dbg-inst-elim -ipsccp -loop-unroll-and-jam -load-store-vectorizer -simple-loop-unswitch -licm -adce -callsite-splitting -prune-eh -flattencfg -inferattrs -ee-instrument -lower-constant-intrinsics -add-discriminators -simplifycfg -loop-reduce -lowerswitch -sancov -loop-reduce -newgvn -alignment-from-assumptions -elim-avail-extern -coro-early -indvars -sroa -speculative-execution -indvars -reassociate -licm -reassociate -constprop -loop-instsimplify -add-discriminators -attributor -called-value-propagation -insert-gcov-profiling -loop-unroll -rewrite-statepoints-for-gc -strip-dead-prototypes -adce -dse -licm -post-inline-ee-instrument -instcombine -simple-loop-unswitch -canonicalize-aliases -lower-widenable-condition -constmerge -newgvn -coro-cleanup -infer-address-spaces -loop-interchange -instsimplify -canonicalize-aliases -loop-versioning -separate-const-offset-from-gep -forceattrs -adce -always-inline -reg2mem -constmerge -sancov -aggressive-instcombine -scalarizer -forceattrs -ipsccp -ee-instrument -scalarizer -reg2mem -redundant-dbg-inst-elim -sroa -inject-tli-mappings -barrier -bdce -flattencfg -nary-reassociate -instnamer -loop-load-elim -reassociate -loop-vectorize -sccp -nary-reassociate -separate-const-offset-from-gep -correlated-propagation -instnamer -strip-debug-declare -barrier -div-rem-pairs -aggressive-instcombine -instsimplify -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/ghostscript,0.9683191859499436,742.1303203105927,opt -loweratomic -dse -add-discriminators -alignment-from-assumptions -attributor -memcpyopt -post-inline-ee-instrument -reg2mem -alignment-from-assumptions -guard-widening -coro-early -infer-address-spaces -elim-avail-extern -simplifycfg -globaldce -mergeicmps -loop-interchange -alignment-from-assumptions -ipsccp -rewrite-statepoints-for-gc -break-crit-edges -lower-matrix-intrinsics -reassociate -dse -loop-simplifycfg -infer-address-spaces -loop-unroll-and-jam -loop-versioning -loop-unswitch -indvars -barrier -flattencfg -newgvn -mergereturn -inject-tli-mappings -lower-matrix-intrinsics -loop-predication -slp-vectorizer -coro-split -gvn-hoist -dse -indvars -coro-split -called-value-propagation -newgvn -loop-unroll-and-jam -guard-widening -lower-expect -slp-vectorizer -sink -alignment-from-assumptions -lower-constant-intrinsics -lower-widenable-condition -loop-simplify -globaldce -attributor -mldst-motion -early-cse-memssa -inject-tli-mappings -strip-dead-prototypes -instnamer -dse -globalopt -ipsccp -float2int -coro-early -argpromotion -slp-vectorizer -correlated-propagation -licm -instnamer -coro-cleanup -mergereturn -irce -globaldce -mergeicmps -instsimplify -sancov -loop-reroll -lcssa -lowerswitch -jump-threading -constprop -die -dse -indvars -strip-dead-prototypes -always-inline -loop-distribute -slsr -mergereturn -lower-expect -loop-simplifycfg -mldst-motion -loop-simplify -strip-dead-prototypes -instsimplify -loop-reroll -separate-const-offset-from-gep -lowerinvoke -float2int -loop-data-prefetch -loop-versioning -mem2reg -gvn-hoist -sccp -functionattrs -loop-unswitch -loop-distribute -flattencfg -insert-gcov-profiling -prune-eh -tailcallelim -inferattrs -always-inline -indvars -dse -aggressive-instcombine -consthoist -post-inline-ee-instrument -ipsccp -lower-expect -globalsplit -globaldce -loop-vectorize -loop-reroll -loop-simplifycfg -loop-unroll -memcpyopt -instsimplify -coro-cleanup -coro-cleanup -loop-reroll -loweratomic -mldst-motion -lower-constant-intrinsics -add-discriminators -tailcallelim -strip -loop-data-prefetch -coro-cleanup -coro-cleanup -bdce -slp-vectorizer -newgvn -attributor -lower-expect -loop-versioning -callsite-splitting -libcalls-shrinkwrap -dse -irce -instcombine -ipconstprop -dse -strip-dead-prototypes -libcalls-shrinkwrap -coro-cleanup -guard-widening -inferattrs -barrier -early-cse-memssa -separate-const-offset-from-gep -lowerswitch -instsimplify -loop-distribute -lower-constant-intrinsics -prune-eh -partially-inline-libcalls -lower-matrix-intrinsics -insert-gcov-profiling -coro-elide -mem2reg -loop-versioning -scalarizer -alignment-from-assumptions -coro-cleanup -consthoist -elim-avail-extern -dce -loop-reduce -lowerswitch -strip-debug-declare -indvars -cross-dso-cfi -loop-instsimplify -globalsplit -loop-deletion -slp-vectorizer -sccp -break-crit-edges -add-discriminators -loop-reduce -indvars -coro-elide -loop-interchange -coro-split -strip-debug-declare -ipconstprop -loop-simplify -globalsplit -coro-elide -sroa -coro-cleanup -flattencfg -loop-data-prefetch -sccp -loweratomic -memcpyopt -loop-vectorize -functionattrs -loop-unroll -canonicalize-aliases -deadargelim -insert-gcov-profiling -irce -mergefunc -loop-interchange -lowerinvoke -ee-instrument -adce -constprop -lcssa -hotcoldsplit -aggressive-instcombine -mem2reg -called-value-propagation -lcssa -tailcallelim -inject-tli-mappings -bdce -sink -dse -inject-tli-mappings -constprop -forceattrs -functionattrs -hotcoldsplit -ipconstprop -consthoist -strip -lower-expect -infer-address-spaces -sroa -mergereturn -dse -newgvn -dse -slsr -loop-fusion -flattencfg -loop-versioning-licm -sancov -always-inline -partially-inline-libcalls -add-discriminators -elim-avail-extern -loop-interchange -sroa -slsr -lower-guard-intrinsic -dce -load-store-vectorizer -simplifycfg -rpo-functionattrs -name-anon-globals -elim-avail-extern -gvn-hoist -cross-dso-cfi -instsimplify -jump-threading input.bc -o output.bc +benchmark://cbench-v1/ghostscript,0.9694556389925783,492.34522247314453,opt -tailcallelim -loop-rotate -adce -constprop -loop-rotate -rewrite-statepoints-for-gc -elim-avail-extern -post-inline-ee-instrument -strip-debug-declare -constprop -functionattrs -sccp -gvn -flattencfg -constprop -loop-instsimplify -separate-const-offset-from-gep -sccp -die -attributor -canonicalize-aliases -indvars -constprop -sink -loop-reroll -elim-avail-extern -loop-instsimplify -rewrite-statepoints-for-gc -tailcallelim -lower-widenable-condition -irce -hotcoldsplit -float2int -coro-early -sancov -ipsccp -loop-deletion -simplifycfg -loop-guard-widening -strip -callsite-splitting -constmerge -loweratomic -loop-deletion -loop-simplifycfg -loop-predication -mergeicmps -post-inline-ee-instrument -sroa -ee-instrument -coro-split -loop-simplify -lcssa -correlated-propagation -mergeicmps -lowerinvoke -instcombine -loop-guard-widening -separate-const-offset-from-gep -lowerswitch -newgvn -instcombine -simplifycfg -deadargelim -inject-tli-mappings -mergeicmps -float2int -lower-matrix-intrinsics -instsimplify input.bc -o output.bc +benchmark://cbench-v1/ghostscript,0.9789275380056125,292.0016040802002,opt -forceattrs -separate-const-offset-from-gep -hotcoldsplit -attributor -indvars -loop-unroll -add-discriminators -licm -canonicalize-aliases -reg2mem -bdce -slp-vectorizer -lower-matrix-intrinsics -loop-reduce -loop-distribute -guard-widening -coro-early -early-cse-memssa -load-store-vectorizer -alignment-from-assumptions -name-anon-globals -argpromotion -loop-load-elim -always-inline -early-cse-memssa -licm -memcpyopt -gvn -name-anon-globals -callsite-splitting -gvn-hoist -loop-instsimplify -gvn-hoist -loop-versioning -mldst-motion -attributor -separate-const-offset-from-gep -loop-fusion -rewrite-statepoints-for-gc -dce -coro-early -forceattrs -loop-sink -dce -lower-expect -consthoist -newgvn -loop-unroll-and-jam -memcpyopt -reassociate -speculative-execution -nary-reassociate -mergefunc -loop-deletion -ipsccp -bdce -tailcallelim -rewrite-statepoints-for-gc -scalarizer -functionattrs -deadargelim -loop-simplify -irce -attributor -name-anon-globals -loop-versioning -loop-vectorize -flattencfg -globalopt -partially-inline-libcalls -coro-early -early-cse-memssa -coro-cleanup -strip-dead-prototypes -name-anon-globals -rpo-functionattrs -lower-constant-intrinsics -redundant-dbg-inst-elim -prune-eh -loop-reroll -separate-const-offset-from-gep -sroa -lowerinvoke -irce -loop-unroll-and-jam -rewrite-statepoints-for-gc -coro-split -inject-tli-mappings -name-anon-globals -cross-dso-cfi -mergeicmps -aggressive-instcombine -loop-vectorize -memcpyopt -globaldce -guard-widening -ipsccp -jump-threading -strip -loop-simplify -mergereturn -instcombine -gvn -loop-vectorize -bdce -nary-reassociate -barrier -dse input.bc -o output.bc +benchmark://cbench-v1/ghostscript,0.9792815868381253,275.35339760780334,opt -rewrite-statepoints-for-gc -loop-unroll-and-jam -partially-inline-libcalls -coro-elide -globalopt -alignment-from-assumptions -div-rem-pairs -lowerinvoke -inferattrs -lower-constant-intrinsics -loop-load-elim -instnamer -loweratomic -constmerge -loop-vectorize -post-inline-ee-instrument -loop-vectorize -loop-reroll -instnamer -loop-simplify -coro-elide -loop-unroll -loop-versioning -partial-inliner -loop-deletion -rpo-functionattrs -simplifycfg -loweratomic -jump-threading -reg2mem -loop-unroll-and-jam -indvars -instsimplify -ipconstprop -inject-tli-mappings -callsite-splitting -called-value-propagation -float2int -break-crit-edges -correlated-propagation -coro-early -infer-address-spaces -strip-dead-prototypes -loop-idiom -loop-interchange -memcpyopt -dce -loop-unroll -consthoist -lower-expect -mergereturn -dce -loop-fusion -rewrite-statepoints-for-gc -loop-idiom -loop-unroll -instsimplify -aggressive-instcombine -called-value-propagation -sroa -loop-idiom -loop-predication -slp-vectorizer -libcalls-shrinkwrap -strip -loop-versioning-licm -rewrite-statepoints-for-gc -barrier -instcombine -loop-unroll -lower-constant-intrinsics -partial-inliner -simple-loop-unswitch -mergeicmps -mergeicmps -insert-gcov-profiling -loweratomic -mem2reg -hotcoldsplit -lower-matrix-intrinsics -loop-interchange -constprop -simplifycfg -die -alignment-from-assumptions -rpo-functionattrs -newgvn input.bc -o output.bc +benchmark://cbench-v1/ghostscript,0.9801208137003785,266.2952723503113,opt -strip-debug-declare -simple-loop-unswitch -div-rem-pairs -rewrite-statepoints-for-gc -loop-sink -insert-gcov-profiling -simplifycfg -flattencfg -lower-widenable-condition -loop-simplifycfg -strip-nondebug -adce -partial-inliner -strip-dead-prototypes -add-discriminators -rewrite-statepoints-for-gc -lower-widenable-condition -loop-unroll-and-jam -coro-early -coro-split -reassociate -separate-const-offset-from-gep -hotcoldsplit -lowerinvoke -reassociate -strip-debug-declare -rpo-functionattrs -flattencfg -prune-eh -load-store-vectorizer -barrier -strip-debug-declare -sroa -coro-split -gvn -infer-address-spaces -aggressive-instcombine -sink -newgvn -bdce -loweratomic -dce -prune-eh -loop-vectorize -simple-loop-unswitch -redundant-dbg-inst-elim -strip -loop-interchange -rpo-functionattrs -nary-reassociate -ipsccp -rpo-functionattrs -loop-fusion -loop-vectorize -sancov -globaldce -instcombine -loop-unroll -partial-inliner -newgvn -instcombine -functionattrs -insert-gcov-profiling -coro-cleanup -loop-guard-widening -infer-address-spaces -loop-unroll-and-jam -jump-threading -called-value-propagation -loop-simplifycfg -aggressive-instcombine -constprop -loop-vectorize -strip-nondebug -lcssa -elim-avail-extern -alignment-from-assumptions -lower-guard-intrinsic -gvn -slsr -simple-loop-unswitch -redundant-dbg-inst-elim -scalarizer -lcssa -lowerinvoke -redundant-dbg-inst-elim -callsite-splitting -sink -constprop -tailcallelim -lower-guard-intrinsic -redundant-dbg-inst-elim -loop-load-elim -div-rem-pairs -libcalls-shrinkwrap -float2int -loop-vectorize -guard-widening -jump-threading -functionattrs -mldst-motion -gvn -mergereturn -constprop -dse -alignment-from-assumptions -infer-address-spaces -coro-early -simplifycfg -die input.bc -o output.bc +benchmark://cbench-v1/ghostscript,0.9816987350403442,358.9749844074249,opt -mem2reg -lower-expect -sccp -reassociate -mergereturn -correlated-propagation -barrier -attributor -simplifycfg -rpo-functionattrs -rewrite-statepoints-for-gc -aggressive-instcombine -slsr -loop-load-elim -constprop -instsimplify -add-discriminators -lowerinvoke -scalarizer -instsimplify -insert-gcov-profiling -coro-early -loop-sink -deadargelim -aggressive-instcombine -forceattrs -loop-unroll-and-jam -constprop -globalsplit -bdce -mergereturn -speculative-execution -strip-dead-prototypes -lower-matrix-intrinsics -sancov -nary-reassociate -callsite-splitting -ipconstprop -globaldce -simplifycfg -partially-inline-libcalls -redundant-dbg-inst-elim -ipconstprop -separate-const-offset-from-gep -licm -elim-avail-extern -scalarizer -alignment-from-assumptions -ee-instrument -lower-constant-intrinsics -partially-inline-libcalls -hotcoldsplit -instcombine -strip-nondebug -forceattrs -jump-threading -loop-distribute -lcssa -strip-debug-declare -loop-unroll -constmerge -deadargelim -globalopt -constmerge -lower-constant-intrinsics -inject-tli-mappings -mem2reg -sancov -always-inline -constmerge -deadargelim -globaldce -loop-sink -name-anon-globals -loop-instsimplify -post-inline-ee-instrument -loop-simplify -instsimplify -die -strip -mergereturn -mem2reg -elim-avail-extern -lower-matrix-intrinsics -indvars -break-crit-edges -scalarizer -alignment-from-assumptions -tailcallelim -loop-vectorize -speculative-execution -inject-tli-mappings -lowerswitch -instnamer -attributor -gvn-hoist -instcombine -die -coro-split -lower-guard-intrinsic -ee-instrument -sink -loop-versioning -reassociate -loop-versioning -dce -mergereturn -slsr -attributor -mergereturn -name-anon-globals -speculative-execution -constprop -speculative-execution -rpo-functionattrs -loop-vectorize -ipconstprop -canonicalize-aliases -mergeicmps -canonicalize-aliases -loop-simplify -loop-instsimplify -separate-const-offset-from-gep -lower-widenable-condition -newgvn -strip-nondebug -speculative-execution -coro-cleanup -globaldce -loop-sink -bdce -globaldce -dce -instsimplify -globaldce -instcombine -globalopt -callsite-splitting -jump-threading -bdce input.bc -o output.bc +benchmark://cbench-v1/ghostscript,0.985794336967069,404.01260805130005,opt -coro-cleanup -reassociate -called-value-propagation -break-crit-edges -pgo-memop-opt -loop-vectorize -loop-versioning-licm -mem2reg -indvars -mem2reg -sroa -strip-dead-prototypes -mldst-motion -add-discriminators -loop-unswitch -loop-distribute -loop-unroll-and-jam -strip -rewrite-statepoints-for-gc -forceattrs -reassociate -newgvn -jump-threading -attributor -flattencfg -loop-instsimplify -slsr -loop-deletion -loop-reroll -lower-expect -slp-vectorizer -reg2mem -loop-versioning -ipsccp -indvars -newgvn -globalsplit -tailcallelim -speculative-execution -sancov -strip-nondebug -licm -lower-expect -coro-split -globaldce -loop-load-elim -consthoist -loop-reroll -loop-versioning -constmerge -loop-guard-widening -strip -infer-address-spaces -lcssa -loop-versioning -break-crit-edges -ipsccp -loop-sink -post-inline-ee-instrument -loop-deletion -lowerinvoke -forceattrs -ipsccp -add-discriminators -ipconstprop -globaldce -add-discriminators -aggressive-instcombine -inject-tli-mappings -float2int -deadargelim -separate-const-offset-from-gep -strip-debug-declare -mergereturn -licm -name-anon-globals -add-discriminators -sroa -instcombine -strip-nondebug -libcalls-shrinkwrap -consthoist -mergereturn -loop-reroll -separate-const-offset-from-gep -aggressive-instcombine -loop-idiom -sancov -slsr -sink -mergereturn -gvn -rewrite-statepoints-for-gc -partially-inline-libcalls -loop-unroll -canonicalize-aliases -constprop -inject-tli-mappings -loop-unroll-and-jam -flattencfg -prune-eh -dse -licm -adce -loop-deletion -instnamer -div-rem-pairs -add-discriminators -early-cse-memssa -canonicalize-aliases -guard-widening -loop-idiom -lcssa -lowerinvoke -lower-constant-intrinsics -redundant-dbg-inst-elim -reassociate -loop-versioning-licm -name-anon-globals -div-rem-pairs -loop-data-prefetch -mem2reg -loop-sink -instcombine -loop-deletion -lower-widenable-condition -strip -loop-reroll -functionattrs -ipsccp -loop-load-elim -redundant-dbg-inst-elim -flattencfg -deadargelim -jump-threading -bdce -consthoist -nary-reassociate -newgvn input.bc -o output.bc +benchmark://cbench-v1/ghostscript,0.9872236452168439,293.0374753475189,opt -lowerswitch -name-anon-globals -constmerge -canonicalize-aliases -post-inline-ee-instrument -inject-tli-mappings -consthoist -sink -loop-versioning -strip-nondebug -alignment-from-assumptions -sancov -partially-inline-libcalls -correlated-propagation -globaldce -consthoist -aggressive-instcombine -dse -loop-vectorize -lower-expect -div-rem-pairs -loop-deletion -pgo-memop-opt -loop-simplify -memcpyopt -barrier -globalopt -flattencfg -sroa -memcpyopt -loop-deletion -mergereturn -prune-eh -div-rem-pairs -insert-gcov-profiling -break-crit-edges -lowerinvoke -float2int -elim-avail-extern -prune-eh -loop-reduce -loop-predication -tailcallelim -argpromotion -argpromotion -memcpyopt -guard-widening -partially-inline-libcalls -barrier -globaldce -indvars -strip-dead-prototypes -constprop -instcombine -jump-threading -redundant-dbg-inst-elim -float2int -memcpyopt -attributor -die -called-value-propagation -functionattrs -alignment-from-assumptions -speculative-execution -simplifycfg -gvn -lower-expect -add-discriminators -constmerge -loop-load-elim -break-crit-edges -ipsccp -globalsplit -jump-threading -strip -div-rem-pairs -functionattrs -pgo-memop-opt -dce -mem2reg -canonicalize-aliases -instsimplify -functionattrs -mem2reg -hotcoldsplit -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/ghostscript,0.9906854560236381,478.18332958221436,opt -ee-instrument -aggressive-instcombine -lower-constant-intrinsics -post-inline-ee-instrument -simplifycfg -licm -scalarizer -slsr -simple-loop-unswitch -add-discriminators -constmerge -elim-avail-extern -tailcallelim -rewrite-statepoints-for-gc -scalarizer -instsimplify -consthoist -correlated-propagation -mergereturn -callsite-splitting -reassociate -load-store-vectorizer -sroa -inferattrs -div-rem-pairs -die -loop-versioning -strip-nondebug -scalarizer -reassociate -attributor -loop-simplifycfg -loop-unroll-and-jam -flattencfg -argpromotion -instcombine -loop-simplify -loweratomic -speculative-execution -always-inline -strip-nondebug -gvn-hoist -strip -loop-interchange -canonicalize-aliases -load-store-vectorizer -newgvn -lcssa -canonicalize-aliases -break-crit-edges -jump-threading -infer-address-spaces -libcalls-shrinkwrap -correlated-propagation -jump-threading -inject-tli-mappings -name-anon-globals -always-inline -memcpyopt -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/ghostscript,1.001337517811716,288.97663617134094,opt -loop-interchange -lowerswitch -loop-fusion -mergeicmps -constprop -reassociate -attributor -mem2reg -lower-guard-intrinsic -argpromotion -mergefunc -hotcoldsplit -coro-split -name-anon-globals -newgvn -post-inline-ee-instrument -instcombine -always-inline -speculative-execution -coro-elide -prune-eh -nary-reassociate -licm -prune-eh -canonicalize-aliases -jump-threading -canonicalize-aliases -instsimplify -sink -dce -strip-dead-prototypes -strip -name-anon-globals -memcpyopt -forceattrs -gvn-hoist -post-inline-ee-instrument -canonicalize-aliases -redundant-dbg-inst-elim -prune-eh -sroa -simplifycfg -functionattrs -infer-address-spaces -lower-guard-intrinsic -add-discriminators -loop-instsimplify -mem2reg -irce -simple-loop-unswitch -flattencfg -newgvn -newgvn input.bc -o output.bc +benchmark://cbench-v1/gsm,1.049551792828685,62.63266634941101,opt -called-value-propagation -dce -gvn-hoist -irce -sroa -argpromotion -lcssa -barrier -adce -nary-reassociate -ipconstprop -loop-unroll-and-jam -licm -adce -bdce -lower-widenable-condition -cross-dso-cfi -aggressive-instcombine -loop-reroll -memcpyopt -mldst-motion -loop-unroll -loop-simplifycfg -guard-widening -loop-reroll -loop-distribute -globalsplit -loop-fusion -slsr -newgvn -argpromotion -loop-interchange -coro-cleanup -div-rem-pairs -adce -sink -canonicalize-aliases -strip-dead-prototypes -slp-vectorizer -simplifycfg -gvn-hoist -coro-split -functionattrs -loop-vectorize -loop-reroll -globalopt -coro-cleanup -lower-constant-intrinsics -loop-reroll -load-store-vectorizer -inferattrs -reassociate -instsimplify -coro-elide -strip-nondebug -instcombine -loop-instsimplify -lower-expect -pgo-memop-opt -loop-interchange -early-cse-memssa -loop-vectorize -elim-avail-extern -consthoist -consthoist -slsr -loop-unswitch -loop-distribute -guard-widening -loop-fusion -coro-split -gvn-hoist -lower-guard-intrinsic -canonicalize-aliases -lower-guard-intrinsic -simplifycfg -jump-threading input.bc -o output.bc +benchmark://cbench-v1/gsm,1.0515438247011952,64.79662609100342,opt -canonicalize-aliases -nary-reassociate -loop-load-elim -slp-vectorizer -globalsplit -loop-distribute -correlated-propagation -argpromotion -instcombine -sroa -ipsccp -loop-versioning -ipsccp -loop-unroll-and-jam -adce -always-inline -argpromotion -partially-inline-libcalls -dse -rpo-functionattrs -instcombine -sancov -loop-instsimplify -barrier -attributor -insert-gcov-profiling -div-rem-pairs -load-store-vectorizer -loop-versioning-licm -constmerge -coro-elide -loop-load-elim -consthoist -simplifycfg -separate-const-offset-from-gep -infer-address-spaces -lower-widenable-condition -loop-deletion -mergefunc -loop-instsimplify -load-store-vectorizer -consthoist -irce -post-inline-ee-instrument -callsite-splitting -cross-dso-cfi -pgo-memop-opt -strip -simplifycfg -guard-widening -strip-nondebug -load-store-vectorizer -loop-reduce -mergereturn -ipconstprop -mergereturn -loop-sink -flattencfg -float2int -lowerinvoke -infer-address-spaces -simple-loop-unswitch -gvn -constmerge -mem2reg -mergereturn -sccp -guard-widening -name-anon-globals -loop-reduce -slp-vectorizer -indvars -sancov -loop-unswitch -slsr -mldst-motion -loop-instsimplify -always-inline -attributor -instcombine input.bc -o output.bc +benchmark://cbench-v1/gsm,1.052290836653386,63.34988474845886,opt -coro-elide -speculative-execution -mergeicmps -globaldce -speculative-execution -gvn -slp-vectorizer -div-rem-pairs -ipsccp -coro-cleanup -constprop -attributor -strip-dead-prototypes -callsite-splitting -mergefunc -consthoist -dce -aggressive-instcombine -loop-sink -strip -mem2reg -inferattrs -loop-interchange -mem2reg -strip -consthoist -mergereturn -bdce -mem2reg -callsite-splitting -loop-deletion -inferattrs -constmerge -ee-instrument -separate-const-offset-from-gep -loop-simplifycfg -ee-instrument -irce -argpromotion -barrier -separate-const-offset-from-gep -jump-threading -mergeicmps -dce -adce -loop-data-prefetch -loweratomic -coro-split -rpo-functionattrs -ipconstprop -float2int -sroa -lower-matrix-intrinsics -loop-vectorize -dce -guard-widening -coro-elide -simplifycfg -loop-unroll-and-jam -mem2reg -lower-widenable-condition -jump-threading -inferattrs -mergereturn -functionattrs -loop-guard-widening -loop-fusion -insert-gcov-profiling -irce -loop-simplify -lowerinvoke -constmerge -loop-reroll -strip-dead-prototypes -sroa -mldst-motion -slsr -float2int -loop-simplify -functionattrs -loop-data-prefetch -lower-expect -infer-address-spaces -tailcallelim -instsimplify -cross-dso-cfi -dce -irce -instcombine -coro-split -newgvn -loop-versioning -always-inline -lower-matrix-intrinsics -mergeicmps -functionattrs -post-inline-ee-instrument -coro-early -mergeicmps -licm -instnamer -slp-vectorizer -speculative-execution -functionattrs -coro-early -loop-versioning -indvars -loop-idiom -globalopt -strip-dead-prototypes -called-value-propagation -name-anon-globals -nary-reassociate -loop-instsimplify -loop-reduce -mergefunc -loop-predication -mergereturn -rpo-functionattrs -libcalls-shrinkwrap -dse -memcpyopt -lower-expect -indvars -dce -instcombine -cross-dso-cfi -die -mldst-motion -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/gsm,1.0586404382470118,62.90404176712036,opt -always-inline -lower-matrix-intrinsics -lcssa -dse -deadargelim -pgo-memop-opt -coro-elide -guard-widening -separate-const-offset-from-gep -insert-gcov-profiling -libcalls-shrinkwrap -separate-const-offset-from-gep -loop-instsimplify -lower-constant-intrinsics -nary-reassociate -coro-early -prune-eh -indvars -loop-unswitch -barrier -sccp -deadargelim -constprop -loop-reroll -sink -loop-versioning-licm -loop-predication -ipsccp -ipconstprop -globalopt -sink -constprop -loop-instsimplify -lowerinvoke -pgo-memop-opt -early-cse-memssa -lowerinvoke -callsite-splitting -deadargelim -pgo-memop-opt -sancov -post-inline-ee-instrument -simple-loop-unswitch -sroa -loop-versioning-licm -loop-interchange -instsimplify -indvars -flattencfg -slp-vectorizer -always-inline -instcombine -infer-address-spaces -add-discriminators -break-crit-edges -ipconstprop -slsr -simplifycfg -correlated-propagation -load-store-vectorizer -instcombine -rewrite-statepoints-for-gc -lower-widenable-condition -instcombine -div-rem-pairs -elim-avail-extern input.bc -o output.bc +benchmark://cbench-v1/gsm,1.0632470119521908,65.17371106147766,opt -ipconstprop -mem2reg -reg2mem -ee-instrument -inferattrs -break-crit-edges -sancov -loop-vectorize -rpo-functionattrs -consthoist -loop-unroll-and-jam -coro-elide -always-inline -loop-fusion -bdce -loop-idiom -functionattrs -strip-nondebug -constprop -div-rem-pairs -loop-simplify -slp-vectorizer -loop-sink -name-anon-globals -loop-interchange -loop-load-elim -rpo-functionattrs -redundant-dbg-inst-elim -guard-widening -add-discriminators -correlated-propagation -instcombine -loop-predication -memcpyopt -early-cse-memssa -insert-gcov-profiling -rpo-functionattrs -gvn -redundant-dbg-inst-elim -loop-unroll-and-jam -div-rem-pairs -loop-reduce -ipconstprop -consthoist -functionattrs -mergereturn -loop-simplify -loop-guard-widening -sink -newgvn -lower-guard-intrinsic -loop-simplifycfg -separate-const-offset-from-gep -rewrite-statepoints-for-gc -guard-widening -scalarizer -die -strip-debug-declare -loop-rotate -partial-inliner -newgvn -bdce -gvn-hoist -sancov -loop-guard-widening -post-inline-ee-instrument -strip-nondebug -lower-widenable-condition -loop-interchange -indvars -dse -loop-load-elim -ipconstprop -always-inline -partially-inline-libcalls -loop-predication -loop-guard-widening -sroa -load-store-vectorizer -load-store-vectorizer -instcombine -rpo-functionattrs -simple-loop-unswitch -barrier -loop-guard-widening -simple-loop-unswitch -attributor -lcssa -sccp -name-anon-globals -attributor -guard-widening -early-cse-memssa -float2int -infer-address-spaces -simple-loop-unswitch -reassociate -globalsplit -loop-predication -lower-matrix-intrinsics -slp-vectorizer -constmerge -globalopt -instcombine -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/gsm,1.0634960159362552,65.4237732887268,opt -consthoist -loop-instsimplify -rpo-functionattrs -forceattrs -lowerswitch -constprop -loop-unswitch -gvn -argpromotion -div-rem-pairs -loop-unswitch -consthoist -loop-instsimplify -lower-widenable-condition -infer-address-spaces -simple-loop-unswitch -loop-reroll -loop-simplify -always-inline -constmerge -separate-const-offset-from-gep -globalsplit -loop-load-elim -lower-expect -irce -lower-matrix-intrinsics -name-anon-globals -loop-load-elim -early-cse-memssa -float2int -loop-simplify -lowerswitch -simple-loop-unswitch -always-inline -argpromotion -loop-predication -instsimplify -instnamer -globalopt -name-anon-globals -adce -gvn-hoist -reg2mem -redundant-dbg-inst-elim -loop-deletion -newgvn -sccp -called-value-propagation -mem2reg -loop-unswitch -inferattrs -loop-guard-widening -dce -globaldce -nary-reassociate -flattencfg -called-value-propagation -simplifycfg -correlated-propagation -coro-cleanup -sink -mldst-motion -slsr -strip-nondebug -inject-tli-mappings -loop-unroll-and-jam -loop-distribute -speculative-execution -libcalls-shrinkwrap -rewrite-statepoints-for-gc -coro-elide -early-cse-memssa -always-inline -mergeicmps -instsimplify -functionattrs -sroa -partially-inline-libcalls -nary-reassociate -instcombine -attributor -infer-address-spaces -loop-simplify -simple-loop-unswitch -sink -loop-versioning -canonicalize-aliases -redundant-dbg-inst-elim -deadargelim -lower-expect -inject-tli-mappings -lower-widenable-condition -load-store-vectorizer -strip-debug-declare -coro-split -bdce -memcpyopt -ee-instrument -loop-simplify -loop-interchange -strip-nondebug -load-store-vectorizer -loop-load-elim -irce -partially-inline-libcalls -prune-eh -consthoist -gvn-hoist -lcssa -loop-predication -cross-dso-cfi -newgvn -mem2reg -sroa -strip-nondebug -indvars -loop-rotate -flattencfg -globaldce -separate-const-offset-from-gep -ipsccp -redundant-dbg-inst-elim -simple-loop-unswitch -strip-nondebug -strip-dead-prototypes -aggressive-instcombine -barrier -dce -mergereturn -attributor -indvars -loop-unroll-and-jam -callsite-splitting -slp-vectorizer -irce -adce -consthoist -licm -sancov -early-cse-memssa -separate-const-offset-from-gep -gvn -called-value-propagation -dse -lower-widenable-condition -loop-interchange -simple-loop-unswitch -loop-rotate -rpo-functionattrs -sink -lower-widenable-condition -coro-split -mem2reg -loop-interchange -lowerinvoke -constmerge -aggressive-instcombine -libcalls-shrinkwrap -gvn -loop-unroll-and-jam -ipconstprop -ee-instrument -strip-nondebug -lower-constant-intrinsics -inferattrs -hotcoldsplit -canonicalize-aliases -speculative-execution -rpo-functionattrs -separate-const-offset-from-gep -cross-dso-cfi -die -infer-address-spaces -gvn -memcpyopt -instcombine input.bc -o output.bc +benchmark://cbench-v1/gsm,1.0643675298804778,63.232433795928955,opt -indvars -mergereturn -pgo-memop-opt -ipsccp -redundant-dbg-inst-elim -add-discriminators -jump-threading -jump-threading -attributor -break-crit-edges -redundant-dbg-inst-elim -lowerswitch -early-cse-memssa -early-cse-memssa -loop-versioning -strip-nondebug -alignment-from-assumptions -ipsccp -sroa -redundant-dbg-inst-elim -dse -loop-simplifycfg -pgo-memop-opt -rewrite-statepoints-for-gc -name-anon-globals -simplifycfg -redundant-dbg-inst-elim -constmerge -consthoist -elim-avail-extern -die -coro-cleanup -globalopt -loop-deletion -slsr -add-discriminators -insert-gcov-profiling -infer-address-spaces -loop-fusion -consthoist -partially-inline-libcalls -callsite-splitting -consthoist -loop-load-elim -rewrite-statepoints-for-gc -loop-reroll -loweratomic -inferattrs -loop-unswitch -consthoist -lower-widenable-condition -loop-distribute -mergereturn -rpo-functionattrs -dse -instsimplify -loop-simplifycfg -loop-distribute -loop-unswitch -loop-simplify -callsite-splitting -rewrite-statepoints-for-gc -instcombine -insert-gcov-profiling -adce -instsimplify -loop-deletion -cross-dso-cfi -loweratomic -loop-distribute -insert-gcov-profiling -slp-vectorizer -lowerswitch -loop-guard-widening -loop-versioning -cross-dso-cfi -indvars -argpromotion -reassociate -simplifycfg -insert-gcov-profiling -lcssa -sancov -pgo-memop-opt -speculative-execution -sancov -post-inline-ee-instrument -sink -argpromotion -partially-inline-libcalls -ipsccp -lower-expect -dse -canonicalize-aliases -dce -sancov -prune-eh -loop-unswitch -functionattrs -globaldce -correlated-propagation -flattencfg -lower-matrix-intrinsics -strip -loop-instsimplify -simplifycfg -loop-fusion -loop-idiom -aggressive-instcombine -loop-idiom -coro-elide -called-value-propagation -loop-load-elim -coro-elide -lcssa -globalopt -slp-vectorizer -scalarizer -loop-simplifycfg -called-value-propagation -coro-early -mergeicmps -ee-instrument -loop-data-prefetch -pgo-memop-opt -gvn -bdce -loop-simplifycfg -partial-inliner -slp-vectorizer -globalsplit -dce -reassociate -loop-versioning-licm -barrier -coro-split -strip -loop-guard-widening -lcssa -partially-inline-libcalls -loop-data-prefetch -constprop -loop-vectorize -sroa -coro-elide -libcalls-shrinkwrap -loop-instsimplify -mergeicmps -loop-rotate -adce -strip-debug-declare -forceattrs -add-discriminators -instnamer -canonicalize-aliases -constmerge -lcssa -coro-early -simple-loop-unswitch -redundant-dbg-inst-elim -lower-expect -tailcallelim -forceattrs -lcssa -strip -loop-fusion -strip-dead-prototypes -mldst-motion -globalopt -ipsccp -nary-reassociate -separate-const-offset-from-gep -load-store-vectorizer -loop-simplify -loop-interchange -loop-unswitch -indvars -inject-tli-mappings -elim-avail-extern -newgvn -loop-simplify -jump-threading input.bc -o output.bc +benchmark://cbench-v1/gsm,1.065986055776892,65.38988256454468,opt -instcombine -rpo-functionattrs -infer-address-spaces -mergereturn -float2int -argpromotion -loop-unroll -simplifycfg -partially-inline-libcalls -argpromotion -loop-interchange -lcssa -strip-nondebug -strip -globalopt -redundant-dbg-inst-elim -dce -guard-widening -cross-dso-cfi -name-anon-globals -aggressive-instcombine -mergeicmps -redundant-dbg-inst-elim -rpo-functionattrs -loop-simplifycfg -coro-early -lower-matrix-intrinsics -ipsccp -loop-unroll -loop-simplify -speculative-execution -rpo-functionattrs -loop-data-prefetch -lowerinvoke -loop-sink -gvn -called-value-propagation -instcombine -sccp -reassociate -loop-unswitch -barrier -loop-reroll -simple-loop-unswitch -coro-early -loop-fusion -loop-unswitch -instnamer -flattencfg -dse -lower-expect -loop-fusion -reg2mem -mergereturn -coro-elide -coro-split -loop-distribute -tailcallelim -loop-unroll -coro-early -lcssa -slp-vectorizer -partially-inline-libcalls -rpo-functionattrs -cross-dso-cfi -dse -rpo-functionattrs -libcalls-shrinkwrap -lower-constant-intrinsics -guard-widening -inject-tli-mappings -slp-vectorizer -flattencfg -lower-expect -loop-predication -lcssa -rewrite-statepoints-for-gc -constprop -nary-reassociate -simplifycfg -early-cse-memssa -lowerinvoke -sroa -coro-split -rewrite-statepoints-for-gc -sink -loop-guard-widening -loop-unswitch -newgvn -callsite-splitting -elim-avail-extern -prune-eh -strip-nondebug -sink -elim-avail-extern -licm -lower-widenable-condition -dce -loop-load-elim -add-discriminators -dse -name-anon-globals -separate-const-offset-from-gep -early-cse-memssa -strip-debug-declare -globalsplit -sancov -name-anon-globals -rpo-functionattrs -irce -rpo-functionattrs -adce -newgvn -loop-guard-widening -loop-idiom -lcssa -post-inline-ee-instrument -loop-unroll-and-jam -lower-guard-intrinsic -functionattrs -jump-threading -rpo-functionattrs -globalsplit -loop-reroll -sancov -loop-load-elim -post-inline-ee-instrument -rewrite-statepoints-for-gc -lower-constant-intrinsics -name-anon-globals -dse -indvars -loweratomic -strip-dead-prototypes -loop-load-elim -canonicalize-aliases -strip-dead-prototypes -prune-eh -loop-versioning-licm -loop-fusion -sancov -guard-widening -loop-distribute -coro-early -strip-debug-declare -flattencfg -lcssa -separate-const-offset-from-gep -tailcallelim -slp-vectorizer -loop-sink -sancov -mldst-motion -strip-nondebug -dce -irce -simple-loop-unswitch -mem2reg -newgvn -irce -lower-widenable-condition -mem2reg -coro-cleanup -aggressive-instcombine -float2int -consthoist -add-discriminators -slsr -inject-tli-mappings -attributor -guard-widening -mergefunc -inferattrs -adce -aggressive-instcombine -instnamer -slp-vectorizer -redundant-dbg-inst-elim -sink -always-inline -inject-tli-mappings -lower-widenable-condition -loop-unroll-and-jam -ee-instrument -load-store-vectorizer -loop-simplify -gvn-hoist -loop-fusion -dse -loop-distribute -loop-fusion -loop-guard-widening -ipsccp -mem2reg -globalsplit -pgo-memop-opt -lower-widenable-condition -instcombine input.bc -o output.bc +benchmark://cbench-v1/gsm,1.0709661354581672,63.0761559009552,opt -coro-early -loop-fusion -adce -infer-address-spaces -loop-guard-widening -simplifycfg -lower-guard-intrinsic -mergereturn -rpo-functionattrs -speculative-execution -div-rem-pairs -forceattrs -strip -instsimplify -called-value-propagation -loop-unroll-and-jam -globalopt -loop-load-elim -lowerinvoke -hotcoldsplit -gvn-hoist -early-cse-memssa -forceattrs -strip-nondebug -instsimplify -globaldce -sccp -mergereturn -inject-tli-mappings -loop-interchange -sink -speculative-execution -adce -adce -argpromotion -sccp -inferattrs -tailcallelim -loop-vectorize -div-rem-pairs -elim-avail-extern -loop-fusion -instsimplify -sroa -functionattrs -pgo-memop-opt -argpromotion -mergeicmps -constprop -ee-instrument -flattencfg -mldst-motion -loop-idiom -alignment-from-assumptions -adce -barrier -mergefunc -ee-instrument -separate-const-offset-from-gep -gvn-hoist -adce -prune-eh -lcssa -loop-idiom -loop-unswitch -always-inline -slp-vectorizer -instcombine -slp-vectorizer -prune-eh -memcpyopt -alignment-from-assumptions -sccp -partially-inline-libcalls -ee-instrument -inferattrs -rpo-functionattrs -inject-tli-mappings -loop-distribute -instcombine -redundant-dbg-inst-elim -aggressive-instcombine -canonicalize-aliases -rpo-functionattrs -loop-instsimplify -mem2reg -licm -loop-interchange -hotcoldsplit -loop-predication -strip-nondebug -globalopt -memcpyopt -lower-widenable-condition -ee-instrument -called-value-propagation -simple-loop-unswitch -constmerge -slp-vectorizer -loop-simplifycfg -partial-inliner -loop-load-elim -gvn -licm -early-cse-memssa -correlated-propagation -loop-interchange -ee-instrument -float2int -mergereturn -pgo-memop-opt -ipconstprop -mergeicmps -die -ee-instrument -load-store-vectorizer -ipsccp -infer-address-spaces -callsite-splitting -flattencfg -loop-versioning-licm -sink -infer-address-spaces -loop-reroll -coro-early -loop-instsimplify -float2int -gvn-hoist -elim-avail-extern -bdce -lower-guard-intrinsic -loop-fusion -aggressive-instcombine -flattencfg -gvn -coro-early -deadargelim -adce -sancov -rpo-functionattrs -pgo-memop-opt -adce -loweratomic -ipsccp -guard-widening -simple-loop-unswitch -jump-threading -adce -loop-sink -early-cse-memssa -simplifycfg -coro-early -loop-idiom -early-cse-memssa -coro-cleanup -indvars -infer-address-spaces -infer-address-spaces -lower-expect -mem2reg -sancov -loop-interchange -loop-versioning -mergefunc -post-inline-ee-instrument -loop-versioning -loop-reroll -ipsccp -ee-instrument -nary-reassociate -hotcoldsplit -slp-vectorizer -strip-debug-declare -gvn-hoist -strip-nondebug -sancov -loop-distribute -loop-idiom -strip-debug-declare -reassociate -adce -newgvn -loop-fusion -mem2reg -memcpyopt -strip-dead-prototypes -instnamer -guard-widening -sroa -loop-simplify -rpo-functionattrs -slp-vectorizer -post-inline-ee-instrument -lower-constant-intrinsics -constmerge -loop-load-elim -ipsccp -loop-versioning -hotcoldsplit -loop-simplifycfg -mergeicmps -loop-idiom -rpo-functionattrs -constmerge -die -attributor -lower-expect -instcombine input.bc -o output.bc +benchmark://cbench-v1/gsm,1.0743276892430278,63.134528160095215,opt -simple-loop-unswitch -constprop -gvn-hoist -name-anon-globals -indvars -always-inline -name-anon-globals -instcombine -always-inline -simplifycfg -pgo-memop-opt -rewrite-statepoints-for-gc -loop-distribute -nary-reassociate -name-anon-globals -mergefunc -callsite-splitting -loop-rotate -loop-predication -alignment-from-assumptions -forceattrs -reg2mem -redundant-dbg-inst-elim -reg2mem -barrier -slsr -lower-widenable-condition -loop-reduce -loop-idiom -constprop -strip -tailcallelim -simplifycfg -callsite-splitting -loop-simplifycfg -mergeicmps -loop-rotate -mem2reg -coro-early -alignment-from-assumptions -loop-simplify -simplifycfg -dse -loop-data-prefetch -simple-loop-unswitch -loop-simplify -constprop -loop-guard-widening -cross-dso-cfi -sink -globalsplit -strip -instcombine -adce -always-inline -inject-tli-mappings -speculative-execution -instnamer -barrier -loop-simplifycfg -newgvn -name-anon-globals -lowerinvoke -tailcallelim -gvn -loop-sink -hotcoldsplit -slp-vectorizer -loop-unswitch -coro-split -canonicalize-aliases -loop-unroll-and-jam -dse -lower-widenable-condition -lower-matrix-intrinsics -insert-gcov-profiling -loop-unroll-and-jam -loop-instsimplify -strip-debug-declare -flattencfg -correlated-propagation -guard-widening -coro-elide -functionattrs -argpromotion -flattencfg -newgvn -strip-debug-declare -loop-data-prefetch -loop-unroll-and-jam -div-rem-pairs -insert-gcov-profiling -sccp -float2int -canonicalize-aliases -ee-instrument -loop-fusion -sancov -loop-versioning-licm -globalsplit -loop-unswitch -partial-inliner -deadargelim -functionattrs -lowerinvoke -loop-deletion -coro-early -jump-threading -globalsplit -coro-elide -ipsccp -redundant-dbg-inst-elim -prune-eh -coro-early -ee-instrument -strip -libcalls-shrinkwrap -rpo-functionattrs -insert-gcov-profiling -mergeicmps -loop-interchange -adce -strip-nondebug -tailcallelim -nary-reassociate -loop-reroll -mldst-motion -coro-cleanup -reg2mem -coro-early -rpo-functionattrs -loop-fusion -loop-guard-widening -redundant-dbg-inst-elim -bdce -load-store-vectorizer -called-value-propagation -loweratomic -jump-threading -constprop -float2int -globalopt -speculative-execution -guard-widening -argpromotion -lower-constant-intrinsics -called-value-propagation -callsite-splitting -loop-load-elim -loop-sink -loop-distribute -mergereturn -load-store-vectorizer -div-rem-pairs -partial-inliner -alignment-from-assumptions -gvn-hoist -correlated-propagation -instnamer -scalarizer -loop-sink -mem2reg -libcalls-shrinkwrap -sroa -partially-inline-libcalls -coro-split -always-inline -globalsplit -separate-const-offset-from-gep -loop-guard-widening -forceattrs -loop-unroll-and-jam -loop-unswitch -licm -instcombine -slsr -callsite-splitting -pgo-memop-opt -coro-cleanup -cross-dso-cfi -rpo-functionattrs -loop-load-elim -loop-idiom -globalopt -dce -die -gvn-hoist -newgvn -reassociate -loop-simplifycfg -load-store-vectorizer -licm -loweratomic -aggressive-instcombine -loop-unswitch -mergeicmps -flattencfg -mldst-motion -globaldce -loop-reroll -loop-vectorize -lower-guard-intrinsic -loop-unswitch -early-cse-memssa -slp-vectorizer -instcombine input.bc -o output.bc +benchmark://cbench-v1/ispell,0.9643912737508797,63.807353258132935,opt -instnamer -lcssa -infer-address-spaces -lower-guard-intrinsic -loop-simplify -slp-vectorizer -deadargelim -adce -barrier -inferattrs -early-cse-memssa -separate-const-offset-from-gep -sccp -strip -mergereturn -sroa -sroa -instcombine -separate-const-offset-from-gep -float2int -simple-loop-unswitch -correlated-propagation -loop-reduce -pgo-memop-opt -alignment-from-assumptions -coro-early -loop-vectorize -constprop -sccp -mergereturn -argpromotion -instsimplify -jump-threading -early-cse-memssa -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/ispell,0.9748064743138635,64.32104349136353,opt -strip-nondebug -indvars -coro-elide -flattencfg -deadargelim -tailcallelim -tailcallelim -prune-eh -loweratomic -separate-const-offset-from-gep -lower-constant-intrinsics -loop-interchange -insert-gcov-profiling -lower-matrix-intrinsics -sroa -redundant-dbg-inst-elim -simplifycfg -inferattrs -loop-load-elim -gvn-hoist -slsr -libcalls-shrinkwrap -constprop -loop-unroll -instcombine -attributor -strip-debug-declare -loop-versioning-licm -loop-fusion -lcssa -strip -ee-instrument -sink -redundant-dbg-inst-elim -loop-interchange -consthoist -globalopt -loop-deletion -constmerge -sroa -prune-eh -sccp -globalsplit -mergeicmps -prune-eh -simplifycfg -coro-split -lowerinvoke -cross-dso-cfi -mergereturn -consthoist -slsr -simplifycfg -float2int -deadargelim -speculative-execution -loop-distribute -loop-fusion -loop-fusion -div-rem-pairs -loop-unroll-and-jam -gvn-hoist -loop-unroll -strip-debug-declare -loop-idiom -constmerge -ee-instrument -loop-sink -loweratomic -strip-debug-declare -mergereturn -inject-tli-mappings -canonicalize-aliases -loop-reroll -loop-unroll-and-jam -name-anon-globals -guard-widening -jump-threading -break-crit-edges -mergeicmps -canonicalize-aliases -elim-avail-extern -lower-expect -sccp -ipsccp -loop-simplifycfg -loop-unroll -scalarizer -strip-nondebug -loop-unroll -hotcoldsplit -mldst-motion -inferattrs -aggressive-instcombine -called-value-propagation -instcombine -coro-split -tailcallelim -sancov -newgvn -scalarizer -lower-widenable-condition -gvn -separate-const-offset-from-gep -lower-matrix-intrinsics -newgvn -add-discriminators -lower-matrix-intrinsics -pgo-memop-opt -callsite-splitting -loop-unroll-and-jam -sroa -lower-expect -functionattrs -sink -loop-guard-widening -coro-cleanup -functionattrs -lower-widenable-condition -irce -cross-dso-cfi -reassociate -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/ispell,0.9791695988740322,64.13968276977539,opt -name-anon-globals -break-crit-edges -coro-early -loop-guard-widening -partial-inliner -slp-vectorizer -loweratomic -loop-reduce -partial-inliner -sroa -instcombine -correlated-propagation -sccp -strip-nondebug -simplifycfg -mergeicmps -inject-tli-mappings -slsr -loop-versioning-licm -alignment-from-assumptions -loop-unroll-and-jam -newgvn -instsimplify -sroa -scalarizer -instcombine -ee-instrument -scalarizer -irce -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/ispell,0.9847994370161856,66.86581897735596,opt -redundant-dbg-inst-elim -lower-widenable-condition -strip -nary-reassociate -loop-reduce -nary-reassociate -loop-load-elim -simple-loop-unswitch -loop-versioning-licm -redundant-dbg-inst-elim -scalarizer -nary-reassociate -instnamer -simplifycfg -break-crit-edges -loop-load-elim -indvars -load-store-vectorizer -dse -lower-matrix-intrinsics -lower-constant-intrinsics -pgo-memop-opt -slsr -instsimplify -sink -loop-predication -loweratomic -float2int -constmerge -speculative-execution -loop-reroll -callsite-splitting -always-inline -consthoist -redundant-dbg-inst-elim -cross-dso-cfi -inferattrs -globaldce -ipsccp -mergeicmps -instsimplify -constprop -redundant-dbg-inst-elim -sroa -globalopt -div-rem-pairs -coro-elide -early-cse-memssa -loop-versioning-licm -inferattrs -scalarizer -globalopt -loop-versioning -rpo-functionattrs -load-store-vectorizer -barrier -globalopt -irce -redundant-dbg-inst-elim -ipconstprop -guard-widening -post-inline-ee-instrument -globalopt -mem2reg -coro-cleanup -sroa -deadargelim -instsimplify -add-discriminators -constprop -alignment-from-assumptions -partially-inline-libcalls -aggressive-instcombine -reg2mem -early-cse-memssa -strip -mem2reg -newgvn -coro-split -always-inline -strip-nondebug -rewrite-statepoints-for-gc -licm -functionattrs -instsimplify -slsr -hotcoldsplit -dce -infer-address-spaces -coro-cleanup -float2int -post-inline-ee-instrument -loop-instsimplify -elim-avail-extern -globaldce -functionattrs -sink -guard-widening -loop-sink -add-discriminators -inject-tli-mappings -globalopt -indvars -instnamer -instcombine -ipconstprop -strip-debug-declare -functionattrs -jump-threading -gvn -always-inline -prune-eh -attributor -slp-vectorizer -newgvn input.bc -o output.bc +benchmark://cbench-v1/ispell,0.9855031667839551,64.19602680206299,opt -functionattrs -barrier -globalsplit -speculative-execution -correlated-propagation -separate-const-offset-from-gep -loop-interchange -constmerge -memcpyopt -loop-distribute -redundant-dbg-inst-elim -loop-instsimplify -lower-expect -alignment-from-assumptions -early-cse-memssa -indvars -gvn-hoist -globalsplit -partially-inline-libcalls -constprop -loop-unswitch -strip -post-inline-ee-instrument -loop-versioning -sccp -argpromotion -instcombine -argpromotion -lowerinvoke -loop-deletion -elim-avail-extern -sroa -partially-inline-libcalls -reassociate -dse -scalarizer -strip-nondebug -loop-guard-widening -strip-dead-prototypes -gvn -loop-data-prefetch -sccp -name-anon-globals -coro-early -simplifycfg -called-value-propagation -instnamer -load-store-vectorizer -forceattrs -mergefunc -prune-eh -lower-constant-intrinsics -ipconstprop -newgvn -jump-threading -called-value-propagation -instcombine input.bc -o output.bc +benchmark://cbench-v1/ispell,0.9874736101337088,64.0391092300415,opt -loop-idiom -float2int -aggressive-instcombine -nary-reassociate -simple-loop-unswitch -mldst-motion -loop-sink -correlated-propagation -insert-gcov-profiling -partially-inline-libcalls -lower-widenable-condition -scalarizer -load-store-vectorizer -guard-widening -hotcoldsplit -aggressive-instcombine -redundant-dbg-inst-elim -guard-widening -loop-guard-widening -indvars -inferattrs -sancov -dce -rpo-functionattrs -called-value-propagation -coro-split -callsite-splitting -newgvn -mem2reg -instnamer -instsimplify -partially-inline-libcalls -loop-versioning-licm -deadargelim -instcombine -newgvn -pgo-memop-opt -ipconstprop -pgo-memop-opt -loop-versioning -loweratomic -strip-dead-prototypes -callsite-splitting -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/ispell,0.9894440534834623,65.27008605003357,opt -deadargelim -loop-vectorize -inferattrs -jump-threading -name-anon-globals -coro-cleanup -simplifycfg -jump-threading -gvn-hoist -div-rem-pairs -loop-idiom -reg2mem -loop-unswitch -loop-unswitch -loop-versioning -hotcoldsplit -slp-vectorizer -sink -loop-interchange -sancov -gvn -redundant-dbg-inst-elim -globalsplit -coro-elide -strip-nondebug -lower-constant-intrinsics -loop-versioning -indvars -loop-load-elim -lower-widenable-condition -loop-reroll -partial-inliner -gvn -cross-dso-cfi -always-inline -loop-versioning -argpromotion -loop-unroll-and-jam -strip-debug-declare -lower-guard-intrinsic -barrier -argpromotion -loop-simplifycfg -argpromotion -coro-cleanup -prune-eh -coro-cleanup -coro-early -loop-simplifycfg -break-crit-edges -sccp -ipconstprop -called-value-propagation -inject-tli-mappings -memcpyopt -tailcallelim -argpromotion -tailcallelim -gvn-hoist -dce -elim-avail-extern -post-inline-ee-instrument -slsr -always-inline -indvars -inferattrs -simplifycfg -speculative-execution -always-inline -alignment-from-assumptions -inject-tli-mappings -globalsplit -coro-cleanup -gvn -load-store-vectorizer -insert-gcov-profiling -lowerinvoke -partially-inline-libcalls -instcombine -name-anon-globals -globalsplit -separate-const-offset-from-gep -sccp -forceattrs -coro-elide -barrier -loop-reroll -nary-reassociate -reassociate -callsite-splitting -post-inline-ee-instrument -newgvn -inferattrs -loop-versioning -mergereturn -always-inline -post-inline-ee-instrument -strip -loop-idiom -mem2reg -newgvn -break-crit-edges -scalarizer -reassociate -loop-unroll -strip-nondebug -lower-matrix-intrinsics -rpo-functionattrs -cross-dso-cfi -instcombine -break-crit-edges -dce -inject-tli-mappings -sink -pgo-memop-opt -globalopt -consthoist -loop-idiom -rpo-functionattrs -functionattrs -always-inline -newgvn -float2int -argpromotion -instnamer -hotcoldsplit -simplifycfg -lower-expect -mergefunc input.bc -o output.bc +benchmark://cbench-v1/ispell,0.9952146375791695,65.40430235862732,opt -name-anon-globals -memcpyopt -aggressive-instcombine -float2int -ee-instrument -gvn-hoist -div-rem-pairs -instnamer -prune-eh -forceattrs -coro-cleanup -alignment-from-assumptions -lower-guard-intrinsic -coro-elide -newgvn -prune-eh -sancov -indvars -float2int -loop-guard-widening -loop-simplifycfg -loop-idiom -dse -prune-eh -loop-guard-widening -flattencfg -lower-guard-intrinsic -deadargelim -float2int -simplifycfg -load-store-vectorizer -coro-split -float2int -lowerinvoke -mergefunc -guard-widening -break-crit-edges -inferattrs -mem2reg -instcombine -cross-dso-cfi -insert-gcov-profiling -memcpyopt -gvn-hoist -reg2mem -separate-const-offset-from-gep -elim-avail-extern -sroa -ipconstprop -loop-unroll -pgo-memop-opt -memcpyopt -sancov -newgvn -functionattrs -slp-vectorizer -loop-unroll-and-jam -loop-deletion -rpo-functionattrs -lower-widenable-condition -attributor -loop-simplifycfg -simple-loop-unswitch -loop-idiom -loop-fusion -ipsccp -loop-guard-widening -loop-vectorize -alignment-from-assumptions -insert-gcov-profiling -consthoist -sancov -ee-instrument -loop-deletion -redundant-dbg-inst-elim -insert-gcov-profiling -barrier -consthoist -div-rem-pairs -partial-inliner -lcssa -correlated-propagation -partially-inline-libcalls -lower-constant-intrinsics -callsite-splitting -loop-predication -constmerge -sccp -jump-threading -instsimplify input.bc -o output.bc +benchmark://cbench-v1/ispell,1.0014074595355382,64.54691743850708,opt -callsite-splitting -slp-vectorizer -name-anon-globals -argpromotion -insert-gcov-profiling -inject-tli-mappings -lowerinvoke -sancov -globalopt -strip-dead-prototypes -div-rem-pairs -always-inline -loop-idiom -instnamer -loop-versioning -cross-dso-cfi -sccp -bdce -mergeicmps -slp-vectorizer -pgo-memop-opt -reg2mem -prune-eh -constmerge -constmerge -speculative-execution -strip-nondebug -lower-matrix-intrinsics -early-cse-memssa -mem2reg -loweratomic -sroa -loop-reroll -globalsplit -globalsplit -loop-unroll -newgvn -strip-dead-prototypes -constprop -indvars -simplifycfg -argpromotion -post-inline-ee-instrument -loop-reroll -argpromotion -globalsplit -sancov -early-cse-memssa -loop-simplifycfg -gvn -instcombine -strip-nondebug -lowerinvoke -slp-vectorizer -mldst-motion -loweratomic -reassociate -loop-simplifycfg -rewrite-statepoints-for-gc -loop-sink -break-crit-edges -mergeicmps -jump-threading -loop-distribute -lcssa -canonicalize-aliases -attributor -bdce -lower-expect -coro-split -loop-fusion -guard-widening -instnamer -rpo-functionattrs -strip-dead-prototypes -early-cse-memssa -callsite-splitting -separate-const-offset-from-gep -newgvn -lower-matrix-intrinsics -gvn -mldst-motion -loop-data-prefetch -ipconstprop -dse -strip-nondebug -loop-versioning-licm -newgvn -libcalls-shrinkwrap -early-cse-memssa -dse -attributor -early-cse-memssa -called-value-propagation -lower-matrix-intrinsics -slp-vectorizer -coro-early -slsr -argpromotion -tailcallelim -slsr -jump-threading -coro-early -gvn-hoist -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/ispell,1.0014074595355382,64.55206608772278,opt -memcpyopt -inferattrs -speculative-execution -consthoist -callsite-splitting -flattencfg -loop-simplifycfg -scalarizer -reassociate -mergeicmps -always-inline -gvn-hoist -newgvn -dse -mem2reg -speculative-execution -loop-idiom -loop-simplify -simplifycfg -newgvn -infer-address-spaces -jump-threading -load-store-vectorizer -loop-data-prefetch -sink -insert-gcov-profiling -lower-constant-intrinsics -barrier -loop-idiom -mergefunc -add-discriminators -div-rem-pairs -functionattrs -float2int -deadargelim -licm -scalarizer -forceattrs -loop-predication -instcombine -simplifycfg -loop-vectorize -flattencfg -loop-unroll-and-jam -loop-reroll -guard-widening -loop-distribute -lcssa -div-rem-pairs -coro-cleanup -barrier -strip-dead-prototypes -prune-eh -jump-threading -loop-distribute -licm -argpromotion -forceattrs -guard-widening -lower-widenable-condition -simple-loop-unswitch -redundant-dbg-inst-elim -loop-reduce -forceattrs -dce -instsimplify -load-store-vectorizer -flattencfg -post-inline-ee-instrument -loop-distribute -loop-load-elim -ee-instrument -memcpyopt -loop-versioning-licm -barrier -coro-split -lower-constant-intrinsics -constprop -load-store-vectorizer -rewrite-statepoints-for-gc -loop-load-elim -irce -coro-elide -simple-loop-unswitch -loop-predication -lower-guard-intrinsic -deadargelim -lower-expect -functionattrs -globaldce -newgvn -dce -cross-dso-cfi -loop-simplifycfg -float2int -die -instnamer -memcpyopt -lower-widenable-condition -loop-distribute -strip-debug-declare -coro-elide -barrier -rpo-functionattrs -ee-instrument -instsimplify -bdce -dce -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0063552097219208,76.24695205688477,opt -sccp -partially-inline-libcalls -barrier -slsr -hotcoldsplit -forceattrs -simple-loop-unswitch -dse -strip-dead-prototypes -rewrite-statepoints-for-gc -hotcoldsplit -die -cross-dso-cfi -sancov -lower-expect -mem2reg -loop-vectorize -newgvn -loop-vectorize -loop-reroll -loop-sink -licm -lowerswitch -bdce -mergeicmps -strip-dead-prototypes -pgo-memop-opt -lowerswitch -mldst-motion -loop-rotate -div-rem-pairs -loop-fusion -forceattrs -loop-unroll-and-jam -coro-split -canonicalize-aliases -scalarizer -dce -constmerge -dse -attributor -reassociate -loop-simplify -jump-threading -speculative-execution -sroa -loop-idiom -name-anon-globals -break-crit-edges -loop-interchange -coro-split -constprop -attributor -simple-loop-unswitch -coro-elide -constmerge -loop-deletion -attributor -licm -post-inline-ee-instrument -pgo-memop-opt -newgvn -loweratomic -loop-versioning-licm -strip-nondebug -load-store-vectorizer -forceattrs -coro-early -break-crit-edges -loop-rotate -slsr -simplifycfg -tailcallelim -sroa -lower-constant-intrinsics -libcalls-shrinkwrap -strip-debug-declare -instcombine input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.006696220975292,73.28315615653992,opt -slp-vectorizer -elim-avail-extern -libcalls-shrinkwrap -load-store-vectorizer -rpo-functionattrs -mem2reg -callsite-splitting -instcombine -constprop -licm -barrier -load-store-vectorizer -functionattrs -sink -redundant-dbg-inst-elim -attributor -jump-threading -coro-cleanup -strip-nondebug -loop-versioning -name-anon-globals -deadargelim -libcalls-shrinkwrap -mergereturn -scalarizer -strip-dead-prototypes -libcalls-shrinkwrap -flattencfg -indvars -loweratomic -loweratomic -infer-address-spaces -canonicalize-aliases -prune-eh -gvn-hoist -ipconstprop -insert-gcov-profiling -newgvn -loop-load-elim -bdce -cross-dso-cfi -infer-address-spaces -lower-expect -prune-eh -globaldce input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0068822271134945,73.44375777244568,opt -instsimplify -early-cse-memssa -barrier -loop-unswitch -argpromotion -mergereturn -attributor -memcpyopt -float2int -coro-early -redundant-dbg-inst-elim -flattencfg -div-rem-pairs -scalarizer -die -loop-instsimplify -early-cse-memssa -argpromotion -globaldce -break-crit-edges -mergereturn -dse -loop-simplifycfg -inject-tli-mappings -mem2reg -lcssa -argpromotion -indvars -slp-vectorizer -scalarizer -coro-elide -sancov -adce -instnamer -sroa -alignment-from-assumptions -bdce -aggressive-instcombine -ipconstprop -ipsccp -attributor -early-cse-memssa -instcombine -mergefunc -ipconstprop -rpo-functionattrs -infer-address-spaces -jump-threading -instsimplify input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.012245404098335,77.20652055740356,opt -prune-eh -redundant-dbg-inst-elim -strip-nondebug -partially-inline-libcalls -mergeicmps -inferattrs -die -strip-dead-prototypes -newgvn -strip-nondebug -mergefunc -sroa -instsimplify -instnamer -mldst-motion -jump-threading -ee-instrument -die -ipconstprop -argpromotion -scalarizer -coro-early -memcpyopt -loop-instsimplify -barrier -die -loop-deletion -slsr -coro-cleanup -instsimplify -coro-cleanup -instcombine -reg2mem -redundant-dbg-inst-elim -guard-widening -slsr -deadargelim -dse -float2int -attributor -loop-instsimplify -sink -redundant-dbg-inst-elim -indvars -reg2mem -early-cse-memssa -loop-data-prefetch -coro-elide -tailcallelim -slp-vectorizer -consthoist -gvn-hoist -lower-constant-intrinsics -lower-expect -deadargelim -sink -mergefunc -coro-elide -coro-early -insert-gcov-profiling -float2int -inject-tli-mappings -loop-fusion -libcalls-shrinkwrap -loop-simplify -lower-widenable-condition -globaldce -loop-instsimplify -loop-sink -functionattrs -memcpyopt -callsite-splitting -early-cse-memssa -simplifycfg -globaldce -sroa -coro-split -licm -mergereturn -lower-matrix-intrinsics -loop-versioning-licm -name-anon-globals -inferattrs -instcombine -rpo-functionattrs -elim-avail-extern -loop-versioning-licm -consthoist -scalarizer -mergefunc -tailcallelim -barrier -loop-distribute -loop-reroll -irce -loop-interchange -deadargelim -memcpyopt -indvars -float2int -mem2reg -loop-sink -globalopt -pgo-memop-opt -ipconstprop -mldst-motion -reassociate -loop-unroll-and-jam -name-anon-globals -jump-threading input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0148184890101377,75.44664001464844,opt -lcssa -rewrite-statepoints-for-gc -dse -sancov -inferattrs -inject-tli-mappings -speculative-execution -sccp -flattencfg -dse -lower-widenable-condition -ipsccp -rpo-functionattrs -indvars -load-store-vectorizer -gvn-hoist -ipsccp -callsite-splitting -coro-early -partially-inline-libcalls -loop-versioning -dce -libcalls-shrinkwrap -loop-versioning -strip-debug-declare -coro-cleanup -loop-sink -lower-widenable-condition -load-store-vectorizer -flattencfg -mergefunc -early-cse-memssa -canonicalize-aliases -functionattrs -loop-interchange -loop-instsimplify -guard-widening -ee-instrument -bdce -loop-guard-widening -strip -scalarizer -instsimplify -ipsccp -loop-fusion -correlated-propagation -scalarizer -mergefunc -coro-split -loop-reroll -loop-versioning-licm -constmerge -loop-sink -dse -jump-threading -mldst-motion -separate-const-offset-from-gep -instnamer -post-inline-ee-instrument -tailcallelim -coro-elide -loop-distribute -called-value-propagation -loop-unswitch -speculative-execution -constprop -ipsccp -coro-cleanup -licm -gvn-hoist -loop-unroll-and-jam -mldst-motion -ipconstprop -flattencfg -loop-simplify -reg2mem -loweratomic -loop-interchange -loop-guard-widening -consthoist -cross-dso-cfi -loop-unroll -sroa -pgo-memop-opt -strip-debug-declare -loop-guard-widening -loop-instsimplify -nary-reassociate -forceattrs -loop-vectorize -loop-instsimplify -lcssa -instcombine -libcalls-shrinkwrap -post-inline-ee-instrument -loop-reroll -indvars -name-anon-globals -inferattrs -loop-load-elim -instsimplify -memcpyopt -ee-instrument -loop-unroll-and-jam -adce -constprop -lowerinvoke -ipsccp -consthoist -constmerge -loweratomic -gvn-hoist -slsr -infer-address-spaces -strip-nondebug -pgo-memop-opt -loop-unroll-and-jam -functionattrs -slp-vectorizer -ipsccp -float2int -loop-sink -simplifycfg -correlated-propagation -loop-unroll-and-jam -loop-interchange -loop-guard-widening -loop-sink -div-rem-pairs -called-value-propagation -instcombine -load-store-vectorizer -gvn -globaldce -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0154075084477787,74.82714986801147,opt -loop-unroll-and-jam -argpromotion -pgo-memop-opt -coro-cleanup -lowerinvoke -loop-reroll -sccp -strip-debug-declare -alignment-from-assumptions -loop-instsimplify -loop-distribute -strip-dead-prototypes -rewrite-statepoints-for-gc -canonicalize-aliases -mergeicmps -post-inline-ee-instrument -early-cse-memssa -bdce -functionattrs -break-crit-edges -loop-deletion -memcpyopt -loop-guard-widening -name-anon-globals -loop-reduce -loop-fusion -canonicalize-aliases -attributor -argpromotion -coro-cleanup -reg2mem -strip-dead-prototypes -add-discriminators -globaldce -loop-interchange -mem2reg -lower-widenable-condition -gvn -partially-inline-libcalls -lower-guard-intrinsic -loop-instsimplify -instsimplify -lower-guard-intrinsic -instcombine -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0182906035899184,74.4551010131836,opt -attributor -loop-instsimplify -sroa -argpromotion -redundant-dbg-inst-elim -flattencfg -strip -jump-threading -mergeicmps -lower-matrix-intrinsics -scalarizer -nary-reassociate -lower-widenable-condition -barrier -adce -indvars -coro-cleanup -mergeicmps -redundant-dbg-inst-elim -elim-avail-extern -lower-widenable-condition -inferattrs -alignment-from-assumptions -coro-split -ipconstprop -loop-vectorize -forceattrs -loop-versioning-licm -mergeicmps -loop-distribute -inferattrs -instcombine -strip -inject-tli-mappings -lower-expect -indvars -constprop -tailcallelim -loop-fusion -licm -nary-reassociate -elim-avail-extern -ipconstprop -redundant-dbg-inst-elim -gvn-hoist -lower-widenable-condition -sancov -loop-instsimplify -indvars -mldst-motion -newgvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0190346281427287,72.94964694976807,opt -hotcoldsplit -loop-load-elim -mem2reg -redundant-dbg-inst-elim -functionattrs -constprop -guard-widening -mergeicmps -sroa -coro-cleanup -gvn -load-store-vectorizer -called-value-propagation -loweratomic -loop-versioning-licm -ipsccp -inject-tli-mappings -mem2reg -loop-interchange -lowerinvoke -redundant-dbg-inst-elim -jump-threading -tailcallelim -sink -inject-tli-mappings -instcombine -add-discriminators -partially-inline-libcalls -coro-elide -lcssa -infer-address-spaces -jump-threading -break-crit-edges -aggressive-instcombine -infer-address-spaces -early-cse-memssa -elim-avail-extern -redundant-dbg-inst-elim -flattencfg -lowerinvoke -slp-vectorizer -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0216077130545307,374.86166167259216,opt -sccp -mergereturn -constmerge -reassociate -lowerinvoke -globalopt -coro-cleanup -strip-debug-declare -strip-debug-declare -lower-matrix-intrinsics -functionattrs -jump-threading -ipconstprop -alignment-from-assumptions -loop-versioning-licm -strip -alignment-from-assumptions -ee-instrument -lcssa -dce -rewrite-statepoints-for-gc -ipconstprop -mem2reg -strip -loop-guard-widening -mergereturn -correlated-propagation -instsimplify -name-anon-globals -lower-expect -div-rem-pairs -constprop -lower-matrix-intrinsics -always-inline -guard-widening -newgvn -coro-early -forceattrs -ipconstprop -argpromotion -aggressive-instcombine -correlated-propagation -break-crit-edges -called-value-propagation -strip-debug-declare -lower-matrix-intrinsics -gvn-hoist -gvn-hoist -callsite-splitting -lower-constant-intrinsics -lowerinvoke -tailcallelim -lower-expect -rewrite-statepoints-for-gc -hotcoldsplit -irce -mldst-motion -gvn-hoist -aggressive-instcombine -loop-idiom -globalsplit -instcombine -post-inline-ee-instrument -loop-versioning -aggressive-instcombine -globalsplit -memcpyopt -constprop -infer-address-spaces -early-cse-memssa -partially-inline-libcalls -guard-widening -die -scalarizer -mergefunc -licm -loop-data-prefetch -loop-data-prefetch -loop-deletion -hotcoldsplit -rewrite-statepoints-for-gc -gvn-hoist -scalarizer -lower-constant-intrinsics -constprop -reg2mem -rpo-functionattrs -loop-reduce -loop-unroll-and-jam -lower-widenable-condition -loop-guard-widening -insert-gcov-profiling -speculative-execution -instsimplify -sroa -mergefunc -licm -loop-sink -loop-simplify -globalsplit -lower-matrix-intrinsics -hotcoldsplit -canonicalize-aliases -indvars -die -coro-cleanup -cross-dso-cfi -hotcoldsplit -called-value-propagation -simple-loop-unswitch -simplifycfg -elim-avail-extern input.bc -o output.bc +benchmark://cbench-v1/jpeg-c,1.0307220138264561,76.84722781181335,opt -coro-early -indvars -slp-vectorizer -callsite-splitting -attributor -loop-reroll -lower-constant-intrinsics -instsimplify -consthoist -lcssa -partially-inline-libcalls -alignment-from-assumptions -deadargelim -lower-widenable-condition -loop-versioning -adce -add-discriminators -speculative-execution -loop-predication -die -elim-avail-extern -loop-deletion -licm -loop-load-elim -break-crit-edges -sink -simplifycfg -div-rem-pairs -forceattrs -tailcallelim -strip-dead-prototypes -loweratomic -rpo-functionattrs -constprop -loop-simplifycfg -canonicalize-aliases -nary-reassociate -consthoist -loop-simplifycfg -reg2mem -lcssa -infer-address-spaces -lower-constant-intrinsics -loop-versioning-licm -insert-gcov-profiling -strip-dead-prototypes -loop-idiom -coro-split -strip-nondebug -barrier -ee-instrument -name-anon-globals -sancov -loop-instsimplify -loop-versioning -loop-simplify -loop-deletion -aggressive-instcombine -globalopt -gvn-hoist -sroa -instcombine -correlated-propagation -loop-sink -sccp -simple-loop-unswitch -argpromotion -rewrite-statepoints-for-gc -libcalls-shrinkwrap -gvn-hoist -elim-avail-extern -always-inline -mergereturn -newgvn -sancov -irce -strip -slp-vectorizer -inject-tli-mappings -lower-expect -always-inline -sancov -partially-inline-libcalls -indvars -mem2reg -correlated-propagation -coro-split -loop-load-elim -coro-early -sink -instsimplify -constprop -guard-widening -instsimplify -loop-guard-widening -constmerge -simplifycfg -inferattrs -loop-deletion -memcpyopt -loop-distribute -rewrite-statepoints-for-gc -irce -loop-data-prefetch -inject-tli-mappings -gvn-hoist -strip -slsr -irce -bdce -dse -loop-data-prefetch -loop-reroll -break-crit-edges -simplifycfg -tailcallelim -slp-vectorizer -loop-unroll-and-jam -ipsccp -licm -loweratomic -mldst-motion -always-inline -loop-versioning -sink -lower-guard-intrinsic -loop-sink -lcssa -reassociate -inferattrs -lowerinvoke -rpo-functionattrs -strip-debug-declare -reassociate -dse -globaldce -slsr -mergeicmps -coro-split -flattencfg -forceattrs -speculative-execution -elim-avail-extern -globalopt -memcpyopt -lower-constant-intrinsics -ee-instrument -correlated-propagation -simplifycfg -libcalls-shrinkwrap -libcalls-shrinkwrap -called-value-propagation -redundant-dbg-inst-elim -strip-debug-declare -div-rem-pairs -nary-reassociate input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.014874915483435,77.7471342086792,opt -loop-reroll -mergeicmps -called-value-propagation -loop-vectorize -adce -name-anon-globals -loop-reroll -canonicalize-aliases -tailcallelim -constprop -loop-versioning-licm -loop-deletion -mem2reg -loop-versioning-licm -insert-gcov-profiling -called-value-propagation -loop-deletion -sancov -loop-idiom -lower-guard-intrinsic -speculative-execution -tailcallelim -sink -loop-idiom -inferattrs -gvn -called-value-propagation -coro-split -constprop -barrier -cross-dso-cfi -scalarizer -coro-early -name-anon-globals -mem2reg -lowerinvoke -globalopt -licm -inferattrs -loop-load-elim -loop-unroll -lower-expect -attributor -gvn-hoist -mem2reg -die -mergereturn -rpo-functionattrs -lower-constant-intrinsics -irce -instsimplify -called-value-propagation -reassociate -loop-unroll-and-jam -prune-eh -elim-avail-extern -memcpyopt -instcombine -die -strip-debug-declare -post-inline-ee-instrument -argpromotion -insert-gcov-profiling -lower-matrix-intrinsics -strip-debug-declare -called-value-propagation -coro-cleanup -guard-widening -mergereturn -sancov -loweratomic -mldst-motion -instsimplify -slsr -globaldce -simplifycfg -lowerinvoke -bdce -break-crit-edges -infer-address-spaces -mergereturn -deadargelim -canonicalize-aliases -coro-elide -aggressive-instcombine -strip-debug-declare -ee-instrument -lower-expect -globaldce -loop-interchange -loop-idiom -lcssa -loop-predication -loweratomic -loop-simplifycfg -loop-load-elim -coro-early -ipsccp -die -separate-const-offset-from-gep -aggressive-instcombine -ipsccp -cross-dso-cfi -hotcoldsplit -constmerge -strip -ee-instrument -globaldce -loop-deletion -loop-versioning -mergefunc -lower-expect -aggressive-instcombine -elim-avail-extern -sroa -loop-distribute -irce -insert-gcov-profiling -infer-address-spaces -simplifycfg -loop-sink -loop-simplify -loop-deletion -loop-simplify -instcombine -attributor -nary-reassociate -memcpyopt -globalsplit -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0167423291155535,78.36895751953125,opt -loop-versioning-licm -loop-vectorize -gvn-hoist -rpo-functionattrs -loop-interchange -sccp -loop-simplifycfg -sancov -lower-matrix-intrinsics -gvn-hoist -callsite-splitting -loop-guard-widening -loop-unroll -ipsccp -strip-debug-declare -separate-const-offset-from-gep -simplifycfg -post-inline-ee-instrument -alignment-from-assumptions -mem2reg -libcalls-shrinkwrap -hotcoldsplit -loop-predication -partially-inline-libcalls -post-inline-ee-instrument -lower-widenable-condition -loop-reroll -bdce -loop-predication -loop-data-prefetch -indvars -loop-idiom -globaldce -strip-dead-prototypes -loop-simplifycfg -separate-const-offset-from-gep -loop-simplify -loop-predication -loop-unswitch -always-inline -loop-versioning-licm -mergefunc -rpo-functionattrs -reg2mem -elim-avail-extern -pgo-memop-opt -partial-inliner -ipsccp -die -globalsplit -add-discriminators -memcpyopt -div-rem-pairs -canonicalize-aliases -bdce -nary-reassociate -simple-loop-unswitch -insert-gcov-profiling -loop-simplify -partial-inliner -loop-unswitch -die -sancov -insert-gcov-profiling -break-crit-edges -functionattrs -break-crit-edges -loop-vectorize -ipconstprop -load-store-vectorizer -sroa -gvn -lower-matrix-intrinsics -loop-reroll -barrier -loop-simplify -rewrite-statepoints-for-gc -newgvn -sancov -coro-split -scalarizer -loop-versioning-licm -add-discriminators -mldst-motion -partial-inliner -consthoist -licm -rewrite-statepoints-for-gc -simplifycfg -jump-threading -sccp -lcssa -globaldce -deadargelim -hotcoldsplit -coro-cleanup -loop-data-prefetch -die -loop-vectorize -indvars -strip-debug-declare -jump-threading -coro-split -instcombine -float2int -instsimplify -insert-gcov-profiling -inject-tli-mappings -loop-simplify -loop-data-prefetch -lower-widenable-condition -strip-debug-declare -loop-simplifycfg -dse -indvars -loop-distribute -strip-nondebug -strip-dead-prototypes -functionattrs -ipsccp -gvn -indvars -lower-matrix-intrinsics -consthoist -alignment-from-assumptions -memcpyopt -loop-load-elim -sancov -loop-simplifycfg -barrier -strip-nondebug -infer-address-spaces -mergefunc -barrier -mem2reg -loop-guard-widening -mergereturn -loop-sink -rpo-functionattrs -sancov -add-discriminators -coro-elide -simplifycfg -rewrite-statepoints-for-gc -coro-early -name-anon-globals -loop-fusion -adce -lower-matrix-intrinsics -alignment-from-assumptions -tailcallelim -scalarizer -coro-early -loop-versioning-licm -cross-dso-cfi -coro-early -mergeicmps -strip-debug-declare -loop-simplifycfg -coro-cleanup -pgo-memop-opt -prune-eh -constprop -coro-split -div-rem-pairs -loop-fusion -jump-threading -functionattrs -lowerinvoke -functionattrs -elim-avail-extern -loop-idiom -lower-expect -argpromotion -loop-sink -rewrite-statepoints-for-gc -loop-unswitch -slp-vectorizer -lower-constant-intrinsics -lower-widenable-condition -lower-constant-intrinsics -lower-constant-intrinsics -argpromotion -argpromotion -ee-instrument -loop-load-elim -lower-guard-intrinsic -strip-dead-prototypes -correlated-propagation -forceattrs -libcalls-shrinkwrap -alignment-from-assumptions -always-inline -jump-threading -loop-fusion -canonicalize-aliases -coro-cleanup -mldst-motion -loop-interchange -rpo-functionattrs -loop-idiom -loop-simplify -rewrite-statepoints-for-gc -instcombine -loop-load-elim -irce -memcpyopt -loop-fusion -cross-dso-cfi -loop-predication -loweratomic -lower-widenable-condition -correlated-propagation -slsr -gvn-hoist -loop-instsimplify -mergefunc -mem2reg -sink -constmerge -loop-simplifycfg -forceattrs -lower-matrix-intrinsics -prune-eh -attributor -argpromotion -sccp -gvn -simple-loop-unswitch -dse -loop-simplifycfg -irce -reassociate -break-crit-edges -strip-debug-declare -mem2reg -loop-versioning-licm -attributor -globalopt -loop-deletion -loop-sink -rpo-functionattrs -loop-load-elim -tailcallelim -loop-reroll -jump-threading -lower-guard-intrinsic -globalopt -consthoist -callsite-splitting -loop-reroll -loop-unroll-and-jam -alignment-from-assumptions -nary-reassociate -loop-versioning-licm -simple-loop-unswitch -loop-deletion -mergeicmps -argpromotion -float2int -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.020702533887118,75.7045681476593,opt -newgvn -insert-gcov-profiling -bdce -indvars -deadargelim -dse -loop-guard-widening -always-inline -aggressive-instcombine -div-rem-pairs -load-store-vectorizer -constmerge -globalopt -ipconstprop -rewrite-statepoints-for-gc -gvn-hoist -lcssa -post-inline-ee-instrument -hotcoldsplit -lowerswitch -break-crit-edges -indvars -loop-guard-widening -loop-reroll -inject-tli-mappings -mem2reg -globalsplit -constmerge -insert-gcov-profiling -slp-vectorizer -lowerswitch -callsite-splitting -licm -loop-unroll-and-jam -separate-const-offset-from-gep -strip-debug-declare -loop-guard-widening -argpromotion -inject-tli-mappings -aggressive-instcombine -licm -add-discriminators -loop-load-elim -licm -lower-constant-intrinsics -hotcoldsplit -simple-loop-unswitch -infer-address-spaces -partially-inline-libcalls -strip-dead-prototypes -globaldce -argpromotion -loop-idiom -constmerge -rewrite-statepoints-for-gc -infer-address-spaces -nary-reassociate -loop-simplify -loop-predication -strip-dead-prototypes -loop-distribute -loop-guard-widening -called-value-propagation -loop-interchange -forceattrs -loop-guard-widening -ipsccp -strip -mem2reg -globalsplit -loop-simplifycfg -div-rem-pairs -guard-widening -load-store-vectorizer -early-cse-memssa -loop-versioning-licm -partial-inliner -elim-avail-extern -loop-sink -lower-guard-intrinsic -indvars -loop-sink -canonicalize-aliases -pgo-memop-opt -loop-load-elim -loop-data-prefetch -lower-constant-intrinsics -functionattrs -sroa -strip-nondebug -constprop -lower-matrix-intrinsics -flattencfg -loweratomic -alignment-from-assumptions -flattencfg -inferattrs -functionattrs -canonicalize-aliases -flattencfg -loop-distribute -simple-loop-unswitch -loop-guard-widening -prune-eh -lower-widenable-condition -strip-debug-declare -insert-gcov-profiling -deadargelim -cross-dso-cfi -ee-instrument -loop-versioning-licm -ipconstprop -sccp -mergeicmps -simplifycfg -float2int -loop-reroll -inferattrs -globaldce -lower-guard-intrinsic -instcombine -sccp -newgvn -newgvn -globaldce input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.020992304967964,74.4376745223999,opt -insert-gcov-profiling -sroa -load-store-vectorizer -reassociate -nary-reassociate -loop-guard-widening -die -sancov -aggressive-instcombine -ee-instrument -rpo-functionattrs -loop-versioning-licm -aggressive-instcombine -jump-threading -lower-matrix-intrinsics -cross-dso-cfi -post-inline-ee-instrument -tailcallelim -reassociate -strip -newgvn -always-inline -instnamer -sink -lcssa -strip-dead-prototypes -irce -mldst-motion -correlated-propagation -libcalls-shrinkwrap -nary-reassociate -loop-guard-widening -called-value-propagation -prune-eh -strip-nondebug -inject-tli-mappings -lower-widenable-condition -consthoist -simplifycfg -slsr -licm -scalarizer -sancov -constmerge -early-cse-memssa -callsite-splitting -separate-const-offset-from-gep -simple-loop-unswitch -sancov -cross-dso-cfi -instcombine -gvn-hoist -gvn -memcpyopt -mem2reg -inferattrs -loop-distribute -sroa -constprop -loop-instsimplify -cross-dso-cfi -gvn-hoist -partially-inline-libcalls -load-store-vectorizer -memcpyopt -ee-instrument -instcombine input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.022408963585434,71.32278347015381,opt -correlated-propagation -float2int -name-anon-globals -jump-threading -redundant-dbg-inst-elim -loop-data-prefetch -redundant-dbg-inst-elim -div-rem-pairs -sancov -correlated-propagation -slp-vectorizer -mem2reg -simplifycfg -coro-elide -libcalls-shrinkwrap -strip-dead-prototypes -float2int -slp-vectorizer -globaldce -slp-vectorizer -separate-const-offset-from-gep -early-cse-memssa -flattencfg -lower-constant-intrinsics -instnamer -libcalls-shrinkwrap -loop-vectorize -dce -inject-tli-mappings -functionattrs -instcombine -float2int -strip-dead-prototypes -bdce -gvn-hoist -loop-idiom -newgvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0232460800412118,73.95274901390076,opt -sink -guard-widening -cross-dso-cfi -hotcoldsplit -mergereturn -break-crit-edges -licm -inject-tli-mappings -break-crit-edges -argpromotion -alignment-from-assumptions -rewrite-statepoints-for-gc -die -ipsccp -slsr -loop-predication -bdce -constprop -rewrite-statepoints-for-gc -coro-split -slsr -lower-expect -aggressive-instcombine -lcssa -div-rem-pairs -separate-const-offset-from-gep -sroa -partially-inline-libcalls -libcalls-shrinkwrap -sroa -guard-widening -loop-simplifycfg -instcombine -nary-reassociate -canonicalize-aliases -licm -newgvn -gvn -mergeicmps -loop-unroll-and-jam -attributor -ipconstprop -partial-inliner -elim-avail-extern -loop-guard-widening -pgo-memop-opt -lowerswitch -slp-vectorizer -guard-widening -inferattrs -slsr -instcombine -lower-guard-intrinsic -simplifycfg -mldst-motion -sancov -ee-instrument -memcpyopt -bdce input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.027367268746579,74.0155394077301,opt -elim-avail-extern -strip-nondebug -dse -lower-matrix-intrinsics -loop-reduce -globalopt -reg2mem -early-cse-memssa -separate-const-offset-from-gep -separate-const-offset-from-gep -argpromotion -instsimplify -dce -reassociate -jump-threading -globalopt -lcssa -bdce -simple-loop-unswitch -mem2reg -guard-widening -tailcallelim -instcombine -loop-predication -coro-elide -tailcallelim -licm -licm -lower-expect -simplifycfg -libcalls-shrinkwrap -mergereturn -newgvn input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0304903570623651,81.23560118675232,opt -newgvn -coro-early -hotcoldsplit -loop-idiom -canonicalize-aliases -loop-interchange -always-inline -lcssa -strip -rewrite-statepoints-for-gc -float2int -alignment-from-assumptions -sink -aggressive-instcombine -callsite-splitting -constmerge -insert-gcov-profiling -canonicalize-aliases -irce -lower-widenable-condition -callsite-splitting -lower-expect -gvn-hoist -loop-interchange -mem2reg -sancov -simplifycfg -instsimplify -canonicalize-aliases -speculative-execution -mergefunc -libcalls-shrinkwrap -instcombine -instsimplify -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.0318104253195528,73.58163642883301,opt -instsimplify -reassociate -loop-instsimplify -coro-elide -rpo-functionattrs -alignment-from-assumptions -alignment-from-assumptions -ee-instrument -loop-load-elim -sink -loop-instsimplify -loop-versioning-licm -called-value-propagation -pgo-memop-opt -loop-simplify -inferattrs -separate-const-offset-from-gep -globalsplit -flattencfg -rewrite-statepoints-for-gc -licm -loop-unroll-and-jam -newgvn -rpo-functionattrs -strip-dead-prototypes -loop-vectorize -sroa -load-store-vectorizer -mergereturn -ipsccp -attributor -insert-gcov-profiling -globalsplit -bdce -coro-elide -always-inline -loop-reroll -loop-sink -newgvn -add-discriminators -loop-fusion -adce -break-crit-edges -loop-reroll -pgo-memop-opt -forceattrs -simple-loop-unswitch -die -early-cse-memssa -mergefunc -partially-inline-libcalls -gvn -loop-vectorize -instcombine -globalopt -partially-inline-libcalls -sancov -loop-unroll-and-jam -loop-sink -globaldce -break-crit-edges -mldst-motion -jump-threading -sancov -dce -lower-widenable-condition -loop-data-prefetch -dce -memcpyopt -lower-widenable-condition -slsr -cross-dso-cfi -hotcoldsplit -inject-tli-mappings -bdce -lcssa -rpo-functionattrs -licm -constprop -lower-widenable-condition -partially-inline-libcalls -inferattrs -loop-vectorize -constprop -speculative-execution -lower-expect -always-inline -cross-dso-cfi -slp-vectorizer -load-store-vectorizer -mergereturn -early-cse-memssa -slp-vectorizer -loweratomic -attributor -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/jpeg-d,1.040793328825783,74.14569687843323,opt -prune-eh -loop-data-prefetch -partially-inline-libcalls -loop-fusion -strip -canonicalize-aliases -loop-interchange -coro-cleanup -jump-threading -early-cse-memssa -consthoist -loop-unroll -loop-data-prefetch -sink -loop-unroll -mem2reg -loop-instsimplify -pgo-memop-opt -simplifycfg -inferattrs -simple-loop-unswitch -loop-instsimplify -functionattrs -called-value-propagation -mergefunc -mldst-motion -jump-threading -insert-gcov-profiling -strip-dead-prototypes -loop-vectorize -loop-guard-widening -callsite-splitting -mem2reg -canonicalize-aliases -sroa -loop-load-elim -loop-predication -die -lcssa -irce -ipconstprop -loop-versioning-licm -indvars -sccp -mergefunc -mergereturn -memcpyopt -ipconstprop -always-inline -ipsccp -float2int -newgvn -reassociate -loop-instsimplify -strip-dead-prototypes -correlated-propagation -guard-widening -memcpyopt -alignment-from-assumptions -lower-guard-intrinsic -irce -loop-vectorize -attributor -loop-data-prefetch -licm -loop-predication -consthoist -barrier -dce -infer-address-spaces -mem2reg -mem2reg -prune-eh -gvn -inject-tli-mappings -adce -tailcallelim -gvn-hoist -globalsplit -loop-distribute -prune-eh -ipconstprop -instcombine -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/lame,1.0177636073787293,82.4673900604248,opt -canonicalize-aliases -loweratomic -loop-unroll-and-jam -loop-vectorize -infer-address-spaces -loop-instsimplify -break-crit-edges -rewrite-statepoints-for-gc -nary-reassociate -mergefunc -post-inline-ee-instrument -name-anon-globals -flattencfg -functionattrs -strip-debug-declare -loop-vectorize -lowerinvoke -strip-nondebug -redundant-dbg-inst-elim -simple-loop-unswitch -memcpyopt -instnamer -lower-widenable-condition -sink -newgvn -loop-load-elim -pgo-memop-opt -scalarizer -loop-reroll -flattencfg -early-cse-memssa -early-cse-memssa -lowerswitch -sroa -loop-predication -mem2reg -reg2mem -mergeicmps -float2int -die -mergefunc -loop-unroll -lower-constant-intrinsics -instsimplify -bdce -simple-loop-unswitch -loop-guard-widening -globalsplit -loop-distribute -ee-instrument -loop-guard-widening -lower-matrix-intrinsics -bdce -loop-sink -instnamer -infer-address-spaces -strip-dead-prototypes -loop-guard-widening -libcalls-shrinkwrap -adce -gvn -loop-predication -tailcallelim -consthoist -attributor -inject-tli-mappings -correlated-propagation -loop-predication -elim-avail-extern -loop-unroll-and-jam -forceattrs -slsr -partial-inliner -loop-simplifycfg -early-cse-memssa -loweratomic -mldst-motion -loop-reroll -div-rem-pairs -lcssa -loop-versioning -instcombine -alignment-from-assumptions -loop-versioning-licm -coro-split -sccp -guard-widening -lowerinvoke -aggressive-instcombine -hotcoldsplit -adce -adce -loop-simplify -cross-dso-cfi -pgo-memop-opt -always-inline -gvn -add-discriminators -prune-eh -callsite-splitting -memcpyopt -loop-predication -barrier -sroa -strip-dead-prototypes -coro-early -lower-constant-intrinsics -instsimplify -mem2reg -ipsccp -dse -reassociate -loop-data-prefetch -reassociate -canonicalize-aliases -constprop -coro-elide -loop-versioning -float2int -coro-split -inferattrs -loop-vectorize -early-cse-memssa -slp-vectorizer -sancov -ipconstprop -irce -ee-instrument -strip-debug-declare -partially-inline-libcalls -jump-threading -argpromotion -coro-early -strip -bdce -loop-fusion -ipsccp -globaldce -div-rem-pairs -pgo-memop-opt -lowerswitch -insert-gcov-profiling -reassociate -deadargelim -mem2reg -break-crit-edges -partial-inliner -post-inline-ee-instrument -coro-cleanup -irce -lower-guard-intrinsic -correlated-propagation -aggressive-instcombine -add-discriminators -ipconstprop -loop-distribute -lower-constant-intrinsics -separate-const-offset-from-gep -bdce -loop-versioning -dse -coro-cleanup -inferattrs -early-cse-memssa -argpromotion -instcombine -loweratomic -licm -alignment-from-assumptions -mergefunc -deadargelim -strip-dead-prototypes -sink -loop-unswitch -load-store-vectorizer -adce -strip-dead-prototypes -early-cse-memssa -pgo-memop-opt -slp-vectorizer -elim-avail-extern -prune-eh -loop-distribute -coro-elide -gvn-hoist -deadargelim -loop-distribute -reg2mem -reg2mem -mem2reg -attributor -guard-widening -partial-inliner -sink -loop-simplifycfg -loop-idiom -instsimplify -break-crit-edges -loop-unswitch -hotcoldsplit -simplifycfg -float2int -loop-instsimplify -div-rem-pairs -strip-dead-prototypes -guard-widening -indvars -loop-versioning-licm -loop-instsimplify -prune-eh -loop-versioning-licm -globalopt -attributor -lowerswitch -coro-split -sink -mergeicmps -rewrite-statepoints-for-gc -lower-guard-intrinsic -loop-sink -hotcoldsplit -rewrite-statepoints-for-gc -loop-fusion -coro-early -loop-vectorize -mergereturn -div-rem-pairs -mldst-motion -gvn -pgo-memop-opt -forceattrs -speculative-execution -ipsccp -loop-unroll-and-jam -strip -correlated-propagation -lower-widenable-condition -lower-constant-intrinsics -float2int -constprop -strip-nondebug -scalarizer -slp-vectorizer -deadargelim -inject-tli-mappings -lower-widenable-condition -rewrite-statepoints-for-gc -memcpyopt -ipsccp -globaldce -instnamer -coro-early -insert-gcov-profiling -loop-data-prefetch -tailcallelim -instnamer -globalsplit -inferattrs -lower-guard-intrinsic -slsr -always-inline -float2int -globalopt -deadargelim -instcombine -sroa -float2int -lowerswitch -loop-simplifycfg -libcalls-shrinkwrap -die -sink -loop-simplify -loop-simplifycfg -mergefunc -infer-address-spaces -loop-versioning -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/lame,1.0220906399453424,80.74984622001648,opt -lower-guard-intrinsic -loop-predication -mem2reg -mergeicmps -correlated-propagation -mergereturn -coro-split -loop-predication -inject-tli-mappings -prune-eh -correlated-propagation -name-anon-globals -lower-constant-intrinsics -prune-eh -loop-instsimplify -simplifycfg -canonicalize-aliases -ee-instrument -loop-versioning -alignment-from-assumptions -mem2reg -cross-dso-cfi -canonicalize-aliases -die -simplifycfg -slp-vectorizer -globalopt -loop-fusion -callsite-splitting -loop-instsimplify -simple-loop-unswitch -instcombine -mergeicmps -tailcallelim -reassociate -attributor -insert-gcov-profiling -newgvn input.bc -o output.bc +benchmark://cbench-v1/lame,1.026000151825704,89.91641187667847,opt -ipsccp -coro-elide -strip-debug-declare -strip-dead-prototypes -sroa -consthoist -lowerswitch -loweratomic -loop-simplifycfg -coro-elide -alignment-from-assumptions -tailcallelim -lcssa -instnamer -pgo-memop-opt -irce -rewrite-statepoints-for-gc -forceattrs -cross-dso-cfi -mergereturn -loop-sink -gvn-hoist -rpo-functionattrs -float2int -infer-address-spaces -libcalls-shrinkwrap -deadargelim -functionattrs -consthoist -mldst-motion -globalsplit -die -aggressive-instcombine -bdce -aggressive-instcombine -licm -gvn-hoist -slsr -loop-deletion -slsr -loop-idiom -coro-early -licm -globalopt -nary-reassociate -early-cse-memssa -barrier -lowerinvoke -sroa -flattencfg -insert-gcov-profiling -adce -loop-versioning -loop-simplifycfg -partially-inline-libcalls -ee-instrument -simple-loop-unswitch -instnamer -post-inline-ee-instrument -simple-loop-unswitch -ipsccp -bdce -loop-interchange -break-crit-edges -jump-threading -redundant-dbg-inst-elim -lower-expect -always-inline -simplifycfg -speculative-execution -coro-elide -loop-guard-widening -mergefunc -strip-nondebug -mldst-motion -jump-threading -die -loop-guard-widening -instsimplify -prune-eh -ipsccp -instcombine input.bc -o output.bc +benchmark://cbench-v1/lame,1.0306687922265239,78.65229177474976,opt -callsite-splitting -simplifycfg -indvars -mem2reg -correlated-propagation -lower-widenable-condition -constprop -loop-instsimplify -partial-inliner -callsite-splitting -sccp -loop-vectorize -loop-data-prefetch -mergefunc -newgvn -coro-early -loop-idiom -simplifycfg -loop-predication -coro-early -gvn -loweratomic -consthoist -argpromotion -loop-interchange -mldst-motion -loop-deletion -loop-predication -partially-inline-libcalls -jump-threading -instcombine -deadargelim -constprop -name-anon-globals -functionattrs -tailcallelim -attributor -loop-unroll-and-jam -always-inline -memcpyopt -aggressive-instcombine -ee-instrument -loop-vectorize -loop-simplify -mldst-motion -loop-sink -instcombine -ipsccp -jump-threading -elim-avail-extern input.bc -o output.bc +benchmark://cbench-v1/lame,1.0326804828057392,102.16820931434631,opt -jump-threading -strip -inferattrs -gvn -loop-fusion -barrier -canonicalize-aliases -deadargelim -mergefunc -post-inline-ee-instrument -sroa -coro-split -redundant-dbg-inst-elim -loop-reroll -sccp -indvars -reassociate -irce -lower-constant-intrinsics -loop-simplify -post-inline-ee-instrument -mem2reg -slsr -loop-versioning-licm -separate-const-offset-from-gep -mergeicmps -dce -globalsplit -loop-instsimplify -flattencfg -simplifycfg -memcpyopt -rpo-functionattrs -loop-distribute -sroa -hotcoldsplit -float2int -deadargelim -globalsplit -load-store-vectorizer -float2int -rewrite-statepoints-for-gc -globalsplit -mergeicmps -add-discriminators -loop-sink -constprop -strip-dead-prototypes -argpromotion -loop-distribute -libcalls-shrinkwrap -die -loop-load-elim -instnamer -indvars -correlated-propagation -instnamer -instcombine -strip-debug-declare -early-cse-memssa -loop-idiom -ee-instrument -loop-guard-widening -coro-split -lower-guard-intrinsic -cross-dso-cfi -licm -alignment-from-assumptions -flattencfg -consthoist -bdce -add-discriminators -elim-avail-extern -loop-unroll-and-jam -loop-simplifycfg -memcpyopt -speculative-execution -globaldce -loop-interchange -rpo-functionattrs -loop-distribute -mergereturn -memcpyopt -separate-const-offset-from-gep -mergefunc -deadargelim -reassociate -libcalls-shrinkwrap -loop-versioning -mldst-motion -newgvn -nary-reassociate -instcombine input.bc -o output.bc +benchmark://cbench-v1/lame,1.0330600470659683,195.33090710639954,opt -separate-const-offset-from-gep -coro-early -bdce -pgo-memop-opt -nary-reassociate -loop-sink -loop-unswitch -loop-simplifycfg -globalopt -coro-elide -loop-vectorize -break-crit-edges -irce -sccp -coro-cleanup -speculative-execution -functionattrs -called-value-propagation -instnamer -loop-vectorize -argpromotion -mldst-motion -mergereturn -flattencfg -loop-unroll-and-jam -loop-distribute -globalopt -always-inline -instnamer -separate-const-offset-from-gep -load-store-vectorizer -coro-early -lower-guard-intrinsic -insert-gcov-profiling -insert-gcov-profiling -irce -loop-idiom -coro-elide -float2int -licm -loop-simplifycfg -sink -lower-matrix-intrinsics -inject-tli-mappings -lower-expect -inferattrs -simple-loop-unswitch -adce -ipconstprop -strip-nondebug -called-value-propagation -dce -loop-deletion -bdce -float2int -lower-expect -slp-vectorizer -post-inline-ee-instrument -guard-widening -sink -loop-reroll -argpromotion -break-crit-edges -coro-split -mem2reg -guard-widening -simplifycfg -hotcoldsplit -rpo-functionattrs -loop-instsimplify -dse -globaldce -loop-idiom -alignment-from-assumptions -loop-sink -redundant-dbg-inst-elim -gvn-hoist -loop-deletion -loop-simplifycfg -newgvn -rewrite-statepoints-for-gc -strip-nondebug -elim-avail-extern -strip-debug-declare -attributor -lower-expect -lowerinvoke -div-rem-pairs -libcalls-shrinkwrap -tailcallelim -always-inline -instcombine -lowerinvoke -indvars -nary-reassociate -mldst-motion -loop-guard-widening -aggressive-instcombine -mem2reg -deadargelim -attributor -attributor -infer-address-spaces -callsite-splitting -correlated-propagation -attributor -loop-versioning -float2int -hotcoldsplit -hotcoldsplit -inject-tli-mappings -argpromotion -break-crit-edges -instcombine -rewrite-statepoints-for-gc -loop-interchange -loop-data-prefetch -float2int -lower-constant-intrinsics -loop-guard-widening -globaldce -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/lame,1.0341607834206334,72.04348230361938,opt -loop-unswitch -licm -lower-constant-intrinsics -dse -irce -strip-debug-declare -hotcoldsplit -sroa -strip-debug-declare -callsite-splitting -early-cse-memssa -lower-constant-intrinsics -die -div-rem-pairs -lower-expect -attributor -reassociate -insert-gcov-profiling -ee-instrument -deadargelim -correlated-propagation -dse -loop-load-elim -coro-split -strip -loop-versioning-licm -loop-predication -mem2reg -guard-widening -strip -float2int -loop-guard-widening -strip-dead-prototypes -loop-instsimplify -globalsplit -elim-avail-extern -loop-versioning -ipconstprop -irce -inject-tli-mappings -insert-gcov-profiling -gvn-hoist -die -lowerswitch -partially-inline-libcalls -gvn -die -instsimplify -post-inline-ee-instrument -loop-sink -loop-unroll-and-jam -loop-predication -loop-unroll-and-jam -ipconstprop -loop-versioning -sroa -cross-dso-cfi -instnamer -loop-vectorize -constmerge -loop-instsimplify -sccp -lower-constant-intrinsics -sink -mergefunc -reassociate -add-discriminators -sccp -instcombine -instcombine -loop-simplifycfg -loop-fusion -slsr -inject-tli-mappings -irce -alignment-from-assumptions -loop-versioning-licm -sccp -post-inline-ee-instrument -lowerinvoke -ipsccp -flattencfg -loop-instsimplify -ee-instrument -flattencfg -simplifycfg -infer-address-spaces -memcpyopt -loop-load-elim -coro-elide -loop-guard-widening -rpo-functionattrs -adce -loop-simplify -newgvn input.bc -o output.bc +benchmark://cbench-v1/lame,1.039892203750095,87.48616743087769,opt -insert-gcov-profiling -gvn-hoist -loop-deletion -strip-debug-declare -adce -strip-debug-declare -lower-expect -early-cse-memssa -loop-reroll -partially-inline-libcalls -simplifycfg -sroa -instcombine -gvn -infer-address-spaces -lowerinvoke -loop-predication -memcpyopt -nary-reassociate -reg2mem -coro-elide -loop-instsimplify -simple-loop-unswitch -sroa -called-value-propagation -lcssa -loop-fusion -rewrite-statepoints-for-gc -separate-const-offset-from-gep -lower-matrix-intrinsics -irce -loop-unswitch -loop-reroll -lower-guard-intrinsic -ipconstprop -simplifycfg -mergereturn -coro-early -argpromotion -instcombine -mergereturn -lower-guard-intrinsic -strip -elim-avail-extern -ipsccp input.bc -o output.bc +benchmark://cbench-v1/lame,1.0432703256661353,320.4585802555084,opt -separate-const-offset-from-gep -irce -jump-threading -constprop -loop-deletion -sroa -newgvn -licm -lowerinvoke -canonicalize-aliases -inferattrs -simple-loop-unswitch -speculative-execution -name-anon-globals -adce -sancov -die -instsimplify -separate-const-offset-from-gep -inject-tli-mappings -lower-guard-intrinsic -licm -lower-matrix-intrinsics -mergereturn -constprop -instcombine -mem2reg -loop-instsimplify -inferattrs -loop-data-prefetch -mergereturn -irce -speculative-execution -loop-versioning-licm -called-value-propagation -globaldce -loop-reroll -forceattrs -ee-instrument -sccp -inferattrs -loop-load-elim -barrier -simplifycfg -loop-fusion -loop-reroll -loop-distribute -insert-gcov-profiling -lower-widenable-condition -sink -div-rem-pairs -redundant-dbg-inst-elim -loop-instsimplify -deadargelim -nary-reassociate -correlated-propagation -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/lame,1.0480528353450238,136.65584301948547,opt -globalsplit -inject-tli-mappings -mergefunc -tailcallelim -libcalls-shrinkwrap -gvn-hoist -loop-fusion -loop-versioning -prune-eh -loop-interchange -strip-debug-declare -loop-sink -flattencfg -dce -elim-avail-extern -consthoist -barrier -float2int -globalopt -sroa -gvn-hoist -correlated-propagation -gvn -float2int -simple-loop-unswitch -functionattrs -globalsplit -newgvn -instsimplify -simplifycfg -simple-loop-unswitch -loop-versioning -functionattrs -newgvn -loweratomic -pgo-memop-opt -lcssa -adce -insert-gcov-profiling -loop-unroll-and-jam -infer-address-spaces -loop-data-prefetch -loop-deletion -correlated-propagation -rpo-functionattrs -lcssa -instcombine -loop-reroll -flattencfg -loop-predication -functionattrs -scalarizer -insert-gcov-profiling -tailcallelim -loop-fusion -mergefunc -sancov -loop-interchange -loop-unroll-and-jam -loop-sink -inject-tli-mappings -globalopt -loweratomic -sroa -separate-const-offset-from-gep -prune-eh -mergereturn -loop-distribute -deadargelim -loop-instsimplify -ipconstprop -simplifycfg -loop-data-prefetch -pgo-memop-opt -add-discriminators -coro-elide -pgo-memop-opt -partially-inline-libcalls -sccp -rpo-functionattrs -sccp -memcpyopt -constprop -rewrite-statepoints-for-gc -indvars -dce -ipconstprop -globalsplit -argpromotion -called-value-propagation -strip-debug-declare -redundant-dbg-inst-elim -lower-expect -globaldce -ee-instrument -newgvn -mldst-motion input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9955506117908788,61.57529139518738,opt -loop-sink -simplifycfg -lower-widenable-condition -strip -inject-tli-mappings -mldst-motion -lower-constant-intrinsics -adce -loop-distribute -loop-predication -lower-matrix-intrinsics -rpo-functionattrs -lowerinvoke -name-anon-globals -load-store-vectorizer -coro-cleanup -hotcoldsplit -ipsccp -consthoist -guard-widening -strip-debug-declare -bdce -coro-early -bdce -loop-interchange -simplifycfg -redundant-dbg-inst-elim -simplifycfg -loop-guard-widening -forceattrs -loop-versioning -ipconstprop -name-anon-globals -canonicalize-aliases -barrier -loop-data-prefetch -post-inline-ee-instrument -tailcallelim -mem2reg -simplifycfg -ipsccp -loop-interchange -scalarizer -prune-eh -nary-reassociate -post-inline-ee-instrument -nary-reassociate -loop-deletion -argpromotion -insert-gcov-profiling -loop-deletion -constmerge -add-discriminators -gvn -dse -instcombine -functionattrs -coro-elide -loop-load-elim -strip-nondebug -loop-load-elim -ee-instrument -gvn -attributor -die -globalopt -redundant-dbg-inst-elim -strip-dead-prototypes -sccp -float2int -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9955506117908788,61.80874562263489,opt -rpo-functionattrs -lowerswitch -rpo-functionattrs -loop-unroll -early-cse-memssa -deadargelim -hotcoldsplit -inferattrs -mldst-motion -flattencfg -argpromotion -load-store-vectorizer -forceattrs -newgvn -post-inline-ee-instrument -loop-simplifycfg -mldst-motion -globaldce -name-anon-globals -add-discriminators -ee-instrument -mergereturn -loweratomic -sink -argpromotion -jump-threading -consthoist -strip -break-crit-edges -coro-cleanup -lower-matrix-intrinsics -loop-interchange -guard-widening -loop-unroll-and-jam -loop-instsimplify -loop-data-prefetch -jump-threading -indvars -loop-simplifycfg -strip-debug-declare -instnamer -div-rem-pairs -ee-instrument -lower-guard-intrinsic -lower-constant-intrinsics -loop-load-elim -coro-split -lowerinvoke -loop-guard-widening -speculative-execution -loop-unroll-and-jam -loweratomic -gvn -dse -loop-predication -strip -correlated-propagation -die -loop-sink -mem2reg -functionattrs -coro-split -loop-instsimplify -always-inline -globaldce -sroa -loop-simplifycfg -irce -consthoist -attributor -flattencfg -separate-const-offset-from-gep -barrier -ee-instrument -guard-widening -mergereturn -partially-inline-libcalls -loop-simplifycfg -die -loop-deletion -reassociate -strip-dead-prototypes -ipsccp -irce -loop-load-elim -irce -bdce -insert-gcov-profiling -loop-reroll -loop-simplifycfg -strip -lower-guard-intrinsic -loop-reduce -instnamer -deadargelim -coro-split -licm -rpo-functionattrs -loop-deletion -add-discriminators -name-anon-globals -called-value-propagation -loop-versioning -loop-data-prefetch -gvn-hoist -guard-widening -loop-deletion -div-rem-pairs -instcombine -partial-inliner -name-anon-globals -indvars -insert-gcov-profiling -strip-nondebug -globalopt -newgvn -float2int -redundant-dbg-inst-elim -callsite-splitting -deadargelim -ipsccp -loop-predication -loop-simplifycfg -alignment-from-assumptions -barrier -cross-dso-cfi -redundant-dbg-inst-elim -early-cse-memssa -argpromotion -loop-versioning -callsite-splitting -called-value-propagation -loop-versioning-licm -instcombine -sccp -loop-unroll -simplifycfg -strip -loop-sink -consthoist -strip-nondebug -instsimplify -infer-address-spaces -globaldce -loop-guard-widening -die -instnamer -simplifycfg -rewrite-statepoints-for-gc -instcombine input.bc -o output.bc +benchmark://cbench-v1/patricia,0.995550611790879,61.725738286972046,opt -inferattrs -attributor -partially-inline-libcalls -correlated-propagation -speculative-execution -ipsccp -elim-avail-extern -coro-cleanup -loop-versioning-licm -forceattrs -nary-reassociate -constprop -coro-cleanup -loop-simplifycfg -attributor -simple-loop-unswitch -consthoist -constprop -correlated-propagation -partial-inliner -gvn -rewrite-statepoints-for-gc -slp-vectorizer -barrier -instnamer -loop-simplifycfg -instcombine -deadargelim -dce -scalarizer -newgvn -alignment-from-assumptions -loop-interchange -called-value-propagation -functionattrs -guard-widening -forceattrs -loop-interchange -loop-guard-widening -indvars -sccp -early-cse-memssa -dse -correlated-propagation -instnamer -mldst-motion -redundant-dbg-inst-elim -loop-distribute -slsr -loop-predication -lower-matrix-intrinsics -lower-matrix-intrinsics -coro-early -strip-dead-prototypes -hotcoldsplit -loop-simplifycfg -loop-interchange -pgo-memop-opt -memcpyopt -loop-simplifycfg -coro-cleanup -indvars -loop-load-elim -mem2reg -bdce -reassociate -loop-versioning-licm -callsite-splitting -rewrite-statepoints-for-gc -loop-data-prefetch -loop-load-elim -rpo-functionattrs -loweratomic -loop-load-elim -newgvn -gvn-hoist -inferattrs -dce -coro-early -dce -lower-widenable-condition -loweratomic -pgo-memop-opt -dse -die -mem2reg -loop-guard-widening -ipsccp -inferattrs -aggressive-instcombine -instnamer -gvn-hoist -lower-matrix-intrinsics -memcpyopt -libcalls-shrinkwrap -partial-inliner -loop-reduce -reassociate -lower-expect -loop-deletion -instnamer -mergefunc -loop-simplifycfg -lower-widenable-condition -pgo-memop-opt -strip -deadargelim -coro-elide -barrier -newgvn -gvn -sancov -float2int -inject-tli-mappings -barrier -coro-split -tailcallelim -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9977753058954394,61.65921092033386,opt -loop-reroll -coro-early -libcalls-shrinkwrap -loop-guard-widening -loop-unswitch -callsite-splitting -post-inline-ee-instrument -early-cse-memssa -add-discriminators -mldst-motion -strip-nondebug -loop-unswitch -break-crit-edges -infer-address-spaces -sroa -instnamer -loop-fusion -loop-sink -flattencfg -lower-constant-intrinsics -reg2mem -indvars -indvars -mergefunc -insert-gcov-profiling -flattencfg -mldst-motion -elim-avail-extern -loop-vectorize -prune-eh -partial-inliner -functionattrs -speculative-execution -bdce -dce -canonicalize-aliases -coro-elide -pgo-memop-opt -prune-eh -mergefunc -simplifycfg -mergeicmps -loop-unroll-and-jam -lower-guard-intrinsic -mergereturn -bdce -libcalls-shrinkwrap -loop-simplifycfg -coro-split -dse -lowerinvoke -loop-deletion -loop-guard-widening -pgo-memop-opt -load-store-vectorizer -correlated-propagation -loop-sink -loop-guard-widening -mergeicmps -loop-distribute -strip -inject-tli-mappings -loop-reduce -strip-debug-declare -strip -coro-cleanup -irce -simple-loop-unswitch -scalarizer -gvn-hoist -sancov -called-value-propagation -simplifycfg -globalopt -always-inline -rewrite-statepoints-for-gc -ee-instrument -div-rem-pairs -add-discriminators -lower-expect -coro-elide -loop-versioning -ipconstprop -loop-deletion -coro-split -die -mem2reg -gvn -rewrite-statepoints-for-gc -strip-nondebug -attributor -adce -elim-avail-extern -loop-instsimplify -aggressive-instcombine -name-anon-globals -constprop -mergefunc -ee-instrument -lower-expect -separate-const-offset-from-gep -loop-guard-widening -adce -strip -loop-deletion -loop-instsimplify -add-discriminators -newgvn -constprop -instcombine -strip -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9977753058954394,62.400047063827515,opt -sancov -barrier -loop-data-prefetch -libcalls-shrinkwrap -loop-simplifycfg -mldst-motion -strip-dead-prototypes -coro-elide -loop-reduce -loop-idiom -globalopt -loop-sink -loop-unroll-and-jam -canonicalize-aliases -barrier -indvars -strip-nondebug -float2int -simplifycfg -forceattrs -infer-address-spaces -cross-dso-cfi -loop-unroll -coro-cleanup -bdce -nary-reassociate -globalsplit -licm -nary-reassociate -callsite-splitting -slsr -float2int -correlated-propagation -lower-widenable-condition -globalsplit -ee-instrument -callsite-splitting -add-discriminators -constmerge -loop-distribute -functionattrs -flattencfg -early-cse-memssa -lower-constant-intrinsics -correlated-propagation -lower-constant-intrinsics -rewrite-statepoints-for-gc -functionattrs -ipconstprop -rewrite-statepoints-for-gc -insert-gcov-profiling -constmerge -guard-widening -loop-sink -loop-guard-widening -partially-inline-libcalls -mergefunc -partial-inliner -loop-load-elim -loop-data-prefetch -mem2reg -flattencfg -alignment-from-assumptions -called-value-propagation -partially-inline-libcalls -rewrite-statepoints-for-gc -loop-reroll -loop-simplifycfg -instnamer -coro-split -loop-interchange -strip -instcombine -gvn -nary-reassociate -lowerinvoke -globaldce -aggressive-instcombine -globaldce -float2int -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9988876529477196,61.67392659187317,opt -strip -break-crit-edges -loop-unroll-and-jam -correlated-propagation -rpo-functionattrs -functionattrs -separate-const-offset-from-gep -forceattrs -mergereturn -lcssa -scalarizer -redundant-dbg-inst-elim -instnamer -libcalls-shrinkwrap -coro-early -lcssa -ipconstprop -loop-unroll -lower-constant-intrinsics -coro-early -gvn -mergefunc -instcombine -strip-dead-prototypes -sancov -globalsplit -slp-vectorizer -aggressive-instcombine -name-anon-globals -elim-avail-extern -sccp -loop-guard-widening -mergereturn -loop-guard-widening -simplifycfg -add-discriminators -loop-interchange -ipconstprop -callsite-splitting -loop-simplifycfg -lower-constant-intrinsics -jump-threading -scalarizer -coro-cleanup -loop-vectorize -mldst-motion -loop-versioning -correlated-propagation -called-value-propagation -sink -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/patricia,0.9999999999999999,61.583837270736694,opt -ipconstprop -attributor -hotcoldsplit -coro-split -newgvn -barrier -irce -lower-widenable-condition -mem2reg -mergeicmps -die -name-anon-globals -always-inline -loop-deletion -globalsplit -rpo-functionattrs -reassociate -loop-interchange -break-crit-edges -lower-constant-intrinsics -argpromotion -forceattrs -rpo-functionattrs -slsr -loop-unroll -globaldce -sancov -globalopt -loop-sink -mergeicmps -simplifycfg -lower-guard-intrinsic -reg2mem -div-rem-pairs -loop-idiom -lower-constant-intrinsics -mem2reg -mergefunc -pgo-memop-opt -partially-inline-libcalls -cross-dso-cfi -loop-load-elim -instnamer -hotcoldsplit -mergereturn -add-discriminators -irce -partially-inline-libcalls -flattencfg -alignment-from-assumptions -globaldce -mem2reg -loweratomic -functionattrs -insert-gcov-profiling -lower-constant-intrinsics -loop-predication -post-inline-ee-instrument -ipconstprop -loop-vectorize -die -mergeicmps -strip-dead-prototypes -loop-predication -nary-reassociate -strip -cross-dso-cfi -instcombine -loop-distribute -strip-nondebug -constprop -guard-widening -dse -instsimplify -licm -strip-dead-prototypes -loop-fusion -newgvn -mldst-motion -constprop -reassociate -float2int -loop-load-elim -speculative-execution -flattencfg -loop-load-elim -add-discriminators -rpo-functionattrs -scalarizer -rpo-functionattrs -functionattrs -inferattrs -simplifycfg -lowerinvoke -instnamer -lower-matrix-intrinsics -dse input.bc -o output.bc +benchmark://cbench-v1/patricia,1.0000000000000002,61.69987082481384,opt -forceattrs -sink -loop-simplify -loop-simplify -adce -ee-instrument -loop-vectorize -loop-fusion -partial-inliner -loweratomic -lower-widenable-condition -mergeicmps -post-inline-ee-instrument -prune-eh -aggressive-instcombine -scalarizer -insert-gcov-profiling -slsr -barrier -loop-simplify -lower-guard-intrinsic -insert-gcov-profiling -irce -correlated-propagation -coro-cleanup -licm -lower-guard-intrinsic -speculative-execution -forceattrs -sink -break-crit-edges -lcssa -mergereturn -barrier -ee-instrument -strip-debug-declare -memcpyopt -instnamer -constprop -ee-instrument -redundant-dbg-inst-elim -strip-nondebug -mergefunc -constmerge -gvn-hoist -mem2reg -prune-eh -globalsplit -loop-unroll-and-jam -functionattrs -slp-vectorizer -simplifycfg -strip-debug-declare -indvars -reassociate -coro-cleanup -loop-predication -float2int -loop-fusion -called-value-propagation -coro-elide -bdce -loop-simplifycfg -called-value-propagation -strip -cross-dso-cfi -tailcallelim -lower-guard-intrinsic -ipsccp -mem2reg -mldst-motion -simplifycfg -instcombine -loop-idiom -loop-vectorize -always-inline -strip-debug-declare -consthoist -attributor -nary-reassociate -constmerge -loop-interchange -newgvn -lower-matrix-intrinsics -coro-early -lowerinvoke -aggressive-instcombine -simple-loop-unswitch -float2int -bdce -loop-fusion -gvn -licm -consthoist -flattencfg -simplifycfg -loop-simplify -ee-instrument -float2int -partially-inline-libcalls -irce -redundant-dbg-inst-elim -barrier -add-discriminators -jump-threading -redundant-dbg-inst-elim -infer-address-spaces -mldst-motion -canonicalize-aliases -lowerswitch -sink -always-inline -strip-nondebug -lower-constant-intrinsics -mem2reg -name-anon-globals -instsimplify input.bc -o output.bc +benchmark://cbench-v1/patricia,1.0000000000000002,61.75343203544617,opt -globalopt -memcpyopt -mergereturn -infer-address-spaces -globaldce -lowerinvoke -insert-gcov-profiling -sroa -speculative-execution -rewrite-statepoints-for-gc -nary-reassociate -guard-widening -globalopt -bdce -scalarizer -simplifycfg -lower-guard-intrinsic -float2int -loop-idiom -mergereturn -constmerge -argpromotion -loop-instsimplify -name-anon-globals -loop-reroll -globalopt -lowerinvoke -mergeicmps -nary-reassociate -simplifycfg -consthoist -mergeicmps -instnamer -flattencfg -libcalls-shrinkwrap -loop-versioning-licm -lowerinvoke -inject-tli-mappings -indvars -sink -loop-simplifycfg -ipsccp -callsite-splitting -constmerge -loweratomic -licm -loop-unroll -dse -sancov -newgvn -globalopt -argpromotion -loop-simplify -redundant-dbg-inst-elim -libcalls-shrinkwrap -post-inline-ee-instrument -attributor -loop-versioning-licm -lower-expect -correlated-propagation -early-cse-memssa -libcalls-shrinkwrap -lower-constant-intrinsics -sroa -functionattrs -loop-sink -instcombine -reg2mem -loop-predication -loop-simplifycfg -rpo-functionattrs -globaldce -scalarizer -rewrite-statepoints-for-gc -mem2reg -coro-split -loop-vectorize -coro-elide -simplifycfg -simple-loop-unswitch -ipconstprop -name-anon-globals -infer-address-spaces -loop-unroll-and-jam -sroa -loop-idiom -loop-reroll -separate-const-offset-from-gep -inferattrs -simple-loop-unswitch -ee-instrument -loop-fusion -loop-guard-widening -always-inline -rpo-functionattrs -redundant-dbg-inst-elim -instsimplify -sink -loop-reduce -gvn-hoist -mergereturn -jump-threading -pgo-memop-opt -globalopt -gvn-hoist -barrier -loop-predication -rewrite-statepoints-for-gc -partially-inline-libcalls -insert-gcov-profiling -coro-early -newgvn -tailcallelim -forceattrs -loop-guard-widening -loop-interchange -nary-reassociate -coro-early -loop-versioning -flattencfg -rpo-functionattrs -post-inline-ee-instrument -gvn -infer-address-spaces -irce -consthoist -coro-elide -functionattrs -mergefunc -reg2mem -loop-versioning-licm -mem2reg -simplifycfg -always-inline -simplifycfg -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/patricia,1.0011123470522802,61.89285445213318,opt -infer-address-spaces -redundant-dbg-inst-elim -coro-early -loop-predication -speculative-execution -loop-unroll-and-jam -mem2reg -hotcoldsplit -infer-address-spaces -memcpyopt -globalopt -elim-avail-extern -name-anon-globals -loop-versioning-licm -strip-nondebug -coro-early -dse -reg2mem -lowerinvoke -separate-const-offset-from-gep -globaldce -loop-deletion -bdce -dce -argpromotion -always-inline -loop-data-prefetch -inferattrs -coro-early -loop-guard-widening -lower-guard-intrinsic -gvn -pgo-memop-opt -rpo-functionattrs -coro-elide -nary-reassociate -dce -consthoist -scalarizer -lcssa -partially-inline-libcalls -coro-elide -gvn-hoist -adce -loop-instsimplify -licm -prune-eh -mergefunc -strip-debug-declare -newgvn -attributor -loop-unroll-and-jam -coro-early -scalarizer -scalarizer -mergereturn -cross-dso-cfi -loop-distribute -globalsplit -pgo-memop-opt -sink -indvars -globalsplit -cross-dso-cfi -inferattrs -mergereturn -loop-versioning -libcalls-shrinkwrap -called-value-propagation -loweratomic -callsite-splitting -mergeicmps -libcalls-shrinkwrap -ee-instrument -barrier -tailcallelim -ee-instrument -canonicalize-aliases -div-rem-pairs -tailcallelim -libcalls-shrinkwrap -ipconstprop -alignment-from-assumptions -redundant-dbg-inst-elim -flattencfg -loop-idiom -break-crit-edges -load-store-vectorizer -mldst-motion -globalsplit -lowerswitch -lower-matrix-intrinsics -loop-simplifycfg -nary-reassociate -ee-instrument -loop-fusion -infer-address-spaces -loop-unroll-and-jam -div-rem-pairs -libcalls-shrinkwrap -tailcallelim -elim-avail-extern -reassociate -attributor -cross-dso-cfi -loop-deletion -infer-address-spaces -loop-sink -ipsccp -canonicalize-aliases -callsite-splitting -barrier -sancov -called-value-propagation -lower-expect -loop-versioning -gvn-hoist -loop-versioning -consthoist -coro-cleanup -lcssa -name-anon-globals -simplifycfg -rewrite-statepoints-for-gc -always-inline -loop-simplify -mergefunc -loop-data-prefetch -sink -licm -argpromotion -hotcoldsplit -loop-idiom -slsr -nary-reassociate -mem2reg -insert-gcov-profiling -add-discriminators -memcpyopt -loop-sink -forceattrs -lower-guard-intrinsic -ee-instrument -pgo-memop-opt -name-anon-globals -instsimplify -loweratomic -lowerswitch -instcombine -simplifycfg -die -loop-simplifycfg -simple-loop-unswitch -adce -loop-versioning-licm -inferattrs -loop-load-elim -simple-loop-unswitch -lower-expect -attributor -strip-nondebug -loop-vectorize -attributor -slsr -strip-nondebug -cross-dso-cfi -functionattrs -newgvn input.bc -o output.bc +benchmark://cbench-v1/qsort,1.1145510835913313,61.80645179748535,opt -inferattrs -add-discriminators -memcpyopt -lowerswitch -constmerge -memcpyopt -elim-avail-extern -loop-load-elim -loop-distribute -deadargelim -loop-reroll -reg2mem -instnamer -globaldce -sancov -simple-loop-unswitch -ipconstprop -strip -loweratomic -loop-distribute -sroa -called-value-propagation -loop-distribute -instcombine -cross-dso-cfi -loop-predication -div-rem-pairs -loop-fusion -loop-reroll -loop-idiom -newgvn -globalsplit -dce -bdce -coro-cleanup -coro-cleanup -ee-instrument -coro-elide -loop-distribute -always-inline -lcssa -speculative-execution -loop-distribute -slsr -lower-matrix-intrinsics -instnamer -guard-widening -deadargelim -forceattrs -loop-deletion -rewrite-statepoints-for-gc -coro-cleanup -tailcallelim -loop-predication -loop-versioning -break-crit-edges -cross-dso-cfi -load-store-vectorizer -sink -redundant-dbg-inst-elim -break-crit-edges -sccp -lowerinvoke -deadargelim -dse -functionattrs -constmerge -tailcallelim -gvn-hoist -attributor -inject-tli-mappings -separate-const-offset-from-gep -mergefunc -flattencfg -libcalls-shrinkwrap -scalarizer -name-anon-globals -scalarizer -guard-widening -loop-data-prefetch -loop-simplifycfg -slp-vectorizer -deadargelim -loop-unswitch -dce -loop-reroll -mem2reg -indvars -flattencfg -inject-tli-mappings -div-rem-pairs -strip-dead-prototypes -loop-idiom -loop-distribute -loop-guard-widening -globaldce -sink -attributor -slp-vectorizer -ee-instrument -loop-interchange -loweratomic -lowerinvoke -partially-inline-libcalls -lowerswitch -lower-constant-intrinsics -loop-simplify -rewrite-statepoints-for-gc -adce -jump-threading -loop-load-elim -alignment-from-assumptions -globaldce -inject-tli-mappings -loop-sink -scalarizer -pgo-memop-opt -argpromotion -adce -functionattrs -sink -irce -sroa -alignment-from-assumptions -loweratomic -ipconstprop -globalsplit -lcssa -newgvn -attributor -speculative-execution -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/qsort,1.117647058823529,61.690404653549194,opt -globaldce -mergefunc -gvn-hoist -ipconstprop -mergeicmps -tailcallelim -newgvn -loop-simplifycfg -mem2reg -lower-guard-intrinsic -constprop -constmerge -mldst-motion -barrier -tailcallelim -lowerinvoke -barrier -name-anon-globals -lower-matrix-intrinsics -lcssa -strip-dead-prototypes -globaldce -loop-predication -slp-vectorizer -guard-widening -always-inline -coro-cleanup -loop-unroll-and-jam -slp-vectorizer -elim-avail-extern -instcombine -inferattrs -slp-vectorizer -lowerswitch -insert-gcov-profiling -coro-early -instnamer -strip-debug-declare -globalopt -simplifycfg -loop-deletion -globalsplit -loop-guard-widening -gvn-hoist -simplifycfg -libcalls-shrinkwrap -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/qsort,1.1207430340557274,61.65247201919556,opt -slsr -coro-cleanup -insert-gcov-profiling -lowerswitch -sink -lower-widenable-condition -post-inline-ee-instrument -coro-split -strip-debug-declare -deadargelim -lower-constant-intrinsics -loop-reroll -forceattrs -jump-threading -loop-reduce -canonicalize-aliases -loop-interchange -loop-idiom -globalsplit -loop-distribute -callsite-splitting -mergereturn -bdce -loop-vectorize -loop-unswitch -partially-inline-libcalls -ee-instrument -loop-load-elim -globaldce -coro-split -deadargelim -barrier -loweratomic -slsr -elim-avail-extern -loop-data-prefetch -sroa -alignment-from-assumptions -gvn -strip-nondebug -libcalls-shrinkwrap -indvars -loop-unroll-and-jam -guard-widening -loop-guard-widening -insert-gcov-profiling -loop-simplify -gvn -guard-widening -jump-threading -globalopt -coro-elide -early-cse-memssa -infer-address-spaces -loop-simplifycfg -float2int -sccp -dse -lower-guard-intrinsic -loop-deletion -lower-guard-intrinsic -lcssa -loop-vectorize -strip -ipsccp -die -prune-eh -dse -inject-tli-mappings -inferattrs -mergeicmps -alignment-from-assumptions -strip-debug-declare -strip-dead-prototypes -simple-loop-unswitch -coro-split -gvn -lowerinvoke -sink -inject-tli-mappings -loop-data-prefetch -break-crit-edges -libcalls-shrinkwrap -strip -speculative-execution -adce -loweratomic -hotcoldsplit -reassociate -redundant-dbg-inst-elim -strip -guard-widening -strip-debug-declare -inferattrs -newgvn -sancov -loop-distribute -adce -licm -add-discriminators -insert-gcov-profiling -ee-instrument -instcombine -attributor -loop-unswitch -loop-deletion -canonicalize-aliases -coro-cleanup -deadargelim -strip-nondebug -add-discriminators -libcalls-shrinkwrap -div-rem-pairs -lower-constant-intrinsics -barrier -sancov -instnamer -simplifycfg -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/qsort,1.1207430340557276,61.6931471824646,opt -loop-load-elim -irce -loop-sink -loop-idiom -loop-deletion -early-cse-memssa -pgo-memop-opt -partially-inline-libcalls -break-crit-edges -mldst-motion -rpo-functionattrs -elim-avail-extern -canonicalize-aliases -libcalls-shrinkwrap -irce -loweratomic -constmerge -strip -loop-load-elim -licm -callsite-splitting -inject-tli-mappings -globalsplit -loop-versioning-licm -loop-reroll -float2int -loop-unswitch -separate-const-offset-from-gep -slp-vectorizer -sccp -aggressive-instcombine -gvn -loop-guard-widening -flattencfg -prune-eh -loop-unroll-and-jam -float2int -loop-fusion -instcombine -adce -load-store-vectorizer -die -pgo-memop-opt -ipsccp -rewrite-statepoints-for-gc -loop-simplifycfg -simplifycfg -reassociate -strip -globalsplit -coro-early -gvn input.bc -o output.bc +benchmark://cbench-v1/qsort,1.1207430340557276,61.77819585800171,opt -loop-reduce -break-crit-edges -hotcoldsplit -loop-interchange -post-inline-ee-instrument -reassociate -loop-fusion -coro-elide -irce -loop-idiom -libcalls-shrinkwrap -gvn-hoist -called-value-propagation -loop-data-prefetch -coro-cleanup -lowerinvoke -name-anon-globals -load-store-vectorizer -canonicalize-aliases -constprop -forceattrs -slsr -rewrite-statepoints-for-gc -functionattrs -name-anon-globals -sroa -sancov -licm -strip-debug-declare -consthoist -ee-instrument -lower-expect -loop-deletion -gvn -instcombine -rewrite-statepoints-for-gc -pgo-memop-opt -newgvn -loop-fusion -lowerinvoke -lower-constant-intrinsics -instcombine -callsite-splitting -newgvn -float2int -loop-sink -canonicalize-aliases -div-rem-pairs -float2int -instcombine -rpo-functionattrs -forceattrs -mergefunc -separate-const-offset-from-gep -guard-widening -lower-guard-intrinsic -div-rem-pairs -scalarizer -die -ipconstprop -prune-eh -irce -mem2reg -coro-cleanup -simplifycfg -inject-tli-mappings -correlated-propagation input.bc -o output.bc +benchmark://cbench-v1/qsort,1.1207430340557276,61.80295729637146,opt -mergefunc -separate-const-offset-from-gep -loop-unroll -called-value-propagation -loop-reroll -elim-avail-extern -sroa -name-anon-globals -loop-predication -add-discriminators -name-anon-globals -speculative-execution -loop-reroll -elim-avail-extern -inject-tli-mappings -globalopt -loop-unswitch -sancov -mergefunc -coro-cleanup -div-rem-pairs -loop-simplify -newgvn -barrier -instcombine -lcssa -early-cse-memssa -lower-matrix-intrinsics -break-crit-edges -loop-guard-widening -nary-reassociate -strip-dead-prototypes -slp-vectorizer -dse -loop-instsimplify -loweratomic -instnamer -functionattrs -globalopt -strip-nondebug -consthoist -slp-vectorizer -name-anon-globals -load-store-vectorizer -coro-split -slsr -sink -loop-interchange -float2int -argpromotion -simplifycfg -instsimplify -gvn input.bc -o output.bc +benchmark://cbench-v1/qsort,1.1207430340557276,64.49103260040283,opt -coro-early -coro-early -loop-deletion -ee-instrument -sink -argpromotion -lcssa -partially-inline-libcalls -sancov -div-rem-pairs -separate-const-offset-from-gep -load-store-vectorizer -aggressive-instcombine -simple-loop-unswitch -bdce -newgvn -instsimplify -early-cse-memssa -sink -inferattrs -bdce -rpo-functionattrs -ipconstprop -consthoist -mergereturn -scalarizer -redundant-dbg-inst-elim -loop-idiom -mem2reg -globalopt -lowerswitch -elim-avail-extern -loop-reroll -deadargelim -elim-avail-extern -lowerinvoke -scalarizer -barrier -instcombine -loop-unswitch -lower-expect -lowerinvoke -separate-const-offset-from-gep -guard-widening -barrier -gvn -deadargelim -pgo-memop-opt -guard-widening -reassociate -mergeicmps -instnamer -flattencfg -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/qsort,1.1207430340557278,61.58107852935791,opt -scalarizer -mergefunc -reassociate -loop-vectorize -loop-instsimplify -guard-widening -lower-constant-intrinsics -sancov -constprop -newgvn -guard-widening -mem2reg -instcombine -canonicalize-aliases -licm -alignment-from-assumptions -inject-tli-mappings -mergereturn -sancov -lcssa -sccp -loop-simplifycfg -sccp -ipsccp -constmerge -lower-constant-intrinsics -lower-constant-intrinsics -callsite-splitting -loop-versioning -die -break-crit-edges -coro-cleanup -strip -post-inline-ee-instrument -lower-constant-intrinsics -lower-widenable-condition -elim-avail-extern -strip-nondebug -newgvn -lower-matrix-intrinsics -dse -nary-reassociate -name-anon-globals -reassociate -gvn-hoist -globalsplit -insert-gcov-profiling -strip-debug-declare -die -sccp -newgvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/qsort,1.1238390092879258,61.713104486465454,opt -partially-inline-libcalls -consthoist -loop-versioning -instnamer -add-discriminators -name-anon-globals -lower-guard-intrinsic -mergereturn -newgvn -indvars -name-anon-globals -callsite-splitting -lowerinvoke -scalarizer -lowerswitch -constmerge -loop-sink -instcombine -consthoist -separate-const-offset-from-gep -loop-sink -inject-tli-mappings -loop-reduce -slsr -gvn -ipsccp -always-inline -sink -slsr -insert-gcov-profiling -post-inline-ee-instrument -sancov -loop-deletion -strip-nondebug -loop-interchange -indvars -sccp -globaldce -loop-predication -strip-dead-prototypes -dce -lower-constant-intrinsics -rpo-functionattrs -instcombine -lower-guard-intrinsic -nary-reassociate -memcpyopt -strip-dead-prototypes -simple-loop-unswitch -ee-instrument -sroa -mergeicmps -libcalls-shrinkwrap -lower-widenable-condition -strip-debug-declare -partially-inline-libcalls -gvn -div-rem-pairs -lower-constant-intrinsics -canonicalize-aliases -callsite-splitting -dce -die -dse -coro-cleanup -inject-tli-mappings -instsimplify -inject-tli-mappings -die -strip-debug-declare -coro-split -loop-unroll -nary-reassociate -sancov -guard-widening -correlated-propagation -strip-dead-prototypes -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/qsort,1.123839009287926,61.65643358230591,opt -instsimplify -globalopt -mergereturn -load-store-vectorizer -reg2mem -loop-simplify -ipsccp -slsr -load-store-vectorizer -loop-unswitch -indvars -loop-deletion -mergeicmps -memcpyopt -pgo-memop-opt -forceattrs -argpromotion -infer-address-spaces -flattencfg -loop-load-elim -simplifycfg -loop-vectorize -ipsccp -irce -load-store-vectorizer -div-rem-pairs -loop-unswitch -barrier -strip-debug-declare -slsr -licm -instnamer -loop-data-prefetch -sccp -deadargelim -lcssa -pgo-memop-opt -canonicalize-aliases -inferattrs -loop-reroll -speculative-execution -separate-const-offset-from-gep -globalopt -nary-reassociate -slsr -constprop -scalarizer -called-value-propagation -hotcoldsplit -loop-versioning -nary-reassociate -libcalls-shrinkwrap -lcssa -strip-nondebug -mldst-motion -coro-cleanup -gvn-hoist -mergefunc -strip-dead-prototypes -ee-instrument -mergefunc -strip-dead-prototypes -die -nary-reassociate -reassociate -loop-versioning -loop-vectorize -aggressive-instcombine -loop-unroll-and-jam -gvn -float2int -globaldce -globaldce -constmerge -consthoist -dse -sancov -add-discriminators -prune-eh -simplifycfg -loop-unroll -forceattrs -newgvn -canonicalize-aliases -loop-vectorize -float2int -mergereturn -loop-deletion -partial-inliner -bdce -instsimplify -loop-data-prefetch -reassociate -dse -post-inline-ee-instrument -scalarizer -called-value-propagation -strip -loop-instsimplify -aggressive-instcombine -nary-reassociate -loop-predication -loop-load-elim -lower-guard-intrinsic -name-anon-globals -lowerinvoke -strip -loop-simplify -loop-guard-widening -break-crit-edges -loop-unswitch -sancov -instsimplify -gvn-hoist -nary-reassociate -newgvn -newgvn -load-store-vectorizer -gvn-hoist -licm -ee-instrument -flattencfg -loop-predication -globalsplit -newgvn -canonicalize-aliases -instnamer -instcombine -coro-early -bdce -irce -loop-versioning -simplifycfg -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.0969720199310078,63.5710289478302,opt -partially-inline-libcalls -simplifycfg -reassociate -called-value-propagation -loop-fusion -libcalls-shrinkwrap -loop-sink -ee-instrument -canonicalize-aliases -loop-distribute -gvn -mem2reg -sancov -float2int -loop-load-elim -slp-vectorizer -dse -licm -jump-threading -loop-fusion -instcombine -div-rem-pairs -rpo-functionattrs -slsr -gvn-hoist -constmerge -loweratomic -loop-versioning-licm -memcpyopt -nary-reassociate -constprop -infer-address-spaces -lower-guard-intrinsic -rpo-functionattrs -prune-eh -strip -bdce -mldst-motion -strip-debug-declare -rpo-functionattrs -loop-reroll -functionattrs -slp-vectorizer -loop-instsimplify -div-rem-pairs -mem2reg -mergereturn -ipconstprop -loop-distribute -callsite-splitting -newgvn -coro-split -ee-instrument -alignment-from-assumptions -mergeicmps -loop-simplify -instsimplify -mem2reg -sroa -loop-data-prefetch -tailcallelim -loop-interchange -gvn-hoist -called-value-propagation -float2int -jump-threading -loop-sink -loop-idiom -inject-tli-mappings -loop-guard-widening -instnamer -inferattrs -ee-instrument -newgvn input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.0981218857799924,62.43927502632141,opt -sroa -loop-vectorize -die -simplifycfg -slp-vectorizer -argpromotion -loop-unroll-and-jam -gvn-hoist -pgo-memop-opt -forceattrs -reassociate -called-value-propagation -instcombine -loop-load-elim -coro-elide -gvn-hoist -insert-gcov-profiling -reassociate -irce -ipconstprop -libcalls-shrinkwrap -loop-data-prefetch -instcombine -deadargelim -partially-inline-libcalls -canonicalize-aliases -speculative-execution -bdce -lower-expect -loop-interchange -coro-cleanup -newgvn input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.100038328861633,62.28735589981079,opt -strip-debug-declare -loweratomic -alignment-from-assumptions -ipsccp -loop-guard-widening -flattencfg -redundant-dbg-inst-elim -lower-expect -instnamer -prune-eh -early-cse-memssa -inject-tli-mappings -gvn -constprop -ee-instrument -inferattrs -loop-sink -prune-eh -loop-reduce -mergeicmps -dse -canonicalize-aliases -irce -mergeicmps -argpromotion -lower-widenable-condition -loop-reduce -inferattrs -jump-threading -tailcallelim -strip-debug-declare -always-inline -sccp -sancov -mergereturn -always-inline -inject-tli-mappings -loop-unroll-and-jam -mergeicmps -dce -consthoist -rewrite-statepoints-for-gc -loop-reduce -instcombine -die -loop-simplifycfg -pgo-memop-opt -coro-split -rewrite-statepoints-for-gc -break-crit-edges -argpromotion -canonicalize-aliases -reassociate -called-value-propagation -partial-inliner -rewrite-statepoints-for-gc -gvn -jump-threading -prune-eh -forceattrs -loop-fusion -sancov -newgvn -sroa -tailcallelim -libcalls-shrinkwrap -rewrite-statepoints-for-gc -argpromotion -instcombine -sancov -canonicalize-aliases -argpromotion -coro-elide -slsr -loop-guard-widening -coro-cleanup -dse -inject-tli-mappings -coro-early -libcalls-shrinkwrap -newgvn -loweratomic -inferattrs -strip-nondebug -coro-cleanup -lower-matrix-intrinsics -die -loop-fusion -jump-threading -loop-instsimplify -simplifycfg -lower-widenable-condition -sink -sancov -cross-dso-cfi -gvn input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1008049060942893,64.57522320747375,opt -mem2reg -loop-simplifycfg -die -strip-dead-prototypes -ee-instrument -name-anon-globals -reassociate -gvn-hoist -globalopt -loop-simplify -loweratomic -loweratomic -loop-reroll -inferattrs -coro-elide -separate-const-offset-from-gep -lcssa -newgvn -loop-sink -ipconstprop -early-cse-memssa -loop-fusion -hotcoldsplit -cross-dso-cfi -scalarizer -loop-distribute -globalopt -sink -newgvn -name-anon-globals -called-value-propagation -cross-dso-cfi -die -canonicalize-aliases -lower-guard-intrinsic -prune-eh -loop-fusion -libcalls-shrinkwrap -lcssa -slp-vectorizer -nary-reassociate -loop-versioning -infer-address-spaces -constmerge -loweratomic -partial-inliner -sroa -mldst-motion -coro-elide -constmerge -flattencfg -constmerge -lowerinvoke -attributor -bdce -lower-widenable-condition -argpromotion -ipsccp -globaldce -licm -loweratomic -div-rem-pairs -globalopt -speculative-execution -inferattrs -lcssa -deadargelim -lowerinvoke -partially-inline-libcalls -loop-simplify -separate-const-offset-from-gep -slp-vectorizer -strip-debug-declare -newgvn -sccp -break-crit-edges -forceattrs -irce -simplifycfg -lower-guard-intrinsic -instcombine -loop-versioning -mergereturn -bdce -lower-constant-intrinsics -guard-widening -bdce -flattencfg -lower-matrix-intrinsics -coro-elide -loop-fusion -lower-guard-intrinsic -ipconstprop -mergereturn -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1011881947106172,62.217052936553955,opt -correlated-propagation -forceattrs -lcssa -guard-widening -memcpyopt -instcombine -reassociate -loop-predication -hotcoldsplit -nary-reassociate -slsr -libcalls-shrinkwrap -infer-address-spaces -constmerge -aggressive-instcombine -flattencfg -sink -infer-address-spaces -lower-expect -constmerge -break-crit-edges -mergereturn -loop-simplifycfg -partially-inline-libcalls -instcombine -loop-guard-widening -sancov -forceattrs -loop-reroll -lcssa -strip -constmerge -instsimplify -loop-load-elim -coro-early -guard-widening -loweratomic -loop-vectorize -rpo-functionattrs -gvn -cross-dso-cfi -loop-fusion -ee-instrument -indvars -break-crit-edges -consthoist -argpromotion -loop-guard-widening -functionattrs -ipsccp -die -gvn-hoist -loop-guard-widening -coro-elide -sccp -constprop -sroa -slsr -consthoist -loop-data-prefetch -correlated-propagation -loop-versioning-licm -infer-address-spaces -loop-vectorize -nary-reassociate -loop-idiom -mem2reg -inject-tli-mappings -speculative-execution -break-crit-edges -loweratomic -loop-unswitch -coro-early -mem2reg -dce -partial-inliner -pgo-memop-opt -loop-guard-widening -gvn-hoist -pgo-memop-opt -mem2reg -strip-dead-prototypes -loweratomic -constprop -ee-instrument -mem2reg -always-inline -callsite-splitting -flattencfg -loop-deletion -globalopt -memcpyopt -instnamer -loweratomic -loweratomic -constmerge -lower-expect -nary-reassociate -attributor -globalopt -simplifycfg -globalopt -pgo-memop-opt -slsr -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1015714833269452,62.28260684013367,opt -globalsplit -speculative-execution -ee-instrument -cross-dso-cfi -lowerinvoke -dse -loop-unroll-and-jam -aggressive-instcombine -ee-instrument -strip-nondebug -elim-avail-extern -sink -loop-reroll -loweratomic -loop-distribute -instsimplify -irce -loop-deletion -add-discriminators -loop-interchange -loop-idiom -break-crit-edges -irce -sccp -sancov -loop-instsimplify -break-crit-edges -called-value-propagation -functionattrs -gvn-hoist -loop-unroll-and-jam -elim-avail-extern -ee-instrument -div-rem-pairs -coro-split -simple-loop-unswitch -loop-unswitch -ipconstprop -forceattrs -partially-inline-libcalls -sroa -instcombine -float2int -early-cse-memssa -simplifycfg -post-inline-ee-instrument -loweratomic -globalopt -lowerinvoke -lower-guard-intrinsic -slsr -gvn -loweratomic -newgvn -libcalls-shrinkwrap -inject-tli-mappings -callsite-splitting -aggressive-instcombine -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1023380605596014,61.92038822174072,opt -strip -loop-fusion -correlated-propagation -lower-matrix-intrinsics -consthoist -mldst-motion -inject-tli-mappings -nary-reassociate -partial-inliner -loop-load-elim -loop-simplify -strip-dead-prototypes -ipconstprop -loop-data-prefetch -functionattrs -reassociate -constmerge -indvars -lower-guard-intrinsic -loop-unswitch -indvars -coro-elide -sroa -add-discriminators -flattencfg -indvars -bdce -libcalls-shrinkwrap -elim-avail-extern -memcpyopt -loop-unroll -mergereturn -strip-debug-declare -always-inline -loop-simplify -loop-reroll -loop-simplifycfg -adce -constmerge -loop-versioning -coro-split -loop-simplify -bdce -jump-threading -libcalls-shrinkwrap -loop-simplifycfg -argpromotion -functionattrs -loop-interchange -called-value-propagation -instcombine -reg2mem -pgo-memop-opt -lower-constant-intrinsics -ipsccp -called-value-propagation -scalarizer -slp-vectorizer -instsimplify -mldst-motion -coro-elide -jump-threading -newgvn -ipsccp -infer-address-spaces -mergefunc -globaldce -insert-gcov-profiling -name-anon-globals -nary-reassociate -lower-matrix-intrinsics -mem2reg -loop-load-elim -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1027213491759291,62.01464819908142,opt -slsr -nary-reassociate -indvars -loop-vectorize -coro-elide -loop-versioning -elim-avail-extern -irce -loop-versioning-licm -instnamer -prune-eh -bdce -loop-simplify -sroa -early-cse-memssa -inferattrs -infer-address-spaces -constmerge -mem2reg -strip-nondebug -deadargelim -constmerge -instcombine -instsimplify -loop-instsimplify -coro-cleanup -functionattrs -globalsplit -simplifycfg -dse -mergereturn -redundant-dbg-inst-elim -slsr -forceattrs -loop-simplify -jump-threading -globalsplit -simplifycfg -called-value-propagation -adce -reassociate -lowerinvoke -gvn input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1038712150249135,62.3216187953949,opt -slsr -lower-expect -globalsplit -die -irce -slp-vectorizer -elim-avail-extern -partial-inliner -simplifycfg -sroa -forceattrs -lower-widenable-condition -sancov -cross-dso-cfi -consthoist -mergeicmps -ee-instrument -loop-simplifycfg -mem2reg -loop-load-elim -globalopt -mergereturn -strip-dead-prototypes -callsite-splitting -sink -attributor -gvn -loop-sink -loop-guard-widening -correlated-propagation -separate-const-offset-from-gep -simple-loop-unswitch -loop-distribute -lower-expect -rewrite-statepoints-for-gc -redundant-dbg-inst-elim -loop-distribute -rewrite-statepoints-for-gc -loop-predication -break-crit-edges -strip-debug-declare -nary-reassociate -lowerinvoke -loop-guard-widening -jump-threading -correlated-propagation -sroa -post-inline-ee-instrument -rewrite-statepoints-for-gc -forceattrs -dse -loop-fusion -die -prune-eh -cross-dso-cfi -newgvn -separate-const-offset-from-gep -infer-address-spaces -alignment-from-assumptions -loop-sink -guard-widening -called-value-propagation -gvn-hoist -globalopt -simplifycfg -div-rem-pairs -instcombine -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/rijndael,1.1046377922575703,62.29489493370056,opt -adce -pgo-memop-opt -speculative-execution -loop-unroll-and-jam -coro-cleanup -loop-sink -dce -newgvn -simple-loop-unswitch -irce -inferattrs -argpromotion -always-inline -simplifycfg -globaldce -simplifycfg -lower-widenable-condition -globalsplit -deadargelim -loop-guard-widening -deadargelim -flattencfg -functionattrs -constmerge -loop-distribute -lower-widenable-condition -coro-cleanup -simple-loop-unswitch -sroa -loop-vectorize -mergereturn -gvn-hoist -infer-address-spaces -loop-deletion -ee-instrument -pgo-memop-opt -prune-eh -rpo-functionattrs -loop-data-prefetch -loop-guard-widening -instsimplify -lower-matrix-intrinsics -instsimplify -dce -pgo-memop-opt -inferattrs -strip-dead-prototypes -alignment-from-assumptions -gvn -loop-deletion -simplifycfg -globalopt -reg2mem -insert-gcov-profiling -loop-simplify -indvars -newgvn -loop-distribute -simple-loop-unswitch -ipsccp -inline -loop-vectorize -constmerge -loop-deletion -loop-unroll -gvn-hoist -callsite-splitting -cross-dso-cfi -flattencfg -mergefunc -loop-data-prefetch -name-anon-globals -jump-threading -mldst-motion -coro-cleanup -consthoist -strip-nondebug -bdce -loop-interchange -loop-idiom -tailcallelim -gvn -reg2mem -sccp -dse -correlated-propagation -insert-gcov-profiling -alignment-from-assumptions -newgvn -insert-gcov-profiling -deadargelim -div-rem-pairs -tailcallelim -loop-idiom -lower-widenable-condition -jump-threading -partially-inline-libcalls -mergeicmps -newgvn -coro-elide -inline -rpo-functionattrs -lowerinvoke -early-cse-memssa -loop-sink -tailcallelim -globalopt -adce -coro-split -ipconstprop -dse -loop-instsimplify -canonicalize-aliases -instcombine -bdce -loop-unswitch -jump-threading -loop-distribute -coro-cleanup -prune-eh -attributor -reassociate -globaldce -loop-predication -callsite-splitting -prune-eh -indvars -instsimplify -loop-predication -early-cse-memssa -gvn -loop-versioning -instcombine -loop-load-elim -loop-fusion -loop-rotate -loop-reroll -lower-constant-intrinsics -newgvn -loop-reroll -loop-guard-widening -argpromotion -loop-distribute -forceattrs -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/sha,1.4816053511705685,61.649839878082275,opt -loop-guard-widening -tailcallelim -partially-inline-libcalls -loop-simplifycfg -attributor -dse -reg2mem -loop-load-elim -ipconstprop -reg2mem -strip-nondebug -load-store-vectorizer -lower-constant-intrinsics -infer-address-spaces -instsimplify -prune-eh -early-cse-memssa -slsr -post-inline-ee-instrument -newgvn -loop-idiom -simplifycfg -globalopt -loop-data-prefetch -rewrite-statepoints-for-gc -elim-avail-extern -slp-vectorizer -argpromotion -speculative-execution -instcombine -div-rem-pairs -prune-eh -sink -alignment-from-assumptions -float2int -loop-instsimplify -adce -tailcallelim -loop-interchange -functionattrs -bdce -sroa -loop-versioning-licm -jump-threading -loop-versioning-licm -mldst-motion -strip-debug-declare -loop-load-elim -lowerswitch -mergeicmps -strip-nondebug -loop-load-elim -indvars -mergeicmps -nary-reassociate -coro-early -speculative-execution -sancov -sccp -lowerinvoke -alignment-from-assumptions -lower-expect -sccp -loop-interchange -globalopt -prune-eh -slsr -strip-nondebug -slsr -loop-data-prefetch -nary-reassociate -mergeicmps -cross-dso-cfi -loop-unroll-and-jam -loop-reroll -flattencfg -strip-dead-prototypes -elim-avail-extern -mem2reg -sccp -separate-const-offset-from-gep -slp-vectorizer -callsite-splitting -barrier -globalsplit -div-rem-pairs -cross-dso-cfi -name-anon-globals -loop-predication -reassociate -dse -newgvn -rpo-functionattrs -div-rem-pairs -separate-const-offset-from-gep -mem2reg -loop-unroll-and-jam -libcalls-shrinkwrap -hotcoldsplit -functionattrs -infer-address-spaces -reassociate -mldst-motion -loop-data-prefetch -strip-debug-declare -lcssa -correlated-propagation -separate-const-offset-from-gep -coro-early -licm -rewrite-statepoints-for-gc -gvn -strip-debug-declare -mergereturn -lower-guard-intrinsic -guard-widening -reassociate -insert-gcov-profiling -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/sha,1.4983277591973243,61.73563838005066,opt -lowerswitch -tailcallelim -slp-vectorizer -newgvn -globalsplit -always-inline -argpromotion -called-value-propagation -constprop -correlated-propagation -add-discriminators -sancov -lower-matrix-intrinsics -loweratomic -mergefunc -loop-reduce -die -guard-widening -loop-unroll-and-jam -slsr -indvars -partially-inline-libcalls -strip-dead-prototypes -instnamer -sroa -lower-widenable-condition -strip-debug-declare -partial-inliner -lower-expect -tailcallelim -float2int -redundant-dbg-inst-elim -alignment-from-assumptions -loop-distribute -instcombine -correlated-propagation -loop-unroll-and-jam -loop-fusion -correlated-propagation -coro-early -scalarizer -elim-avail-extern -ipconstprop -loop-data-prefetch -scalarizer -newgvn -mergeicmps -loop-versioning-licm -canonicalize-aliases -coro-elide -slp-vectorizer -float2int -loweratomic -separate-const-offset-from-gep -redundant-dbg-inst-elim -called-value-propagation -libcalls-shrinkwrap -loop-guard-widening -argpromotion -indvars -elim-avail-extern -reassociate -prune-eh -libcalls-shrinkwrap -ipconstprop -mergeicmps -globaldce -coro-cleanup -break-crit-edges -slsr -mem2reg -gvn-hoist -loop-deletion -dce -post-inline-ee-instrument -loop-simplify -simplifycfg -mergereturn -strip -functionattrs -inferattrs -instcombine -libcalls-shrinkwrap -div-rem-pairs -loweratomic -always-inline -called-value-propagation -loop-data-prefetch -argpromotion -functionattrs -instsimplify -flattencfg -loop-data-prefetch -strip-debug-declare -licm -strip -attributor -gvn -cross-dso-cfi -functionattrs -inferattrs -insert-gcov-profiling -flattencfg -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/sha,1.501672240802675,61.79606604576111,opt -redundant-dbg-inst-elim -mergefunc -nary-reassociate -adce -licm -loop-data-prefetch -constprop -die -lowerswitch -scalarizer -lcssa -sancov -adce -ipconstprop -inject-tli-mappings -loop-interchange -pgo-memop-opt -break-crit-edges -deadargelim -ipconstprop -post-inline-ee-instrument -loop-sink -sancov -sroa -instcombine -early-cse-memssa -loop-deletion -loop-versioning-licm -slsr -ee-instrument -reg2mem -mergeicmps -loop-deletion -lower-constant-intrinsics -div-rem-pairs -coro-early -indvars -forceattrs -early-cse-memssa -gvn -early-cse-memssa -loop-sink -loop-instsimplify -mem2reg -coro-split -name-anon-globals -loop-interchange -irce -indvars -libcalls-shrinkwrap -load-store-vectorizer -simplifycfg -redundant-dbg-inst-elim -gvn -nary-reassociate -simplifycfg -sroa -argpromotion -post-inline-ee-instrument -bdce -ee-instrument -lower-expect -loop-interchange -speculative-execution -loop-distribute -lower-guard-intrinsic -lowerswitch -sancov -inject-tli-mappings -mldst-motion -inferattrs -loop-simplify -mergeicmps -globaldce -licm -simplifycfg -strip-nondebug -mergereturn -strip-dead-prototypes -scalarizer -adce -rewrite-statepoints-for-gc -float2int -deadargelim -globaldce -coro-early -called-value-propagation -coro-early -gvn-hoist -mergefunc -memcpyopt -mergefunc -flattencfg -loop-interchange -jump-threading -reassociate -alignment-from-assumptions -globalopt -constmerge -gvn -instcombine input.bc -o output.bc +benchmark://cbench-v1/sha,1.5050167224080266,61.69275736808777,opt -lower-matrix-intrinsics -barrier -slsr -partially-inline-libcalls -instsimplify -loop-unroll-and-jam -speculative-execution -loop-unroll -loop-distribute -functionattrs -hotcoldsplit -forceattrs -mem2reg -partial-inliner -sroa -functionattrs -loop-idiom -scalarizer -attributor -add-discriminators -add-discriminators -newgvn -loop-sink -add-discriminators -coro-early -callsite-splitting -strip -indvars -libcalls-shrinkwrap -loop-deletion -add-discriminators -pgo-memop-opt -constprop -loop-unroll-and-jam -rpo-functionattrs -add-discriminators -globalsplit -dse -mldst-motion -instcombine -loop-idiom -globalsplit -globaldce -memcpyopt -loop-versioning -correlated-propagation -flattencfg -adce -gvn-hoist -adce -nary-reassociate -instnamer -simplifycfg -lowerinvoke -speculative-execution -gvn -tailcallelim -sancov -inferattrs -deadargelim -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/sha,1.5083612040133778,61.7785108089447,opt -lower-widenable-condition -break-crit-edges -early-cse-memssa -loop-predication -ipsccp -float2int -indvars -post-inline-ee-instrument -ipconstprop -instnamer -loop-predication -loop-idiom -libcalls-shrinkwrap -strip-dead-prototypes -die -lower-guard-intrinsic -mldst-motion -loop-interchange -flattencfg -reassociate -loop-data-prefetch -flattencfg -gvn -functionattrs -dce -lower-widenable-condition -float2int -name-anon-globals -simplifycfg -speculative-execution -mldst-motion -libcalls-shrinkwrap -strip-nondebug -forceattrs -strip-debug-declare -post-inline-ee-instrument -prune-eh -sancov -loop-unroll-and-jam -sccp -loop-versioning-licm -coro-early -lower-widenable-condition -speculative-execution -mem2reg -globalopt -strip -coro-split -loop-idiom -loop-simplify -callsite-splitting -instcombine -dse -adce -sink -nary-reassociate -gvn -sroa -mergereturn -coro-early -rpo-functionattrs -newgvn -add-discriminators -called-value-propagation -loop-load-elim -loop-data-prefetch -loop-deletion -barrier -loop-vectorize -callsite-splitting -indvars -deadargelim -guard-widening -die -early-cse-memssa -inferattrs -gvn -instnamer -canonicalize-aliases -argpromotion -loweratomic -inject-tli-mappings -mem2reg -loop-simplifycfg -loop-reroll -adce -ipconstprop -lowerswitch -alignment-from-assumptions -always-inline -scalarizer -guard-widening -loop-versioning-licm -inject-tli-mappings -globaldce -div-rem-pairs -insert-gcov-profiling -strip-nondebug -slp-vectorizer -loop-simplify -attributor -indvars -ipconstprop -elim-avail-extern -bdce -instsimplify -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/sha,1.5117056856187288,61.70262050628662,opt -loop-reduce -flattencfg -loop-versioning -loweratomic -sroa -strip-debug-declare -alignment-from-assumptions -insert-gcov-profiling -forceattrs -coro-elide -redundant-dbg-inst-elim -early-cse-memssa -lower-constant-intrinsics -load-store-vectorizer -gvn -loop-reroll -post-inline-ee-instrument -loop-guard-widening -speculative-execution -sroa -tailcallelim -scalarizer -dce -pgo-memop-opt -loop-distribute -mldst-motion -post-inline-ee-instrument -instnamer -speculative-execution -float2int -mergereturn -called-value-propagation -div-rem-pairs -cross-dso-cfi -cross-dso-cfi -lower-expect -redundant-dbg-inst-elim -loop-versioning-licm -speculative-execution -ipconstprop -callsite-splitting -sccp -loop-simplifycfg -simple-loop-unswitch -scalarizer -mem2reg -lower-constant-intrinsics -loop-simplify -licm -prune-eh -partially-inline-libcalls -partially-inline-libcalls -loop-data-prefetch -lcssa -dce -memcpyopt -loop-sink -redundant-dbg-inst-elim -prune-eh -strip-dead-prototypes -pgo-memop-opt -load-store-vectorizer -gvn -instcombine -loweratomic -adce -speculative-execution -loop-unroll-and-jam -mldst-motion -loop-reroll -mergereturn -post-inline-ee-instrument -strip-nondebug -forceattrs -coro-early -rewrite-statepoints-for-gc -partial-inliner -loop-distribute -strip-debug-declare -strip -mergefunc -functionattrs -infer-address-spaces -lowerswitch -tailcallelim -sccp -sink -newgvn -indvars -loop-unroll-and-jam -loop-simplify -loop-simplify -callsite-splitting -deadargelim -simplifycfg -argpromotion -coro-split -newgvn input.bc -o output.bc +benchmark://cbench-v1/sha,1.511705685618729,61.58654522895813,opt -early-cse-memssa -inferattrs -coro-elide -sccp -load-store-vectorizer -lower-guard-intrinsic -coro-elide -loop-simplifycfg -load-store-vectorizer -nary-reassociate -die -libcalls-shrinkwrap -mergeicmps -loop-versioning-licm -tailcallelim -strip -name-anon-globals -redundant-dbg-inst-elim -mldst-motion -called-value-propagation -alignment-from-assumptions -strip-debug-declare -ipconstprop -bdce -mergeicmps -elim-avail-extern -always-inline -gvn -licm -post-inline-ee-instrument -ee-instrument -cross-dso-cfi -loop-simplify -loop-reroll -jump-threading -ee-instrument -lowerinvoke -float2int -loop-versioning -hotcoldsplit -instcombine -loop-data-prefetch -reassociate -simple-loop-unswitch -coro-split -loop-simplifycfg -gvn-hoist -sancov -load-store-vectorizer -lower-expect -lowerswitch -load-store-vectorizer -loop-rotate -barrier -simple-loop-unswitch -newgvn -called-value-propagation -load-store-vectorizer -loop-predication -memcpyopt -mergeicmps -float2int -div-rem-pairs -instsimplify -loop-instsimplify -speculative-execution -coro-cleanup -inferattrs -callsite-splitting -cross-dso-cfi -correlated-propagation -consthoist -mergeicmps -loop-vectorize -constmerge -mem2reg -instsimplify -ee-instrument -coro-early -loop-data-prefetch -argpromotion -irce -indvars -scalarizer -callsite-splitting -loop-guard-widening -instcombine -sancov -loop-unroll-and-jam -loop-deletion -loop-idiom -lower-matrix-intrinsics -loop-sink -simple-loop-unswitch -sccp -memcpyopt -cross-dso-cfi -mldst-motion -gvn -slsr -inject-tli-mappings -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/sha,1.5150501672240804,62.05151176452637,opt -elim-avail-extern -early-cse-memssa -jump-threading -tailcallelim -gvn-hoist -lower-widenable-condition -partially-inline-libcalls -lower-expect -speculative-execution -loop-guard-widening -insert-gcov-profiling -globalsplit -loop-distribute -lcssa -pgo-memop-opt -reassociate -pgo-memop-opt -loop-deletion -functionattrs -instsimplify -mldst-motion -scalarizer -canonicalize-aliases -speculative-execution -loop-idiom -add-discriminators -inferattrs -barrier -globaldce -consthoist -loop-reduce -mem2reg -partially-inline-libcalls -globalsplit -partial-inliner -jump-threading -functionattrs -sancov -globaldce -float2int -div-rem-pairs -simplifycfg -speculative-execution -lower-expect -coro-split -newgvn -rpo-functionattrs -indvars -rewrite-statepoints-for-gc -simplifycfg -ipsccp -instsimplify -barrier -ipsccp -ipconstprop -ee-instrument -indvars -ee-instrument -coro-early -float2int -attributor -ipconstprop -licm -lower-expect -slsr -globaldce -rpo-functionattrs -correlated-propagation -ipsccp -mldst-motion -infer-address-spaces -load-store-vectorizer -newgvn -sccp -indvars -newgvn -simple-loop-unswitch -simplifycfg -gvn -always-inline -partially-inline-libcalls -nary-reassociate -insert-gcov-profiling -coro-early -mergeicmps -irce -instcombine -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/sha,1.5183946488294315,61.559239864349365,opt -ipconstprop -reg2mem -ipconstprop -prune-eh -pgo-memop-opt -rewrite-statepoints-for-gc -rpo-functionattrs -always-inline -constprop -globaldce -libcalls-shrinkwrap -loop-unroll -loop-reroll -consthoist -coro-split -lower-constant-intrinsics -functionattrs -pgo-memop-opt -coro-elide -slsr -inject-tli-mappings -memcpyopt -loop-vectorize -barrier -libcalls-shrinkwrap -adce -div-rem-pairs -ipsccp -memcpyopt -gvn-hoist -partially-inline-libcalls -prune-eh -lowerinvoke -always-inline -loop-reroll -lowerswitch -coro-split -break-crit-edges -nary-reassociate -partially-inline-libcalls -gvn-hoist -attributor -instnamer -rpo-functionattrs -gvn -loop-fusion -bdce -sink -add-discriminators -simplifycfg -infer-address-spaces -lcssa -strip-dead-prototypes -loop-versioning -simplifycfg -partially-inline-libcalls -loop-deletion -simple-loop-unswitch -loop-distribute -licm -loop-vectorize -aggressive-instcombine -globalsplit -lower-guard-intrinsic -constmerge -constmerge -always-inline -loop-simplify -insert-gcov-profiling -indvars -elim-avail-extern -mergeicmps -loop-interchange -mem2reg -loop-reroll -load-store-vectorizer -alignment-from-assumptions -bdce -partial-inliner -loop-distribute -gvn-hoist -memcpyopt -mergefunc -coro-split -coro-split -mldst-motion -loop-idiom -loop-deletion -rpo-functionattrs -attributor -attributor -slsr -slp-vectorizer -loop-distribute -irce -lower-guard-intrinsic -gvn -loop-versioning-licm -loop-interchange -die -add-discriminators -deadargelim -instcombine -irce -lowerinvoke -separate-const-offset-from-gep -partially-inline-libcalls -jump-threading -consthoist -constprop -libcalls-shrinkwrap -aggressive-instcombine -flattencfg -constmerge -slsr -partial-inliner -sroa -correlated-propagation -deadargelim -correlated-propagation -indvars -mergefunc -indvars -load-store-vectorizer -loop-interchange -loop-interchange -jump-threading -inject-tli-mappings -attributor -forceattrs -loop-predication -loweratomic -sroa -loop-predication -correlated-propagation -loop-distribute -simple-loop-unswitch -loop-predication -loop-interchange -slp-vectorizer -loop-predication -jump-threading -loop-simplify -sink -loop-sink -sroa -coro-early -loop-distribute -insert-gcov-profiling -post-inline-ee-instrument -memcpyopt -coro-cleanup -name-anon-globals -loop-sink -sancov -slsr -lower-matrix-intrinsics -licm -simplifycfg -dse -early-cse-memssa -attributor -strip-debug-declare -nary-reassociate -div-rem-pairs -prune-eh -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/sha,1.5250836120401334,61.66695785522461,opt -partial-inliner -coro-elide -sancov -irce -nary-reassociate -alignment-from-assumptions -mergereturn -insert-gcov-profiling -ipconstprop -instsimplify -correlated-propagation -barrier -attributor -loop-deletion -load-store-vectorizer -dce -licm -globaldce -loop-vectorize -div-rem-pairs -strip-debug-declare -load-store-vectorizer -always-inline -inferattrs -mergeicmps -sink -loop-unroll-and-jam -flattencfg -sccp -load-store-vectorizer -loop-rotate -deadargelim -lcssa -attributor -indvars -globalopt -scalarizer -coro-cleanup -prune-eh -post-inline-ee-instrument -gvn -loop-idiom -loop-load-elim -attributor -simplifycfg -strip -constmerge -indvars -sroa -dce -instcombine -separate-const-offset-from-gep -mergefunc -loop-simplify -barrier -tailcallelim -lower-expect -globalopt -libcalls-shrinkwrap -lower-widenable-condition -jump-threading -deadargelim -pgo-memop-opt -rewrite-statepoints-for-gc -callsite-splitting -mergefunc -globalsplit -mergeicmps -gvn -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/stringsearch,0.9959016393442623,61.68849325180054,opt -nary-reassociate -lower-matrix-intrinsics -cross-dso-cfi -lower-expect -canonicalize-aliases -load-store-vectorizer -forceattrs -loop-idiom -barrier -slp-vectorizer -loop-versioning-licm -insert-gcov-profiling -dse -strip-nondebug -early-cse-memssa -instnamer -globaldce -hotcoldsplit -mergeicmps -lowerinvoke -sink -coro-early -lower-constant-intrinsics -ipconstprop -pgo-memop-opt -scalarizer -sancov -loop-fusion -barrier -pgo-memop-opt -coro-split -reg2mem -globalopt -lower-expect -infer-address-spaces -constprop -loop-sink -slp-vectorizer -gvn -nary-reassociate -speculative-execution -loop-interchange -lowerinvoke -libcalls-shrinkwrap -float2int -add-discriminators -sink -elim-avail-extern -reassociate -memcpyopt -loop-sink -elim-avail-extern -redundant-dbg-inst-elim -lowerswitch -mergefunc -add-discriminators -loop-fusion -simple-loop-unswitch -lower-matrix-intrinsics -globaldce -add-discriminators -load-store-vectorizer -infer-address-spaces -callsite-splitting -loop-simplifycfg -instnamer -adce -sroa -attributor -adce -name-anon-globals -globaldce -redundant-dbg-inst-elim -forceattrs -loop-simplify -elim-avail-extern -loop-distribute -aggressive-instcombine -lowerswitch -die -strip-dead-prototypes -forceattrs -infer-address-spaces -rpo-functionattrs -loop-simplify -globalsplit -loop-load-elim -licm -lower-widenable-condition -ee-instrument -lower-constant-intrinsics -insert-gcov-profiling -float2int -globalopt -attributor -redundant-dbg-inst-elim -lower-guard-intrinsic -sccp -strip -aggressive-instcombine -strip-nondebug -ipconstprop -loop-fusion -coro-elide -strip-dead-prototypes -loop-reroll -mergeicmps -float2int -loop-data-prefetch -reassociate -hotcoldsplit -newgvn -instcombine -mldst-motion -redundant-dbg-inst-elim -jump-threading -gvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0013661202185793,61.93865656852722,opt -loop-fusion -coro-elide -coro-cleanup -guard-widening -simplifycfg -mergefunc -hotcoldsplit -inferattrs -guard-widening -guard-widening -globalopt -lower-matrix-intrinsics -loop-versioning-licm -lower-widenable-condition -loop-fusion -loop-instsimplify -irce -loop-vectorize -float2int -loop-reduce -partially-inline-libcalls -sccp -lower-expect -loop-distribute -lowerswitch -loop-predication -newgvn -early-cse-memssa -lowerswitch -libcalls-shrinkwrap -loop-deletion -loweratomic -attributor -coro-cleanup -loop-guard-widening -insert-gcov-profiling -lower-constant-intrinsics -sccp -loop-idiom -gvn-hoist -slsr -barrier -gvn -mem2reg -slsr -bdce -simple-loop-unswitch -newgvn -insert-gcov-profiling -globalopt -nary-reassociate -loop-idiom -gvn-hoist -partial-inliner -lcssa -die -aggressive-instcombine -canonicalize-aliases -loop-idiom -loop-idiom -libcalls-shrinkwrap -dse -globaldce -strip -coro-cleanup -adce -instcombine -loop-data-prefetch -instnamer -newgvn -deadargelim -loop-distribute -coro-split -sancov -correlated-propagation -mergereturn -insert-gcov-profiling -mergefunc -reassociate -insert-gcov-profiling -coro-elide -post-inline-ee-instrument -callsite-splitting -libcalls-shrinkwrap -loop-predication -loop-data-prefetch -lower-matrix-intrinsics -lower-expect -instsimplify -lowerinvoke -pgo-memop-opt -ipsccp -hotcoldsplit -sroa -coro-elide -gvn -loop-unroll -globalopt -redundant-dbg-inst-elim -ipsccp -dse -loop-guard-widening -ipconstprop -loop-deletion -memcpyopt -loop-sink -loop-instsimplify -partial-inliner -die -insert-gcov-profiling -loop-sink -constmerge -mergefunc -partially-inline-libcalls -inferattrs -loweratomic -sroa -constprop -dse -libcalls-shrinkwrap -callsite-splitting -barrier -name-anon-globals -name-anon-globals -loop-predication -correlated-propagation -loop-unroll-and-jam -deadargelim -loop-idiom -loop-deletion -loop-idiom -post-inline-ee-instrument -speculative-execution -loop-sink -lowerinvoke -speculative-execution -consthoist -die -canonicalize-aliases -canonicalize-aliases -memcpyopt -scalarizer -elim-avail-extern -tailcallelim -callsite-splitting -irce -speculative-execution -post-inline-ee-instrument -barrier -loop-interchange -pgo-memop-opt -lcssa -reg2mem -functionattrs -name-anon-globals -loop-reduce -loop-fusion -indvars -loop-unroll-and-jam -correlated-propagation -lower-constant-intrinsics -float2int -loop-interchange -functionattrs -ipsccp -loop-distribute -mergefunc -mergereturn -reg2mem -irce -strip-debug-declare -irce -reg2mem -loop-versioning-licm -functionattrs -slp-vectorizer -scalarizer -sancov -barrier -coro-cleanup -loop-unroll-and-jam -pgo-memop-opt -mem2reg -instnamer -newgvn -lcssa -cross-dso-cfi -globalsplit -loop-simplify -hotcoldsplit -called-value-propagation -sroa -jump-threading -mem2reg -mergeicmps -called-value-propagation -ipsccp -loop-unroll-and-jam -simplifycfg -loop-versioning -instcombine input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0013661202185793,62.70221829414368,opt -loop-fusion -loop-simplifycfg -loop-reduce -loop-load-elim -loop-unswitch -partially-inline-libcalls -coro-split -insert-gcov-profiling -ipsccp -always-inline -post-inline-ee-instrument -coro-elide -loop-fusion -functionattrs -gvn -prune-eh -instsimplify -die -slp-vectorizer -inferattrs -coro-split -globaldce -callsite-splitting -sccp -loop-interchange -inject-tli-mappings -loop-versioning-licm -tailcallelim -partially-inline-libcalls -insert-gcov-profiling -nary-reassociate -jump-threading -float2int -tailcallelim -sroa -loop-versioning -loop-sink -called-value-propagation -loop-unroll -sccp -barrier -loop-instsimplify -coro-elide -constmerge -strip-nondebug -nary-reassociate -coro-early -cross-dso-cfi -attributor -mergeicmps -deadargelim -speculative-execution -constmerge -alignment-from-assumptions -ipsccp -div-rem-pairs -redundant-dbg-inst-elim -speculative-execution -prune-eh -newgvn -mldst-motion -sroa -lower-widenable-condition -attributor -simplifycfg -memcpyopt -indvars -lowerswitch -newgvn -name-anon-globals -strip-debug-declare -inject-tli-mappings -prune-eh -name-anon-globals -instcombine -coro-cleanup -functionattrs -globalsplit -functionattrs -aggressive-instcombine -sancov -bdce -rewrite-statepoints-for-gc -cross-dso-cfi -indvars -ipconstprop -nary-reassociate -separate-const-offset-from-gep -callsite-splitting -canonicalize-aliases -licm -sccp -redundant-dbg-inst-elim -loop-guard-widening -loop-reroll -consthoist -float2int -gvn-hoist -loop-data-prefetch -globaldce -elim-avail-extern -loop-sink -strip-dead-prototypes -argpromotion -correlated-propagation -indvars -lower-widenable-condition -rpo-functionattrs -loop-unswitch -lower-constant-intrinsics -lower-expect -jump-threading -globaldce -globaldce -simplifycfg -lower-constant-intrinsics -infer-address-spaces -early-cse-memssa -jump-threading -elim-avail-extern -rpo-functionattrs -dse -correlated-propagation -memcpyopt -strip -alignment-from-assumptions -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0027322404371586,61.595093727111816,opt -canonicalize-aliases -gvn-hoist -float2int -coro-early -reg2mem -ipconstprop -loop-versioning -strip-debug-declare -strip-nondebug -constprop -speculative-execution -redundant-dbg-inst-elim -licm -simplifycfg -constmerge -inferattrs -lower-widenable-condition -globalopt -loop-vectorize -deadargelim -sancov -loop-distribute -post-inline-ee-instrument -partially-inline-libcalls -lower-constant-intrinsics -dce -dse -slp-vectorizer -die -ipconstprop -loop-vectorize -slp-vectorizer -prune-eh -strip -post-inline-ee-instrument -pgo-memop-opt -partial-inliner -deadargelim -gvn -forceattrs -load-store-vectorizer -globalsplit -separate-const-offset-from-gep -loop-interchange -pgo-memop-opt -lowerswitch -reassociate -rewrite-statepoints-for-gc -mergefunc -lcssa -inferattrs -infer-address-spaces -float2int -mldst-motion -libcalls-shrinkwrap -simplifycfg -ipconstprop -deadargelim -functionattrs -loop-simplify -lower-matrix-intrinsics -strip -mergereturn -elim-avail-extern -functionattrs -rpo-functionattrs -inject-tli-mappings -loop-simplify -loop-deletion -instcombine -lowerswitch -post-inline-ee-instrument -sroa -speculative-execution -infer-address-spaces -dce -lower-widenable-condition -jump-threading -loop-load-elim -sink -partial-inliner -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.005464480874317,61.7589898109436,opt -lower-constant-intrinsics -loop-predication -rewrite-statepoints-for-gc -loop-idiom -rpo-functionattrs -hotcoldsplit -infer-address-spaces -coro-cleanup -coro-elide -jump-threading -instsimplify -loop-reroll -coro-split -sink -coro-elide -lcssa -libcalls-shrinkwrap -correlated-propagation -infer-address-spaces -sroa -newgvn -elim-avail-extern -guard-widening -always-inline -simplifycfg -ipsccp -mergeicmps -instcombine input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0054644808743174,61.90070199966431,opt -always-inline -float2int -loop-interchange -globalsplit -constmerge -nary-reassociate -flattencfg -loop-interchange -slsr -newgvn -lower-guard-intrinsic -loweratomic -lcssa -guard-widening -prune-eh -loop-interchange -float2int -flattencfg -libcalls-shrinkwrap -loop-idiom -loop-distribute -sccp -simple-loop-unswitch -mergereturn -functionattrs -slsr -always-inline -canonicalize-aliases -redundant-dbg-inst-elim -barrier -lower-widenable-condition -coro-elide -coro-split -loop-versioning -partially-inline-libcalls -dce -attributor -canonicalize-aliases -canonicalize-aliases -canonicalize-aliases -aggressive-instcombine -infer-address-spaces -mem2reg -deadargelim -libcalls-shrinkwrap -globalsplit -lower-widenable-condition -lower-matrix-intrinsics -lcssa -guard-widening -argpromotion -coro-split -strip -dse -loop-simplifycfg -rpo-functionattrs -slsr -loop-deletion -break-crit-edges -loop-reroll -coro-cleanup -simplifycfg -strip-debug-declare -scalarizer -lowerswitch -loop-load-elim -add-discriminators -partial-inliner -coro-split -globalsplit -loop-vectorize -lower-matrix-intrinsics -lower-widenable-condition -sancov -reassociate -coro-cleanup -alignment-from-assumptions -elim-avail-extern -strip-dead-prototypes -early-cse-memssa -reassociate -reg2mem -called-value-propagation -flattencfg -loop-unswitch -coro-cleanup -constprop -canonicalize-aliases -loop-reduce -irce -elim-avail-extern -sink -argpromotion -loop-data-prefetch -inject-tli-mappings -loop-data-prefetch -redundant-dbg-inst-elim -load-store-vectorizer -lower-constant-intrinsics -simplifycfg -inline -globaldce -sccp -elim-avail-extern -strip-dead-prototypes -functionattrs -coro-split -lower-expect -cross-dso-cfi -mergeicmps -globaldce -rpo-functionattrs -dse -loop-fusion -loop-reroll -constprop -lowerswitch -correlated-propagation -speculative-execution -inferattrs -deadargelim -simplifycfg -dce -post-inline-ee-instrument -globalopt -gvn -reassociate -loop-versioning -constmerge -coro-split -always-inline -gvn -loop-sink -newgvn -loop-idiom -guard-widening -reg2mem -indvars -aggressive-instcombine -strip -deadargelim -irce -loop-unroll-and-jam -reg2mem -sroa -loop-guard-widening -loop-sink -strip -break-crit-edges -instsimplify -slsr -break-crit-edges -inferattrs -always-inline -simple-loop-unswitch -instcombine -called-value-propagation -mergeicmps -slp-vectorizer -strip-debug-declare -lower-matrix-intrinsics -break-crit-edges -loop-sink -always-inline -lcssa -loop-versioning-licm -guard-widening -consthoist -loop-load-elim -argpromotion -mergefunc -reassociate -sink -simple-loop-unswitch -aggressive-instcombine -lcssa -reg2mem -strip-nondebug -lower-widenable-condition -mergereturn -simplifycfg -load-store-vectorizer -forceattrs -constprop -instsimplify -loop-reduce -ee-instrument -loop-simplify -globalsplit -mergereturn -adce -sroa -lower-matrix-intrinsics -ee-instrument -bdce -nary-reassociate -coro-early -rpo-functionattrs -called-value-propagation -cross-dso-cfi -jump-threading -name-anon-globals -rewrite-statepoints-for-gc -loop-reroll -pgo-memop-opt -alignment-from-assumptions -bdce -memcpyopt -forceattrs -deadargelim -sccp -argpromotion -speculative-execution -strip-nondebug -die -infer-address-spaces -sccp -mergefunc -strip-nondebug -sancov -sccp -always-inline -scalarizer -forceattrs -insert-gcov-profiling -mldst-motion -barrier -loop-versioning -lcssa -infer-address-spaces -coro-split -consthoist -loop-deletion -libcalls-shrinkwrap -loop-vectorize -reassociate -loop-simplify -simplifycfg -called-value-propagation -mergeicmps -lower-widenable-condition -rpo-functionattrs -memcpyopt -newgvn -insert-gcov-profiling -newgvn -insert-gcov-profiling -always-inline -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0068306010928962,61.69719099998474,opt -loop-reroll -sancov -pgo-memop-opt -coro-early -loop-unroll-and-jam -strip-nondebug -instsimplify -loop-simplify -strip -break-crit-edges -die -globalsplit -lower-widenable-condition -add-discriminators -mergefunc -reassociate -lower-expect -div-rem-pairs -licm -argpromotion -gvn -post-inline-ee-instrument -gvn-hoist -scalarizer -loop-interchange -sink -rpo-functionattrs -reg2mem -inject-tli-mappings -ee-instrument -float2int -reg2mem -inferattrs -newgvn -div-rem-pairs -tailcallelim -coro-cleanup -instsimplify -deadargelim -name-anon-globals -pgo-memop-opt -partial-inliner -globalsplit -loop-versioning-licm -sancov -loop-simplify -indvars -slsr -correlated-propagation -libcalls-shrinkwrap -break-crit-edges -dse -nary-reassociate -slp-vectorizer -instnamer -float2int -infer-address-spaces -guard-widening -float2int -inline -lowerinvoke -sccp -loop-simplify -loop-distribute -alignment-from-assumptions -loop-simplifycfg -jump-threading -sink -scalarizer -die -inline -loop-unroll-and-jam -elim-avail-extern -gvn -die -mldst-motion -infer-address-spaces -consthoist -lower-expect -loop-instsimplify -barrier -simplifycfg -strip-dead-prototypes -name-anon-globals -called-value-propagation -sancov -barrier -tailcallelim -tailcallelim -loop-data-prefetch -loop-vectorize -name-anon-globals -lower-expect -reassociate -lcssa -loweratomic -globaldce -gvn-hoist -libcalls-shrinkwrap -nary-reassociate -adce -dse -adce -loop-versioning-licm -dse -libcalls-shrinkwrap -canonicalize-aliases -sroa -ipsccp -mergefunc -constmerge -inferattrs -name-anon-globals -mldst-motion -pgo-memop-opt -loop-versioning -die -add-discriminators -strip-nondebug -licm -libcalls-shrinkwrap -loop-unswitch -simplifycfg -constprop -cross-dso-cfi -forceattrs -sancov -coro-early -newgvn -nary-reassociate -instcombine -mem2reg -loop-predication -cross-dso-cfi -mem2reg -loop-data-prefetch -dse -loop-vectorize -irce -strip -cross-dso-cfi -loop-versioning-licm -loweratomic -loop-simplifycfg -partial-inliner -loop-instsimplify -loop-deletion -partially-inline-libcalls -loop-unroll -loop-predication -attributor -sink -correlated-propagation -lower-constant-intrinsics -reassociate -lower-expect -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0068306010928965,61.84607648849487,opt -constmerge -memcpyopt -libcalls-shrinkwrap -consthoist -lower-constant-intrinsics -mem2reg -loop-data-prefetch -rewrite-statepoints-for-gc -called-value-propagation -separate-const-offset-from-gep -forceattrs -gvn -loop-simplify -rpo-functionattrs -constmerge -irce -dce -loop-load-elim -coro-early -constmerge -lower-matrix-intrinsics -slp-vectorizer -slp-vectorizer -add-discriminators -gvn -scalarizer -jump-threading -die -cross-dso-cfi -strip -loop-vectorize -inferattrs -adce -loweratomic -rewrite-statepoints-for-gc -lowerswitch -post-inline-ee-instrument -float2int -argpromotion -coro-split -ipconstprop -slp-vectorizer -lowerswitch -alignment-from-assumptions -add-discriminators -consthoist -mergeicmps -argpromotion -sink -loop-load-elim -loop-versioning-licm -mem2reg -inferattrs -indvars -instcombine -coro-early -ee-instrument -instcombine -alignment-from-assumptions -loop-instsimplify -consthoist -canonicalize-aliases -coro-split -load-store-vectorizer -aggressive-instcombine -gvn -slsr -loop-reroll -lower-constant-intrinsics -instnamer -sroa -infer-address-spaces -elim-avail-extern -correlated-propagation -scalarizer -lowerinvoke -inject-tli-mappings -constmerge -strip-debug-declare -loop-unswitch -elim-avail-extern -scalarizer -functionattrs -partial-inliner -early-cse-memssa -div-rem-pairs -inferattrs -mem2reg -mergefunc -separate-const-offset-from-gep -inferattrs -globalsplit -consthoist -mergeicmps -loop-sink -lower-guard-intrinsic -nary-reassociate -rewrite-statepoints-for-gc -partial-inliner -post-inline-ee-instrument -load-store-vectorizer -mldst-motion -deadargelim -barrier -dce -simplifycfg -loop-unroll -simple-loop-unswitch -break-crit-edges -loop-sink -globalsplit -loop-deletion -strip -deadargelim -loop-sink -loop-unswitch -loop-idiom -strip-nondebug -gvn-hoist -nary-reassociate -loop-vectorize -infer-address-spaces -early-cse-memssa -dse -always-inline -coro-split -globalsplit -loop-distribute -callsite-splitting -mldst-motion -loop-simplifycfg -speculative-execution -early-cse-memssa -die -instcombine -canonicalize-aliases -coro-early -die -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.0081967213114753,61.87919545173645,opt -called-value-propagation -jump-threading -break-crit-edges -globaldce -break-crit-edges -adce -gvn-hoist -name-anon-globals -mldst-motion -coro-split -attributor -correlated-propagation -jump-threading -simple-loop-unswitch -loop-unswitch -mergefunc -loop-unroll -pgo-memop-opt -partial-inliner -tailcallelim -add-discriminators -strip-nondebug -prune-eh -strip -load-store-vectorizer -strip -loop-deletion -callsite-splitting -slp-vectorizer -licm -lower-matrix-intrinsics -aggressive-instcombine -lower-widenable-condition -lowerinvoke -sroa -attributor -instnamer -attributor -loweratomic -load-store-vectorizer -insert-gcov-profiling -globaldce -sroa -simplifycfg -loop-interchange -simple-loop-unswitch -jump-threading -guard-widening -nary-reassociate -memcpyopt -gvn -ipconstprop -functionattrs -loop-load-elim -licm -irce -pgo-memop-opt -infer-address-spaces -elim-avail-extern -sccp -elim-avail-extern -correlated-propagation -coro-split -rpo-functionattrs -prune-eh -constprop -break-crit-edges -correlated-propagation -coro-cleanup -redundant-dbg-inst-elim -globalsplit -barrier -called-value-propagation -constmerge -hotcoldsplit -simplifycfg -scalarizer -insert-gcov-profiling -globalopt -loop-simplify -float2int -redundant-dbg-inst-elim -dce -slp-vectorizer -jump-threading -post-inline-ee-instrument -sancov -guard-widening -tailcallelim -coro-split -gvn -loop-versioning-licm -strip -licm -mem2reg -loop-unroll -dce -partial-inliner -reassociate -slsr -memcpyopt -instcombine -guard-widening -die -loop-predication -loweratomic -infer-address-spaces -libcalls-shrinkwrap -loop-unroll -redundant-dbg-inst-elim -instcombine -strip-dead-prototypes -instnamer -lower-constant-intrinsics -globaldce -sroa -callsite-splitting -licm -lower-expect -globalsplit -loop-predication -libcalls-shrinkwrap -globaldce -flattencfg -name-anon-globals -inferattrs -loweratomic -lower-matrix-intrinsics -mergefunc -elim-avail-extern -strip-nondebug -sink -loop-unswitch -simplifycfg -die -newgvn input.bc -o output.bc +benchmark://cbench-v1/stringsearch,1.012295081967213,61.989551305770874,opt -slsr -alignment-from-assumptions -ipsccp -canonicalize-aliases -slp-vectorizer -gvn-hoist -rewrite-statepoints-for-gc -lower-expect -constmerge -canonicalize-aliases -ee-instrument -nary-reassociate -licm -flattencfg -loop-unroll-and-jam -load-store-vectorizer -newgvn -loop-reroll -loop-distribute -licm -gvn -lcssa -globalopt -instnamer -mergereturn -loop-simplify -loop-interchange -globaldce -irce -flattencfg -mldst-motion -bdce -instcombine -jump-threading -loop-unswitch -callsite-splitting -licm -load-store-vectorizer -slsr -lower-constant-intrinsics -correlated-propagation -callsite-splitting -instnamer -infer-address-spaces -dse -loop-unswitch -dse -mergereturn -strip -loweratomic -instsimplify -loop-deletion -functionattrs -gvn-hoist -lower-expect -barrier -consthoist -inject-tli-mappings -prune-eh -lcssa -dse -strip-debug-declare -loop-reroll -called-value-propagation -deadargelim -mergereturn -loop-simplify -loop-unswitch -strip-dead-prototypes -coro-elide -attributor -tailcallelim -partially-inline-libcalls -loop-distribute -dce -licm -loop-versioning -inferattrs -loop-predication -loop-deletion -post-inline-ee-instrument -slp-vectorizer -coro-early -add-discriminators -name-anon-globals -strip -adce -consthoist -ipconstprop -loop-predication -lower-matrix-intrinsics -loop-sink -bdce -loop-reroll -simplifycfg -loop-versioning-licm -barrier -irce -dce -loop-load-elim -newgvn -always-inline -always-inline -callsite-splitting -loop-unroll -callsite-splitting -loweratomic -ee-instrument -lower-widenable-condition -break-crit-edges -instnamer -deadargelim -lowerswitch -ipconstprop -mem2reg -loop-load-elim -callsite-splitting -pgo-memop-opt -instcombine -lower-constant-intrinsics -strip -gvn -add-discriminators -loop-versioning -canonicalize-aliases -strip-nondebug -barrier -loop-fusion -inferattrs -mem2reg -lower-matrix-intrinsics -functionattrs -irce -correlated-propagation -deadargelim -sroa -strip-dead-prototypes -loop-predication -flattencfg -cross-dso-cfi -constmerge -strip-debug-declare -dce -reg2mem -lower-matrix-intrinsics -loop-predication -loop-predication -lower-constant-intrinsics -instnamer -attributor -dce -ipconstprop -instnamer -alignment-from-assumptions -strip-dead-prototypes -loop-simplifycfg -elim-avail-extern -argpromotion -early-cse-memssa -dse -loop-instsimplify -reg2mem -lowerswitch -partial-inliner -insert-gcov-profiling -loop-simplify -post-inline-ee-instrument -partial-inliner -float2int -loop-fusion -prune-eh -lcssa -float2int -div-rem-pairs -strip-debug-declare -loop-sink -loop-reduce -strip -alignment-from-assumptions -loop-simplify -canonicalize-aliases -reg2mem -gvn -insert-gcov-profiling -barrier -newgvn -mem2reg -strip-dead-prototypes -loop-simplify -loop-data-prefetch -loop-versioning-licm -simplifycfg -slsr -instcombine input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9850746268656715,61.64527368545532,opt -memcpyopt -sroa -elim-avail-extern -lower-widenable-condition -div-rem-pairs -div-rem-pairs -loop-load-elim -cross-dso-cfi -gvn -loop-versioning -insert-gcov-profiling -early-cse-memssa -instcombine -redundant-dbg-inst-elim -inferattrs -nary-reassociate -coro-cleanup -inferattrs -partial-inliner -loop-fusion -consthoist -adce -name-anon-globals -loop-versioning -aggressive-instcombine -correlated-propagation -loweratomic -early-cse-memssa -loop-unroll -jump-threading -sroa -name-anon-globals -speculative-execution -barrier -constprop -loop-data-prefetch -lower-expect -load-store-vectorizer -coro-split -lower-widenable-condition -early-cse-memssa -speculative-execution -elim-avail-extern -loop-guard-widening -loop-sink -coro-early -globalsplit -forceattrs -slsr -coro-elide -pgo-memop-opt -canonicalize-aliases -deadargelim -instcombine -deadargelim -sancov -guard-widening -elim-avail-extern -always-inline -libcalls-shrinkwrap -coro-cleanup -load-store-vectorizer -redundant-dbg-inst-elim -speculative-execution -prune-eh -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9850746268656717,62.151060581207275,opt -loop-simplifycfg -mem2reg -loop-interchange -tailcallelim -coro-cleanup -sroa -sink -insert-gcov-profiling -adce -die -loop-vectorize -rpo-functionattrs -post-inline-ee-instrument -slsr -loop-versioning -mergeicmps -load-store-vectorizer -loop-sink -loop-unroll -barrier -loweratomic -insert-gcov-profiling -mergereturn -div-rem-pairs -slp-vectorizer -mergefunc -strip-dead-prototypes -loop-sink -bdce -redundant-dbg-inst-elim -flattencfg -mergereturn -infer-address-spaces -flattencfg -newgvn -attributor -instcombine -bdce -mergereturn -loop-load-elim -redundant-dbg-inst-elim -add-discriminators -cross-dso-cfi -strip-debug-declare -inferattrs -mergereturn -loop-simplify -lower-widenable-condition -coro-early -barrier -loop-instsimplify -jump-threading -div-rem-pairs -loop-unroll-and-jam -loop-vectorize -loop-data-prefetch -scalarizer -functionattrs -loop-interchange -inject-tli-mappings -loop-sink -dce -newgvn -constprop -post-inline-ee-instrument -elim-avail-extern -coro-cleanup -correlated-propagation -mem2reg -guard-widening -lower-widenable-condition -globaldce -loop-distribute -instcombine -die -loop-load-elim -slsr -libcalls-shrinkwrap -mergefunc -ee-instrument -prune-eh -ee-instrument -coro-split -rewrite-statepoints-for-gc -tailcallelim -rpo-functionattrs -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9888059701492538,61.676395654678345,opt -loop-vectorize -slp-vectorizer -ee-instrument -float2int -called-value-propagation -loop-reroll -coro-elide -canonicalize-aliases -prune-eh -alignment-from-assumptions -inferattrs -indvars -indvars -globalsplit -partially-inline-libcalls -loop-unroll-and-jam -adce -indvars -inject-tli-mappings -name-anon-globals -globaldce -constprop -mldst-motion -sroa -loop-vectorize -rewrite-statepoints-for-gc -gvn -loop-sink -prune-eh -always-inline -mergereturn -mldst-motion -cross-dso-cfi -ipsccp -coro-elide -sink -separate-const-offset-from-gep -mergefunc -cross-dso-cfi -infer-address-spaces -always-inline -forceattrs -aggressive-instcombine -strip-debug-declare -partially-inline-libcalls -lower-matrix-intrinsics -instsimplify -break-crit-edges -lcssa -early-cse-memssa -loop-unroll -infer-address-spaces -strip-nondebug -jump-threading -alignment-from-assumptions -loop-vectorize -gvn -partially-inline-libcalls -constmerge -flattencfg -globaldce -mergeicmps -constmerge -loop-unroll-and-jam -partially-inline-libcalls -partial-inliner -inject-tli-mappings -globaldce -simplifycfg -mergereturn -inject-tli-mappings -speculative-execution -loop-distribute -rpo-functionattrs -indvars -lowerswitch -coro-elide -callsite-splitting -load-store-vectorizer -aggressive-instcombine -loop-predication -argpromotion -loop-guard-widening -insert-gcov-profiling -argpromotion -argpromotion -dse -partially-inline-libcalls -newgvn -lcssa -mldst-motion -lower-guard-intrinsic -simplifycfg -hotcoldsplit -load-store-vectorizer -dse -consthoist -dce -instcombine input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9888059701492538,64.41505336761475,opt -barrier -nary-reassociate -strip-debug-declare -strip-nondebug -loop-reduce -constmerge -deadargelim -ipsccp -float2int -instsimplify -coro-cleanup -break-crit-edges -speculative-execution -loop-deletion -loop-versioning -coro-split -coro-cleanup -globalsplit -callsite-splitting -strip-dead-prototypes -loop-guard-widening -prune-eh -loop-distribute -sroa -newgvn -always-inline -coro-elide -newgvn -correlated-propagation -dce -scalarizer -partially-inline-libcalls -loop-data-prefetch -strip-debug-declare -called-value-propagation -loop-deletion -loop-guard-widening -sink -lower-widenable-condition -constprop -barrier -reg2mem -instsimplify -reg2mem -loop-interchange -simple-loop-unswitch -ipconstprop -loop-sink -early-cse-memssa -rpo-functionattrs -lower-constant-intrinsics -sink -prune-eh -mergefunc -name-anon-globals -coro-early -loop-deletion -sink -loop-guard-widening -loop-versioning -strip -loop-unswitch -instnamer -lowerinvoke -guard-widening -nary-reassociate -ee-instrument -ipsccp -elim-avail-extern -correlated-propagation -canonicalize-aliases -strip-dead-prototypes -lower-guard-intrinsic -separate-const-offset-from-gep -loop-idiom -lower-constant-intrinsics -dce -globaldce -loop-instsimplify -prune-eh -forceattrs -scalarizer -strip-nondebug -rewrite-statepoints-for-gc -loop-interchange -lower-constant-intrinsics -lower-guard-intrinsic -sancov -partially-inline-libcalls -insert-gcov-profiling -constprop -libcalls-shrinkwrap -loop-guard-widening -inferattrs -loop-unroll-and-jam -memcpyopt -sroa -slp-vectorizer -coro-elide -strip-nondebug -strip-dead-prototypes -loop-versioning -deadargelim -globalopt -lcssa -slp-vectorizer -ee-instrument -loop-unswitch -loop-unroll-and-jam -loop-idiom -sroa -coro-elide -dce -load-store-vectorizer -lower-widenable-condition -redundant-dbg-inst-elim -redundant-dbg-inst-elim -canonicalize-aliases -redundant-dbg-inst-elim -early-cse-memssa -indvars -post-inline-ee-instrument -lower-constant-intrinsics -rpo-functionattrs -loop-predication -sancov -ee-instrument -callsite-splitting -loop-reroll -strip -partial-inliner -irce -strip-debug-declare -mem2reg -instcombine -loop-guard-widening -inferattrs -callsite-splitting -memcpyopt -early-cse-memssa -reassociate -strip-nondebug -functionattrs -reassociate -nary-reassociate -bdce -licm -partially-inline-libcalls -ipconstprop -globaldce -strip -coro-elide -simplifycfg -guard-widening -correlated-propagation input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9888059701492539,61.77658653259277,opt -always-inline -ipconstprop -libcalls-shrinkwrap -newgvn -inferattrs -elim-avail-extern -mem2reg -bdce -reassociate -gvn -strip -attributor -loop-guard-widening -guard-widening -reassociate -loop-idiom -forceattrs -die -aggressive-instcombine -memcpyopt -consthoist -mldst-motion -loop-vectorize -strip -rewrite-statepoints-for-gc -loop-idiom -name-anon-globals -strip -infer-address-spaces -instnamer -argpromotion -strip-nondebug -strip -lower-widenable-condition -ipsccp -callsite-splitting -slsr -memcpyopt -coro-elide -mergeicmps -aggressive-instcombine -indvars -always-inline -strip-debug-declare -functionattrs -insert-gcov-profiling -mem2reg -constmerge -mldst-motion -separate-const-offset-from-gep -memcpyopt -gvn -insert-gcov-profiling -elim-avail-extern -bdce -loop-distribute -sroa -coro-split -div-rem-pairs -slp-vectorizer -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.988805970149254,61.721890687942505,opt -mldst-motion -canonicalize-aliases -irce -infer-address-spaces -functionattrs -scalarizer -attributor -mldst-motion -licm -barrier -coro-split -rpo-functionattrs -nary-reassociate -separate-const-offset-from-gep -coro-elide -consthoist -loop-fusion -coro-elide -sroa -constmerge -inferattrs -instsimplify -coro-early -prune-eh -sink -sccp -instsimplify -lower-matrix-intrinsics -newgvn -coro-early -loop-guard-widening -sccp -barrier -mergereturn -loop-vectorize -tailcallelim -sancov -add-discriminators -loop-predication -coro-elide -instcombine -separate-const-offset-from-gep -indvars -libcalls-shrinkwrap -bdce -name-anon-globals -loop-deletion -lower-guard-intrinsic -tailcallelim -loop-guard-widening -cross-dso-cfi -strip-dead-prototypes -partially-inline-libcalls -simplifycfg -loop-distribute -pgo-memop-opt -globalsplit -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9925373134328358,61.8615505695343,opt -lower-constant-intrinsics -functionattrs -loop-reduce -instnamer -forceattrs -loop-guard-widening -die -strip-nondebug -lowerswitch -constprop -redundant-dbg-inst-elim -sancov -loop-unswitch -callsite-splitting -constmerge -lower-matrix-intrinsics -loop-simplify -lower-expect -mergeicmps -instsimplify -bdce -loop-predication -dse -reg2mem -called-value-propagation -guard-widening -loop-vectorize -speculative-execution -ipconstprop -mergefunc -globalopt -constprop -bdce -ipconstprop -tailcallelim -attributor -nary-reassociate -libcalls-shrinkwrap -loop-versioning-licm -cross-dso-cfi -sroa -speculative-execution -jump-threading -partial-inliner -prune-eh -loop-simplify -functionattrs -sink -loop-vectorize -loop-unswitch -mldst-motion -loop-reroll -consthoist -attributor -barrier -sink -tailcallelim -ipsccp -redundant-dbg-inst-elim -called-value-propagation -deadargelim -loop-idiom -canonicalize-aliases -lowerinvoke -loop-unswitch -adce -loop-data-prefetch -loop-data-prefetch -float2int -alignment-from-assumptions -mergeicmps -globaldce -simple-loop-unswitch -called-value-propagation -constmerge -partial-inliner -sancov -loop-versioning -inferattrs -reassociate -rpo-functionattrs -loop-interchange -globaldce -ipconstprop -instcombine -lower-guard-intrinsic -rpo-functionattrs -ipconstprop -lower-expect -insert-gcov-profiling -strip-debug-declare -functionattrs -loweratomic -strip-dead-prototypes -loop-versioning -lower-constant-intrinsics -mergefunc -gvn-hoist -loop-simplifycfg -instcombine -lower-constant-intrinsics -correlated-propagation -lowerswitch -coro-early -mergeicmps -nary-reassociate -slp-vectorizer -load-store-vectorizer -load-store-vectorizer -early-cse-memssa -mergefunc -coro-cleanup -simple-loop-unswitch -flattencfg -bdce -flattencfg -gvn -separate-const-offset-from-gep -loweratomic -aggressive-instcombine -flattencfg -add-discriminators -mem2reg -strip-nondebug -lower-widenable-condition -loweratomic -instnamer -forceattrs -gvn-hoist -bdce -div-rem-pairs -simplifycfg -callsite-splitting -dse -lower-constant-intrinsics -load-store-vectorizer -coro-early -break-crit-edges -partial-inliner -lower-constant-intrinsics -consthoist -inject-tli-mappings -instcombine -div-rem-pairs -mem2reg -argpromotion -loop-predication -sccp -globaldce -elim-avail-extern -inject-tli-mappings -simplifycfg -globaldce -mergereturn -loweratomic -die -die -loweratomic -memcpyopt -scalarizer -sink -alignment-from-assumptions -irce -indvars -ipconstprop -aggressive-instcombine -jump-threading -aggressive-instcombine -globalsplit -mergefunc -globalsplit -gvn-hoist -loop-versioning-licm -guard-widening -coro-early -newgvn -sroa -constprop -inject-tli-mappings -alignment-from-assumptions -add-discriminators -instnamer -globalopt -speculative-execution -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.9962686567164178,61.62188148498535,opt -load-store-vectorizer -loop-interchange -loop-simplify -constmerge -loop-unroll-and-jam -ipsccp -sroa -dce -loop-sink -constprop -rpo-functionattrs -slp-vectorizer -loop-load-elim -die -barrier -slp-vectorizer -loop-sink -div-rem-pairs -gvn-hoist -dce -loop-distribute -loop-fusion -name-anon-globals -licm -rpo-functionattrs -scalarizer -sink -barrier -sroa -loop-sink -irce -correlated-propagation -strip-debug-declare -mergereturn -canonicalize-aliases -early-cse-memssa -sroa -inferattrs -loop-distribute -instcombine -deadargelim -early-cse-memssa -strip-dead-prototypes -strip-dead-prototypes -sink -irce -always-inline -early-cse-memssa -functionattrs -loop-idiom -slp-vectorizer -lower-guard-intrinsic -indvars -loop-sink -lcssa -dce -add-discriminators -sancov -lowerswitch -mldst-motion -deadargelim -jump-threading -gvn -ee-instrument -loop-deletion -coro-split -correlated-propagation -name-anon-globals -lower-expect -globalopt -attributor -loop-instsimplify -elim-avail-extern -coro-early -loop-interchange -loop-guard-widening -tailcallelim -simplifycfg -strip-nondebug -guard-widening -globalopt -barrier -lower-matrix-intrinsics -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.996268656716418,61.765552043914795,opt -cross-dso-cfi -loop-interchange -elim-avail-extern -insert-gcov-profiling -partially-inline-libcalls -mldst-motion -slp-vectorizer -loop-idiom -deadargelim -lower-constant-intrinsics -speculative-execution -sccp -coro-early -correlated-propagation -adce -loop-unroll-and-jam -nary-reassociate -insert-gcov-profiling -separate-const-offset-from-gep -newgvn -correlated-propagation -loop-simplifycfg -strip-nondebug -dse -attributor -gvn -functionattrs -called-value-propagation -newgvn -ee-instrument -instcombine -div-rem-pairs -pgo-memop-opt -partially-inline-libcalls -mergereturn -dce -newgvn -gvn-hoist -mergereturn -loop-simplify -insert-gcov-profiling -inferattrs -loop-deletion -strip-debug-declare -indvars -globalopt -simple-loop-unswitch -newgvn -loop-interchange -add-discriminators -irce -newgvn -nary-reassociate -ipsccp -canonicalize-aliases -mem2reg -correlated-propagation -break-crit-edges -partially-inline-libcalls -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/stringsearch2,0.996268656716418,61.78978753089905,opt -simplifycfg -newgvn -mem2reg -indvars -mergeicmps -inferattrs -aggressive-instcombine -rpo-functionattrs -constprop -loop-versioning -slp-vectorizer -inject-tli-mappings -loop-simplifycfg -insert-gcov-profiling -rpo-functionattrs -indvars -coro-elide -tailcallelim -attributor -coro-cleanup -instcombine -ipconstprop -div-rem-pairs -lower-expect -strip-dead-prototypes -insert-gcov-profiling -coro-early -rpo-functionattrs -argpromotion -loop-versioning-licm -constprop -reassociate -loop-simplifycfg -mergereturn -partial-inliner -partially-inline-libcalls -ipconstprop -float2int -instsimplify -partially-inline-libcalls -slp-vectorizer -redundant-dbg-inst-elim -mem2reg -gvn -sink -loweratomic -coro-split -loop-interchange -gvn -elim-avail-extern -gvn -dce -mergeicmps -rewrite-statepoints-for-gc -aggressive-instcombine -lower-matrix-intrinsics -scalarizer -memcpyopt -loop-unswitch -tailcallelim -loop-vectorize -inject-tli-mappings -libcalls-shrinkwrap -loop-deletion -inject-tli-mappings -instcombine -mldst-motion -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/susan,1.0008958280010236,63.07995295524597,opt -loop-sink -mem2reg -nary-reassociate -indvars -loop-load-elim -loop-simplify -insert-gcov-profiling -loop-simplifycfg -irce -loop-deletion -div-rem-pairs -loop-unroll-and-jam -add-discriminators -rewrite-statepoints-for-gc -simplifycfg -coro-early -lower-expect -loop-interchange -partial-inliner -gvn -loop-data-prefetch -functionattrs -simple-loop-unswitch -guard-widening -mergeicmps -gvn -dse -mldst-motion -lower-guard-intrinsic -loop-simplify -lower-constant-intrinsics -loop-fusion -newgvn -rpo-functionattrs -simplifycfg -inferattrs -partially-inline-libcalls -separate-const-offset-from-gep -loop-load-elim -separate-const-offset-from-gep -loop-guard-widening -loop-predication -instcombine -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/susan,1.0012797542871767,66.32646870613098,opt -instcombine -sroa -partial-inliner -licm -early-cse-memssa -lower-constant-intrinsics -load-store-vectorizer -loop-vectorize -loop-guard-widening -flattencfg -guard-widening -partial-inliner -dse -gvn-hoist -sink -lower-widenable-condition -strip-nondebug -loop-versioning -forceattrs -loop-idiom -loop-versioning-licm -licm -libcalls-shrinkwrap -memcpyopt -loop-simplify -sroa -die -irce -simplifycfg -simple-loop-unswitch -strip-dead-prototypes -instcombine -functionattrs -speculative-execution -mergefunc -jump-threading -consthoist -tailcallelim -alignment-from-assumptions -lcssa -sccp -lower-guard-intrinsic -mldst-motion -loop-unroll-and-jam -jump-threading -partial-inliner -pgo-memop-opt -slsr -simple-loop-unswitch -sroa -loop-simplify -mergereturn -sroa -loop-deletion -coro-cleanup -sancov -jump-threading -mem2reg -slsr -add-discriminators -early-cse-memssa -infer-address-spaces -loop-guard-widening -mergereturn -partially-inline-libcalls -mldst-motion -dce -flattencfg -sroa -newgvn -lower-constant-intrinsics -loop-sink -loop-vectorize -loweratomic -libcalls-shrinkwrap -jump-threading -guard-widening -nary-reassociate -constprop -instnamer -correlated-propagation -loop-versioning-licm -coro-early -simple-loop-unswitch -libcalls-shrinkwrap -loop-versioning-licm -licm -div-rem-pairs -coro-cleanup -coro-split -instsimplify -always-inline -mergefunc -globaldce -rpo-functionattrs -elim-avail-extern -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/susan,1.0051190171487074,63.4972939491272,opt -simplifycfg -ipconstprop -sroa -mem2reg -nary-reassociate -loop-data-prefetch -globalopt -loop-instsimplify -flattencfg -canonicalize-aliases -gvn -pgo-memop-opt -memcpyopt -inferattrs -flattencfg -redundant-dbg-inst-elim -coro-early -deadargelim -loop-unroll -rpo-functionattrs -mergeicmps -dce -post-inline-ee-instrument -strip-dead-prototypes -inject-tli-mappings -loop-instsimplify -lowerswitch -lcssa -alignment-from-assumptions -callsite-splitting -simplifycfg -memcpyopt -reassociate -jump-threading -sroa -strip-debug-declare -guard-widening -lower-guard-intrinsic -loop-idiom -coro-early -strip -sroa -globalopt -mergereturn -libcalls-shrinkwrap -nary-reassociate -separate-const-offset-from-gep -partial-inliner -attributor -slsr -slsr -newgvn -loop-reroll -licm -forceattrs -ipsccp -ipconstprop -loop-reroll -lowerinvoke -instcombine -post-inline-ee-instrument -newgvn -loop-load-elim -rewrite-statepoints-for-gc -redundant-dbg-inst-elim -barrier -strip-nondebug -rpo-functionattrs -loop-simplify -loop-data-prefetch -scalarizer -cross-dso-cfi -libcalls-shrinkwrap -memcpyopt -loop-deletion -nary-reassociate -mergefunc -loop-idiom -instnamer -correlated-propagation -loop-fusion -alignment-from-assumptions -correlated-propagation -cross-dso-cfi -strip-debug-declare -rpo-functionattrs -functionattrs -sancov -called-value-propagation -canonicalize-aliases -indvars -insert-gcov-profiling -separate-const-offset-from-gep -loop-data-prefetch -indvars -gvn-hoist -sancov -guard-widening -add-discriminators -insert-gcov-profiling -nary-reassociate -loop-unroll-and-jam -dce -correlated-propagation -loop-instsimplify -partially-inline-libcalls -mem2reg -loop-interchange -elim-avail-extern -slp-vectorizer -loop-reroll -argpromotion -elim-avail-extern -partial-inliner -instcombine -constmerge -instcombine -canonicalize-aliases -sccp -redundant-dbg-inst-elim -sink -guard-widening -simplifycfg -redundant-dbg-inst-elim -canonicalize-aliases -speculative-execution -alignment-from-assumptions -sroa -inferattrs -add-discriminators -partially-inline-libcalls -speculative-execution -gvn-hoist -div-rem-pairs -loop-versioning -mergefunc -slp-vectorizer -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/susan,1.0051190171487077,63.2826771736145,opt -sancov -libcalls-shrinkwrap -loweratomic -sroa -guard-widening -insert-gcov-profiling -loop-instsimplify -guard-widening -mergereturn -rewrite-statepoints-for-gc -redundant-dbg-inst-elim -nary-reassociate -always-inline -coro-split -cross-dso-cfi -functionattrs -gvn -loop-reroll -mergefunc -mergeicmps -instsimplify -memcpyopt -loop-interchange -loop-predication -alignment-from-assumptions -loop-vectorize -loop-simplify -mem2reg -libcalls-shrinkwrap -strip-debug-declare -mldst-motion -attributor -loop-sink -loop-fusion -called-value-propagation -mldst-motion -mergeicmps -strip-dead-prototypes -loop-deletion -coro-early -gvn -canonicalize-aliases -sink -barrier -inferattrs -loop-deletion -load-store-vectorizer -loop-deletion -nary-reassociate -reassociate -loop-versioning -ee-instrument -attributor -prune-eh -lower-widenable-condition -called-value-propagation -post-inline-ee-instrument -dce -lowerinvoke -slp-vectorizer -elim-avail-extern -load-store-vectorizer -strip -ee-instrument -canonicalize-aliases -strip-dead-prototypes -loop-load-elim -early-cse-memssa -sccp -argpromotion -infer-address-spaces -loop-data-prefetch -dce -loop-load-elim -constmerge -called-value-propagation -loop-vectorize -flattencfg -instnamer -loop-unroll -loweratomic -gvn-hoist -prune-eh -memcpyopt -mldst-motion -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/susan,1.005758894292296,310.464004278183,opt -tailcallelim -break-crit-edges -strip-dead-prototypes -die -loop-vectorize -slp-vectorizer -prune-eh -speculative-execution -newgvn -hotcoldsplit -called-value-propagation -lcssa -strip-dead-prototypes -tailcallelim -dce -redundant-dbg-inst-elim -sroa -jump-threading -loop-versioning-licm -loop-deletion -infer-address-spaces -elim-avail-extern -functionattrs -alignment-from-assumptions -infer-address-spaces -slp-vectorizer -mergefunc -sancov -scalarizer -separate-const-offset-from-gep -functionattrs -sancov -reassociate -loop-unroll -constprop -mergeicmps -globalopt -rewrite-statepoints-for-gc -float2int -barrier -partial-inliner -mldst-motion -deadargelim -memcpyopt -loop-guard-widening -mergefunc -irce -loop-versioning -deadargelim -inferattrs -loop-interchange -loop-simplify -loop-predication -lcssa -functionattrs -coro-elide -load-store-vectorizer -strip-debug-declare -always-inline -insert-gcov-profiling -newgvn -add-discriminators -consthoist -licm -consthoist -prune-eh -elim-avail-extern -indvars -prune-eh -reassociate -functionattrs -rewrite-statepoints-for-gc -simplifycfg -libcalls-shrinkwrap -lower-widenable-condition -newgvn -lower-guard-intrinsic -lower-constant-intrinsics -elim-avail-extern -flattencfg -irce -hotcoldsplit -strip -insert-gcov-profiling -sroa -reassociate -instcombine -sink -lower-matrix-intrinsics -insert-gcov-profiling -sccp -libcalls-shrinkwrap -licm -name-anon-globals -correlated-propagation -lower-matrix-intrinsics -loop-load-elim -coro-elide -adce -loweratomic -cross-dso-cfi -mem2reg -insert-gcov-profiling -lower-constant-intrinsics -strip-debug-declare -strip-nondebug -instnamer -lower-widenable-condition -lower-guard-intrinsic -mergefunc -canonicalize-aliases -dse -loop-simplifycfg -loop-unroll-and-jam -alignment-from-assumptions -libcalls-shrinkwrap -loop-data-prefetch -globalsplit -newgvn input.bc -o output.bc +benchmark://cbench-v1/susan,1.0112618377271563,66.1175889968872,opt -callsite-splitting -deadargelim -simple-loop-unswitch -tailcallelim -simple-loop-unswitch -adce -globalopt -aggressive-instcombine -sroa -inject-tli-mappings -add-discriminators -dce -elim-avail-extern -float2int -strip-dead-prototypes -loop-load-elim -mergereturn -lower-guard-intrinsic -loop-vectorize -libcalls-shrinkwrap -instcombine -licm -correlated-propagation -indvars -strip-debug-declare -strip-debug-declare -instsimplify -infer-address-spaces -float2int -always-inline -flattencfg -dce -newgvn -partial-inliner -jump-threading -lower-matrix-intrinsics -rpo-functionattrs -speculative-execution -loop-sink -globalsplit -lowerinvoke -gvn-hoist -elim-avail-extern -name-anon-globals -lower-guard-intrinsic -lowerinvoke -early-cse-memssa -always-inline -lower-guard-intrinsic -mergeicmps -loop-instsimplify -consthoist -jump-threading -argpromotion -newgvn -loop-distribute -loop-guard-widening -prune-eh -separate-const-offset-from-gep -sancov -inferattrs -lowerinvoke -early-cse-memssa -loweratomic -loop-load-elim -lower-guard-intrinsic -loop-unroll -loop-instsimplify -loop-versioning -div-rem-pairs -ipsccp -strip-debug-declare -prune-eh -mldst-motion -licm -bdce -loop-simplify -loweratomic -add-discriminators -lower-widenable-condition -loop-versioning -simplifycfg -functionattrs -loop-versioning-licm -loop-distribute -mem2reg -adce -strip -float2int -break-crit-edges -loop-data-prefetch -memcpyopt -ee-instrument -sccp -post-inline-ee-instrument -attributor -libcalls-shrinkwrap -cross-dso-cfi -loop-idiom -loop-guard-widening -die -attributor -coro-split -gvn -break-crit-edges -float2int -loop-versioning-licm -always-inline -coro-split -break-crit-edges -argpromotion -attributor -simplifycfg -constmerge -newgvn -instcombine -lowerswitch -canonicalize-aliases -float2int -pgo-memop-opt -infer-address-spaces -die -strip -nary-reassociate -reassociate -forceattrs -partial-inliner -add-discriminators -lowerinvoke -mem2reg -lower-constant-intrinsics -libcalls-shrinkwrap -loop-unroll -loop-deletion -callsite-splitting -loop-simplify -flattencfg -mldst-motion -adce -mergereturn -lowerinvoke -canonicalize-aliases -simplifycfg -strip-nondebug -constprop -coro-early -bdce -reassociate -newgvn -attributor -loop-data-prefetch -slsr -instcombine -lower-matrix-intrinsics -slsr -coro-cleanup -always-inline -loop-guard-widening -lower-matrix-intrinsics -sroa -div-rem-pairs -partially-inline-libcalls -indvars -forceattrs -ipsccp -loweratomic -nary-reassociate input.bc -o output.bc +benchmark://cbench-v1/susan,1.013437420015357,141.09184956550598,opt -sancov -loop-idiom -flattencfg -partially-inline-libcalls -guard-widening -loop-instsimplify -partial-inliner -ipconstprop -sink -strip -partial-inliner -early-cse-memssa -mergereturn -loop-distribute -inferattrs -loop-versioning -jump-threading -globaldce -inferattrs -loop-simplifycfg -licm -mergereturn -slp-vectorizer -strip -post-inline-ee-instrument -coro-early -adce -strip-debug-declare -sccp -correlated-propagation -canonicalize-aliases -rpo-functionattrs -rewrite-statepoints-for-gc -functionattrs -float2int -sroa -reg2mem -loop-sink -loop-unroll-and-jam -pgo-memop-opt -partial-inliner -constprop -loop-deletion -alignment-from-assumptions -strip -loop-sink -called-value-propagation -callsite-splitting -argpromotion -loop-versioning -instcombine -instcombine -instsimplify -coro-split -partial-inliner -consthoist -globalsplit -inject-tli-mappings -loop-unroll -lower-constant-intrinsics -break-crit-edges -rewrite-statepoints-for-gc -loop-versioning-licm -bdce -globalsplit -slp-vectorizer -newgvn -loop-guard-widening -simplifycfg -argpromotion -loop-simplifycfg -gvn -jump-threading -newgvn -inferattrs -loop-idiom -canonicalize-aliases -bdce -forceattrs -bdce -instnamer -reassociate -sroa -instsimplify -lower-constant-intrinsics -lower-widenable-condition -globalsplit -loop-simplify -gvn -instnamer -tailcallelim -instcombine -called-value-propagation -lower-expect -loop-predication -libcalls-shrinkwrap -licm -tailcallelim -dce -break-crit-edges -loop-idiom -tailcallelim -libcalls-shrinkwrap -coro-cleanup -separate-const-offset-from-gep -irce -loop-simplifycfg -lowerinvoke -slp-vectorizer -add-discriminators -cross-dso-cfi -alignment-from-assumptions -loop-idiom -coro-cleanup -guard-widening -globalopt -speculative-execution -loop-instsimplify -loop-simplify -reg2mem -lowerinvoke -loop-vectorize -instcombine -simple-loop-unswitch -elim-avail-extern -inject-tli-mappings -elim-avail-extern -sroa -newgvn input.bc -o output.bc +benchmark://cbench-v1/susan,1.0167647811620169,63.417919397354126,opt -mergefunc -flattencfg -aggressive-instcombine -always-inline -jump-threading -loop-unroll-and-jam -lower-guard-intrinsic -mem2reg -globalsplit -always-inline -strip-debug-declare -mergereturn -instnamer -always-inline -jump-threading -mergeicmps -scalarizer -coro-early -post-inline-ee-instrument -argpromotion -loop-deletion -strip -loop-versioning -mergereturn -constmerge -mergeicmps -loop-unroll -speculative-execution -infer-address-spaces -coro-early -forceattrs -loop-load-elim -lower-expect -scalarizer -libcalls-shrinkwrap -instnamer -post-inline-ee-instrument -loop-guard-widening -loop-instsimplify -loop-unroll-and-jam -ipconstprop -die -globalsplit -slsr -prune-eh -coro-split -gvn -lcssa -called-value-propagation -loop-interchange -barrier -inline -inferattrs -adce -insert-gcov-profiling -always-inline -globalopt -inferattrs -mergefunc -loop-reroll -barrier -functionattrs -callsite-splitting -simple-loop-unswitch -insert-gcov-profiling -hotcoldsplit -instnamer -constmerge -slsr -lower-widenable-condition -loop-instsimplify -callsite-splitting -loop-unroll -die -scalarizer -globaldce -loop-simplify -always-inline -called-value-propagation -rpo-functionattrs -div-rem-pairs -infer-address-spaces -name-anon-globals -div-rem-pairs -loop-load-elim -loop-interchange -forceattrs -functionattrs -post-inline-ee-instrument -deadargelim -load-store-vectorizer -constmerge -inferattrs -loop-distribute -canonicalize-aliases -loop-predication -lowerinvoke -elim-avail-extern -slsr -lower-constant-intrinsics -jump-threading -loop-deletion -instcombine -slsr -loop-reroll -newgvn -loop-versioning-licm -sink -loop-unswitch -sccp -simplifycfg -loweratomic -add-discriminators -reg2mem -instsimplify -coro-cleanup -bdce -loop-sink -simplifycfg -loop-vectorize -gvn -loop-deletion -strip -aggressive-instcombine -loop-sink -speculative-execution -name-anon-globals -loop-unswitch -loop-instsimplify -separate-const-offset-from-gep -lower-matrix-intrinsics -loop-instsimplify -constmerge -instcombine -redundant-dbg-inst-elim -tailcallelim -lower-guard-intrinsic -newgvn -coro-cleanup -coro-elide -loop-fusion -lower-widenable-condition -simplifycfg -loop-simplify -cross-dso-cfi -inject-tli-mappings -strip-debug-declare -bdce -loop-predication -lowerinvoke -load-store-vectorizer -partially-inline-libcalls -speculative-execution -forceattrs -loop-idiom -inject-tli-mappings -guard-widening -loop-predication -partially-inline-libcalls -lower-matrix-intrinsics -loop-unroll -memcpyopt -loweratomic -ipsccp -hotcoldsplit -dce -lower-widenable-condition -lower-matrix-intrinsics -guard-widening -infer-address-spaces -callsite-splitting -lower-matrix-intrinsics -div-rem-pairs -indvars -loop-distribute -loop-idiom -reassociate -lower-constant-intrinsics -loop-instsimplify -instcombine input.bc -o output.bc +benchmark://cbench-v1/susan,1.023931405170207,63.62526869773865,opt -rewrite-statepoints-for-gc -dce -reassociate -infer-address-spaces -loop-unswitch -called-value-propagation -strip-debug-declare -lower-matrix-intrinsics -constprop -strip-dead-prototypes -mldst-motion -mergereturn -functionattrs -loop-unroll-and-jam -globaldce -insert-gcov-profiling -partial-inliner -inject-tli-mappings -loop-reduce -ee-instrument -partial-inliner -loop-data-prefetch -redundant-dbg-inst-elim -loweratomic -loop-versioning-licm -loweratomic -separate-const-offset-from-gep -mergefunc -strip-debug-declare -mergeicmps -slp-vectorizer -indvars -loop-sink -alignment-from-assumptions -rpo-functionattrs -callsite-splitting -post-inline-ee-instrument -loop-distribute -always-inline -mem2reg -redundant-dbg-inst-elim -loop-versioning -loop-fusion -redundant-dbg-inst-elim -coro-early -gvn -loop-versioning-licm -loop-distribute -coro-early -loop-data-prefetch -instnamer -forceattrs -callsite-splitting -loop-guard-widening -load-store-vectorizer -sccp -libcalls-shrinkwrap -loop-unswitch -lower-expect -slsr -float2int -add-discriminators -slp-vectorizer -coro-split -functionattrs -name-anon-globals -separate-const-offset-from-gep -inferattrs -insert-gcov-profiling -prune-eh -lower-guard-intrinsic -inject-tli-mappings -redundant-dbg-inst-elim -newgvn -slsr -name-anon-globals -instsimplify -loop-guard-widening -loop-simplify -lowerswitch -constprop -consthoist -reg2mem -libcalls-shrinkwrap -sccp -inferattrs -simplifycfg -loop-predication -memcpyopt -flattencfg -loop-predication -adce -speculative-execution -consthoist -reg2mem -instsimplify -ipsccp -loop-simplify -div-rem-pairs -globalsplit -flattencfg -nary-reassociate -loop-data-prefetch -loop-fusion -guard-widening -loop-guard-widening -simplifycfg -simple-loop-unswitch -strip-dead-prototypes -gvn-hoist -coro-cleanup -loop-simplify -loop-load-elim -name-anon-globals -argpromotion -deadargelim -rewrite-statepoints-for-gc -correlated-propagation -ipsccp -instcombine -loop-data-prefetch -gvn -newgvn -strip-dead-prototypes -reassociate -simplifycfg -guard-widening -ee-instrument -globaldce -rpo-functionattrs -flattencfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/susan,1.0476068594829784,63.81288194656372,opt -adce -coro-split -mergereturn -loop-idiom -always-inline -strip-debug-declare -memcpyopt -guard-widening -barrier -cross-dso-cfi -loop-instsimplify -loop-versioning -hotcoldsplit -die -loop-simplifycfg -loop-fusion -loop-instsimplify -flattencfg -functionattrs -die -instsimplify -alignment-from-assumptions -loop-unswitch -irce -alignment-from-assumptions -load-store-vectorizer -scalarizer -loop-fusion -flattencfg -argpromotion -partially-inline-libcalls -pgo-memop-opt -consthoist -constmerge -dce -lower-expect -coro-split -callsite-splitting -ipconstprop -inject-tli-mappings -mem2reg -adce -guard-widening -elim-avail-extern -aggressive-instcombine -elim-avail-extern -pgo-memop-opt -loop-sink -adce -canonicalize-aliases -sancov -instsimplify -sroa -sccp -loop-sink -loop-distribute -strip-debug-declare -loop-reroll -dse -always-inline -sccp -strip-dead-prototypes -slp-vectorizer -argpromotion -instsimplify -redundant-dbg-inst-elim -mldst-motion -strip -loop-fusion -aggressive-instcombine -globaldce -sroa -simple-loop-unswitch -loop-simplify -lower-expect -constprop -infer-address-spaces -nary-reassociate -memcpyopt -scalarizer -jump-threading -sccp -coro-elide -early-cse-memssa -strip-debug-declare -bdce -globalopt -attributor -separate-const-offset-from-gep -globaldce -ipconstprop -lower-widenable-condition -loop-instsimplify -callsite-splitting -consthoist -add-discriminators -globalopt -guard-widening -slsr -jump-threading -loop-instsimplify -rewrite-statepoints-for-gc -early-cse-memssa -indvars -gvn-hoist -instcombine -instsimplify -inferattrs -separate-const-offset-from-gep -dse -redundant-dbg-inst-elim -globalsplit -slp-vectorizer -loop-versioning -ipsccp -partially-inline-libcalls -simple-loop-unswitch -load-store-vectorizer -reg2mem -speculative-execution -functionattrs -gvn -newgvn -globaldce -instcombine -partial-inliner -callsite-splitting -ee-instrument -loop-rotate -name-anon-globals -constprop -name-anon-globals -canonicalize-aliases -guard-widening -strip-debug-declare -scalarizer -simple-loop-unswitch -strip-nondebug -strip-nondebug -libcalls-shrinkwrap -loop-interchange -barrier -prune-eh -break-crit-edges -loop-rotate -forceattrs -loop-sink -lower-constant-intrinsics -gvn -attributor -slsr -loop-data-prefetch -loweratomic -rpo-functionattrs -globaldce -div-rem-pairs -mldst-motion -gvn -sink -callsite-splitting -reassociate -globalsplit -instcombine -partial-inliner -coro-cleanup -cross-dso-cfi -sroa -guard-widening -deadargelim -jump-threading -dse -loop-reroll -div-rem-pairs -lower-constant-intrinsics -always-inline -loop-vectorize -nary-reassociate -loop-versioning-licm -libcalls-shrinkwrap -barrier -scalarizer -mergereturn -reassociate -adce -gvn -loop-predication -forceattrs -mergereturn -strip-dead-prototypes -post-inline-ee-instrument -ipsccp -loop-idiom -rpo-functionattrs -deadargelim -indvars -ipsccp -speculative-execution -mldst-motion -globaldce -libcalls-shrinkwrap -consthoist -simple-loop-unswitch -infer-address-spaces -loop-sink -gvn -loop-interchange -dce -instcombine input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.014864429241735,74.9220666885376,opt -loop-sink -strip -loop-interchange -canonicalize-aliases -instsimplify -licm -correlated-propagation -speculative-execution -loop-load-elim -nary-reassociate -guard-widening -ipconstprop -coro-split -loop-deletion -inferattrs -correlated-propagation -licm -newgvn -strip-nondebug -globalsplit -inject-tli-mappings -elim-avail-extern -barrier -licm -instsimplify -lower-widenable-condition -loweratomic -prune-eh -coro-early -lower-matrix-intrinsics -lower-guard-intrinsic -coro-elide -ipconstprop -gvn-hoist -loop-fusion -die -strip -loop-instsimplify -coro-cleanup -canonicalize-aliases -loop-data-prefetch -loop-versioning -name-anon-globals -sroa -globaldce -lowerinvoke -indvars -loop-distribute -gvn-hoist -sancov -gvn-hoist -scalarizer -sroa -sccp -adce -flattencfg -indvars -separate-const-offset-from-gep -instcombine -coro-early -instnamer -div-rem-pairs -coro-cleanup -loop-unroll -reassociate -simple-loop-unswitch -float2int -redundant-dbg-inst-elim -mergereturn -partially-inline-libcalls -pgo-memop-opt -dce -correlated-propagation -early-cse-memssa -gvn-hoist -loop-unroll -add-discriminators -pgo-memop-opt -forceattrs -gvn-hoist -lower-widenable-condition -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0191625774562125,74.73441576957703,opt -instsimplify -elim-avail-extern -flattencfg -indvars -strip-debug-declare -loop-rotate -loop-instsimplify -reg2mem -partially-inline-libcalls -cross-dso-cfi -instsimplify -simple-loop-unswitch -alignment-from-assumptions -lower-matrix-intrinsics -coro-elide -simple-loop-unswitch -loop-guard-widening -loop-unroll-and-jam -functionattrs -globalsplit -hotcoldsplit -scalarizer -loop-versioning-licm -float2int -infer-address-spaces -post-inline-ee-instrument -strip -argpromotion -die -loop-simplifycfg -redundant-dbg-inst-elim -jump-threading -tailcallelim -mergeicmps -globalsplit -globalopt -lower-widenable-condition -infer-address-spaces -sink -rpo-functionattrs -break-crit-edges -rpo-functionattrs -simple-loop-unswitch -ipconstprop -sroa -loop-instsimplify -inject-tli-mappings -loop-versioning-licm -mergefunc -licm -instcombine -newgvn -loop-simplify -simplifycfg -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0203445682151937,75.50654411315918,opt -argpromotion -lcssa -newgvn -lower-matrix-intrinsics -rewrite-statepoints-for-gc -alignment-from-assumptions -loop-reroll -lower-guard-intrinsic -lower-guard-intrinsic -functionattrs -strip-dead-prototypes -inject-tli-mappings -consthoist -correlated-propagation -bdce -pgo-memop-opt -jump-threading -loop-sink -mldst-motion -loop-vectorize -callsite-splitting -partially-inline-libcalls -div-rem-pairs -flattencfg -loop-simplify -ee-instrument -sink -libcalls-shrinkwrap -mem2reg -speculative-execution -constprop -loop-fusion -prune-eh -constmerge -loop-simplifycfg -sink -strip-dead-prototypes -constprop -sink -instnamer -barrier -callsite-splitting -loop-load-elim -loop-reroll -insert-gcov-profiling -loweratomic -irce -instcombine -infer-address-spaces -irce -bdce -jump-threading -newgvn -elim-avail-extern -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0219921916974106,139.76473093032837,opt -lcssa -reg2mem -loop-reroll -globalopt -coro-cleanup -adce -inferattrs -coro-cleanup -always-inline -loop-unroll -loweratomic -slsr -correlated-propagation -coro-elide -loop-fusion -insert-gcov-profiling -name-anon-globals -loop-data-prefetch -ee-instrument -forceattrs -coro-split -rewrite-statepoints-for-gc -partial-inliner -strip-nondebug -cross-dso-cfi -reassociate -elim-avail-extern -inferattrs -loop-deletion -deadargelim -instsimplify -lower-widenable-condition -slsr -loop-unroll-and-jam -memcpyopt -strip -adce -jump-threading -lower-widenable-condition -callsite-splitting -rpo-functionattrs -mem2reg -callsite-splitting -guard-widening -slsr -instnamer -jump-threading -hotcoldsplit -coro-cleanup -strip -separate-const-offset-from-gep -rpo-functionattrs -constprop -always-inline -name-anon-globals -instsimplify -irce -inject-tli-mappings -ipconstprop -loop-vectorize -gvn -mergereturn -div-rem-pairs -loop-vectorize -loop-idiom -loop-vectorize -ee-instrument -simple-loop-unswitch -strip-nondebug -lcssa -simplifycfg -loweratomic -rewrite-statepoints-for-gc -rpo-functionattrs -instnamer -lower-widenable-condition -mergereturn -slsr -instcombine input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.022171281206347,73.88120555877686,opt -inferattrs -prune-eh -sroa -ipconstprop -redundant-dbg-inst-elim -post-inline-ee-instrument -mergereturn -licm -simplifycfg -correlated-propagation -mergereturn -always-inline -inferattrs -instnamer -newgvn -sroa -die -coro-split -alignment-from-assumptions -infer-address-spaces -tailcallelim -coro-elide -strip -mldst-motion -callsite-splitting -newgvn -constprop -rpo-functionattrs -loop-instsimplify -inferattrs -reassociate -loop-reroll -indvars -constprop -barrier -always-inline -redundant-dbg-inst-elim -coro-elide -instcombine -slp-vectorizer input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0225652781260075,74.9262228012085,opt -alignment-from-assumptions -pgo-memop-opt -loop-deletion -loop-fusion -constmerge -tailcallelim -nary-reassociate -loop-instsimplify -prune-eh -loop-predication -die -break-crit-edges -sancov -instnamer -loop-simplifycfg -lower-constant-intrinsics -strip-nondebug -lcssa -lower-expect -sancov -dce -loop-instsimplify -sroa -indvars -early-cse-memssa -barrier -loop-guard-widening -mem2reg -mergefunc -hotcoldsplit -slp-vectorizer -rpo-functionattrs -die -newgvn -loop-unroll-and-jam -called-value-propagation -mergereturn -mergereturn -instsimplify -tailcallelim -instcombine -loop-idiom -strip -lower-guard-intrinsic -memcpyopt -hotcoldsplit -ipconstprop -strip -lcssa -forceattrs -simplifycfg -lower-constant-intrinsics -loop-vectorize -inject-tli-mappings -strip-debug-declare -loop-vectorize -coro-early -loop-data-prefetch -simple-loop-unswitch -lcssa -simplifycfg -coro-cleanup -sink -simplifycfg -reassociate -lower-widenable-condition -slsr -loop-deletion -instcombine -name-anon-globals -loop-unroll -consthoist -adce -newgvn input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.024033812099287,77.53979635238647,opt -lowerinvoke -float2int -mem2reg -lower-guard-intrinsic -break-crit-edges -sroa -partial-inliner -instcombine -loop-guard-widening -div-rem-pairs -inject-tli-mappings -rpo-functionattrs -coro-split -loop-load-elim -sroa -prune-eh -loop-deletion -coro-elide -loop-simplify -correlated-propagation -inferattrs -div-rem-pairs -jump-threading -instsimplify -adce -instsimplify -slp-vectorizer -dse -globalsplit -guard-widening -add-discriminators -jump-threading -lower-widenable-condition -attributor -ipconstprop -coro-split -loop-simplify -prune-eh -reg2mem -loop-unroll-and-jam -alignment-from-assumptions -argpromotion -lowerinvoke -called-value-propagation -early-cse-memssa -called-value-propagation -sroa -prune-eh -pgo-memop-opt -dse -sroa -attributor -loop-predication -sink -bdce -mergefunc -instsimplify -mergeicmps -loop-simplifycfg -name-anon-globals -loop-unroll-and-jam -indvars -barrier -die -licm -float2int -loop-load-elim -inferattrs -canonicalize-aliases -alignment-from-assumptions -coro-split -reassociate -constmerge -cross-dso-cfi -ee-instrument -lower-expect -strip-nondebug -libcalls-shrinkwrap -loop-guard-widening -nary-reassociate -dce -always-inline -load-store-vectorizer -instcombine -loop-guard-widening -hotcoldsplit -name-anon-globals -die -ipsccp -prune-eh -barrier -instnamer -gvn -coro-elide -loop-instsimplify -name-anon-globals -loop-load-elim -coro-split -loop-guard-widening -instsimplify -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0244994448225224,74.15848064422607,opt -sroa -loop-versioning -strip-debug-declare -hotcoldsplit -name-anon-globals -slsr -name-anon-globals -instsimplify -loop-unswitch -rpo-functionattrs -deadargelim -rewrite-statepoints-for-gc -indvars -loop-guard-widening -early-cse-memssa -inject-tli-mappings -simplifycfg -loop-guard-widening -loop-interchange -ipconstprop -indvars -coro-cleanup -correlated-propagation -mem2reg -coro-early -loop-data-prefetch -sink -coro-cleanup -argpromotion -inferattrs -lower-widenable-condition -functionattrs -flattencfg -newgvn -ipsccp -mergereturn -barrier -constprop -newgvn -cross-dso-cfi -gvn-hoist -globalopt -nary-reassociate -forceattrs -insert-gcov-profiling -instcombine -globaldce -bdce -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.0286901393316379,74.36752319335938,opt -break-crit-edges -instsimplify -instsimplify -mldst-motion -ee-instrument -simplifycfg -hotcoldsplit -rpo-functionattrs -strip-nondebug -early-cse-memssa -mem2reg -gvn-hoist -dce -instcombine -loop-unroll -ipconstprop -load-store-vectorizer -callsite-splitting -nary-reassociate -float2int -mem2reg -instsimplify -memcpyopt -ipconstprop -loop-idiom -instsimplify -newgvn -loop-simplifycfg -lower-widenable-condition -reassociate -sroa -functionattrs -guard-widening -sroa -globalsplit -loop-distribute -loop-simplifycfg -dse -reassociate -instcombine -attributor -canonicalize-aliases -loop-fusion -instnamer -ipsccp -always-inline -lcssa -rewrite-statepoints-for-gc -slsr -mergefunc -loweratomic -simplifycfg -lower-matrix-intrinsics -add-discriminators -loop-unroll -redundant-dbg-inst-elim -argpromotion -loop-deletion -guard-widening -simple-loop-unswitch -gvn-hoist -loop-unroll-and-jam -loop-idiom -flattencfg -dse -loop-reroll -slp-vectorizer -hotcoldsplit -instsimplify -loop-vectorize -speculative-execution -load-store-vectorizer -loop-idiom -loop-distribute -loop-guard-widening -loop-idiom -coro-elide -globaldce -loop-unroll -loweratomic -loop-simplifycfg -scalarizer -nary-reassociate -alignment-from-assumptions -partially-inline-libcalls -elim-avail-extern -pgo-memop-opt -gvn-hoist -jump-threading -nary-reassociate -jump-threading -jump-threading -strip-nondebug -correlated-propagation -float2int -partially-inline-libcalls -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiff2bw,1.031555571474623,75.60634303092957,opt -libcalls-shrinkwrap -loop-interchange -loop-distribute -rpo-functionattrs -flattencfg -jump-threading -loop-versioning -strip -rewrite-statepoints-for-gc -sink -loop-versioning-licm -strip-nondebug -coro-elide -loop-instsimplify -deadargelim -strip-dead-prototypes -indvars -reassociate -loop-reduce -loop-distribute -memcpyopt -lower-widenable-condition -elim-avail-extern -loop-versioning-licm -nary-reassociate -post-inline-ee-instrument -consthoist -lower-matrix-intrinsics -coro-early -sancov -irce -lowerinvoke -loop-guard-widening -lower-guard-intrinsic -attributor -loop-unroll -loop-sink -instnamer -instnamer -loop-versioning-licm -loop-vectorize -reg2mem -irce -post-inline-ee-instrument -ipconstprop -instsimplify -inject-tli-mappings -callsite-splitting -name-anon-globals -strip-debug-declare -hotcoldsplit -loop-sink -loop-data-prefetch -globalopt -strip-debug-declare -lower-constant-intrinsics -flattencfg -mem2reg -pgo-memop-opt -sccp -rpo-functionattrs -prune-eh -separate-const-offset-from-gep -strip-dead-prototypes -deadargelim -flattencfg -gvn-hoist -ipconstprop -infer-address-spaces -early-cse-memssa -lower-expect -sroa -post-inline-ee-instrument -libcalls-shrinkwrap -gvn-hoist -consthoist -die -libcalls-shrinkwrap -lower-widenable-condition -ipsccp -loop-instsimplify -loop-versioning -break-crit-edges -loop-deletion -constmerge -canonicalize-aliases -slp-vectorizer -post-inline-ee-instrument -inferattrs -lower-widenable-condition -prune-eh -argpromotion -dce -lowerinvoke -called-value-propagation -loop-reroll -rewrite-statepoints-for-gc -loop-interchange -loop-load-elim -cross-dso-cfi -simplifycfg -float2int -correlated-propagation -loweratomic -sancov -functionattrs -instcombine -deadargelim -bdce -lowerinvoke -memcpyopt -argpromotion -hotcoldsplit -coro-elide -strip-debug-declare -argpromotion -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.000753985351142,77.92356705665588,opt -ee-instrument -loop-load-elim -functionattrs -early-cse-memssa -sccp -attributor -canonicalize-aliases -libcalls-shrinkwrap -loop-guard-widening -irce -sroa -loop-reroll -ee-instrument -irce -nary-reassociate -add-discriminators -loop-sink -post-inline-ee-instrument -globalopt -early-cse-memssa -globalopt -loop-data-prefetch -loop-guard-widening -float2int -lower-widenable-condition -indvars -strip-dead-prototypes -scalarizer -redundant-dbg-inst-elim -load-store-vectorizer -globalopt -redundant-dbg-inst-elim -name-anon-globals -break-crit-edges -div-rem-pairs -inject-tli-mappings -loop-distribute -attributor -mergereturn -coro-split -rewrite-statepoints-for-gc -coro-cleanup -loop-deletion -speculative-execution -loop-reduce -loop-instsimplify -scalarizer -instsimplify -attributor -elim-avail-extern -bdce -scalarizer -strip-dead-prototypes -gvn -consthoist -loop-versioning -aggressive-instcombine -newgvn -cross-dso-cfi -memcpyopt -lcssa -lower-guard-intrinsic -mergeicmps -loop-distribute -loop-deletion -tailcallelim -loop-data-prefetch -separate-const-offset-from-gep -ee-instrument -insert-gcov-profiling -indvars -lower-guard-intrinsic -memcpyopt -loop-idiom -slp-vectorizer -elim-avail-extern -jump-threading -alignment-from-assumptions -loop-unroll-and-jam -loop-load-elim -rpo-functionattrs -strip-dead-prototypes -guard-widening -loop-idiom -mergefunc -gvn -rewrite-statepoints-for-gc -break-crit-edges -coro-early -pgo-memop-opt -cross-dso-cfi -mldst-motion -loop-sink -jump-threading -lcssa -jump-threading -guard-widening -bdce -instnamer -lower-guard-intrinsic -reg2mem -insert-gcov-profiling -loop-interchange -mem2reg -simple-loop-unswitch -hotcoldsplit -loop-unswitch -gvn-hoist -loop-unswitch -constmerge -add-discriminators -instcombine -slsr -loop-predication -loop-data-prefetch -barrier -simplifycfg -barrier -globaldce -instsimplify input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0105557949159845,74.41571712493896,opt -partially-inline-libcalls -sccp -loop-idiom -flattencfg -div-rem-pairs -globalopt -coro-cleanup -elim-avail-extern -called-value-propagation -loop-unswitch -loop-vectorize -attributor -always-inline -loop-simplifycfg -prune-eh -mergeicmps -loop-fusion -elim-avail-extern -adce -post-inline-ee-instrument -div-rem-pairs -argpromotion -simplifycfg -loop-simplifycfg -loop-data-prefetch -lower-matrix-intrinsics -loop-idiom -gvn-hoist -alignment-from-assumptions -deadargelim -mldst-motion -correlated-propagation -lower-matrix-intrinsics -memcpyopt -functionattrs -die -loop-instsimplify -loop-versioning-licm -die -sccp -coro-cleanup -sink -loop-fusion -memcpyopt -nary-reassociate -cross-dso-cfi -reassociate -coro-early -infer-address-spaces -float2int -guard-widening -rpo-functionattrs -aggressive-instcombine -float2int -simple-loop-unswitch -loop-unroll -indvars -lowerinvoke -scalarizer -prune-eh -ipsccp -inferattrs -strip-debug-declare -sroa -bdce -loop-deletion -lowerinvoke -forceattrs -rpo-functionattrs -load-store-vectorizer -rewrite-statepoints-for-gc -coro-elide -libcalls-shrinkwrap -strip -loop-deletion -die -speculative-execution -aggressive-instcombine -loop-fusion -sink -loop-vectorize -loop-versioning-licm -slp-vectorizer -prune-eh -separate-const-offset-from-gep -loop-versioning-licm -instsimplify -simplifycfg -mergefunc -canonicalize-aliases -correlated-propagation -float2int -coro-early -globaldce -gvn-hoist -loop-vectorize -simple-loop-unswitch -loop-predication -prune-eh -loop-simplifycfg -memcpyopt -inferattrs -always-inline -functionattrs -simple-loop-unswitch -loop-guard-widening -consthoist -indvars -instsimplify -slp-vectorizer -aggressive-instcombine -instcombine -aggressive-instcombine -gvn input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0111661640097658,76.2009334564209,opt -slp-vectorizer -correlated-propagation -adce -partially-inline-libcalls -loop-versioning-licm -loweratomic -speculative-execution -ee-instrument -jump-threading -inferattrs -elim-avail-extern -simplifycfg -loop-data-prefetch -break-crit-edges -newgvn -div-rem-pairs -loop-reduce -prune-eh -bdce -die -loop-predication -reassociate -break-crit-edges -lower-matrix-intrinsics -rewrite-statepoints-for-gc -coro-cleanup -loop-idiom -bdce -mergereturn -indvars -always-inline -constprop -prune-eh -mergeicmps -separate-const-offset-from-gep -adce -lower-matrix-intrinsics -partial-inliner -slp-vectorizer -loop-fusion -coro-early -insert-gcov-profiling -strip -post-inline-ee-instrument -globalopt -loop-simplify -guard-widening -post-inline-ee-instrument -canonicalize-aliases -tailcallelim -lcssa -name-anon-globals -adce -coro-cleanup -break-crit-edges -loop-simplifycfg -reg2mem -loop-unroll -nary-reassociate -simple-loop-unswitch -strip -mem2reg -lower-constant-intrinsics -memcpyopt -div-rem-pairs -correlated-propagation -prune-eh -forceattrs -pgo-memop-opt -loop-unswitch -lcssa -constprop -loop-deletion -deadargelim -ipsccp -loop-simplifycfg -loop-sink -separate-const-offset-from-gep -slp-vectorizer -coro-cleanup -called-value-propagation -strip-dead-prototypes -simple-loop-unswitch -ipconstprop -div-rem-pairs -strip-debug-declare -speculative-execution -scalarizer -loop-versioning-licm -coro-cleanup -partial-inliner -loop-versioning-licm -called-value-propagation -functionattrs -slp-vectorizer -float2int -ipsccp -scalarizer -coro-early -adce -callsite-splitting -slsr -elim-avail-extern -tailcallelim -name-anon-globals -memcpyopt -coro-elide -forceattrs -lowerinvoke -libcalls-shrinkwrap -sink -lower-guard-intrinsic -prune-eh -nary-reassociate -forceattrs -rpo-functionattrs -cross-dso-cfi -bdce -correlated-propagation -loop-data-prefetch -loop-distribute -always-inline -sroa -loop-unroll -loop-versioning -loop-versioning-licm -globaldce -coro-cleanup -slsr -loweratomic -coro-split -loop-simplify -insert-gcov-profiling -die -instsimplify -loop-distribute -called-value-propagation -slp-vectorizer -sccp -libcalls-shrinkwrap -loop-unroll -slp-vectorizer -early-cse-memssa -loop-interchange -lower-widenable-condition -strip -strip-dead-prototypes -dse -coro-elide -constprop -pgo-memop-opt -coro-elide -add-discriminators -loop-distribute -simplifycfg -guard-widening -loop-versioning-licm -slp-vectorizer -lcssa -coro-early -loop-guard-widening -gvn -instcombine -correlated-propagation -lower-expect -functionattrs -lcssa -adce -instcombine -sccp -ipsccp -tailcallelim -ipconstprop -strip-dead-prototypes -rpo-functionattrs -forceattrs -newgvn input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0149360907654748,74.06858968734741,opt -dce -constprop -attributor -loop-reroll -slsr -always-inline -instsimplify -inject-tli-mappings -inject-tli-mappings -sroa -loop-versioning-licm -float2int -lower-widenable-condition -loop-sink -coro-elide -speculative-execution -loweratomic -strip-dead-prototypes -flattencfg -simplifycfg -loop-reroll -slsr -loop-deletion -div-rem-pairs -reassociate -mergefunc -scalarizer -callsite-splitting -simple-loop-unswitch -prune-eh -loop-instsimplify -guard-widening -loop-idiom -bdce -constprop -loop-predication -die -mem2reg -newgvn -mem2reg -mergeicmps -deadargelim -early-cse-memssa -correlated-propagation -called-value-propagation -reassociate -mergefunc -div-rem-pairs -loop-versioning -post-inline-ee-instrument -mem2reg -loop-versioning -gvn-hoist -early-cse-memssa -rewrite-statepoints-for-gc -strip-dead-prototypes -simple-loop-unswitch -coro-split -sink -strip-dead-prototypes -jump-threading -sccp -break-crit-edges -scalarizer -loop-load-elim -loop-guard-widening -memcpyopt -ipconstprop -coro-elide -mergereturn -globalopt -mldst-motion -div-rem-pairs -speculative-execution -simple-loop-unswitch -callsite-splitting -infer-address-spaces -licm -simplifycfg -cross-dso-cfi -strip-debug-declare -early-cse-memssa -mldst-motion -lcssa -slsr -functionattrs -sancov -rpo-functionattrs -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0156541720522767,76.2298526763916,opt -loop-load-elim -mem2reg -rpo-functionattrs -ee-instrument -ipsccp -strip-debug-declare -licm -sccp -dce -loop-simplifycfg -post-inline-ee-instrument -globaldce -reassociate -coro-cleanup -slsr -simplifycfg -constmerge -loop-predication -constprop -sroa -mergefunc -coro-elide -forceattrs -constprop -sroa -loop-unswitch -called-value-propagation -simple-loop-unswitch -memcpyopt -strip-dead-prototypes -loop-simplify -pgo-memop-opt -die -globaldce -guard-widening -instcombine -cross-dso-cfi -infer-address-spaces -div-rem-pairs -simple-loop-unswitch -loop-instsimplify -instcombine -coro-elide -loop-fusion -mergefunc -consthoist -callsite-splitting -called-value-propagation -globalopt -memcpyopt -lower-expect -sancov -instcombine -strip-debug-declare -elim-avail-extern -scalarizer -coro-early -loop-fusion -loop-idiom -inject-tli-mappings -loop-instsimplify -newgvn -break-crit-edges -barrier -loop-unroll-and-jam -loop-simplifycfg -gvn-hoist -strip-debug-declare -licm -canonicalize-aliases -inject-tli-mappings -sancov -reassociate -rewrite-statepoints-for-gc -simple-loop-unswitch -loop-instsimplify -loop-deletion -speculative-execution -mem2reg -correlated-propagation -mergereturn -rewrite-statepoints-for-gc -loop-predication -jump-threading -gvn-hoist -licm -ipconstprop -loop-unroll -flattencfg -functionattrs -loop-simplifycfg -lower-constant-intrinsics -instcombine input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0159414045669974,77.51045274734497,opt -strip-debug-declare -sroa -jump-threading -partially-inline-libcalls -sink -dse -globaldce -mem2reg -argpromotion -consthoist -loop-reduce -tailcallelim -libcalls-shrinkwrap -lower-matrix-intrinsics -loop-load-elim -simple-loop-unswitch -mergeicmps -sancov -gvn-hoist -break-crit-edges -break-crit-edges -early-cse-memssa -argpromotion -scalarizer -always-inline -add-discriminators -guard-widening -callsite-splitting -loop-simplify -globaldce -loop-unroll-and-jam -insert-gcov-profiling -float2int -indvars -separate-const-offset-from-gep -loop-interchange -jump-threading -inferattrs -loop-unroll-and-jam -strip-dead-prototypes -div-rem-pairs -attributor -mergereturn -sancov -loop-versioning-licm -simple-loop-unswitch -tailcallelim -inferattrs -float2int -forceattrs -float2int -instcombine -loop-versioning -inferattrs -callsite-splitting -loop-guard-widening -speculative-execution -correlated-propagation -simplifycfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0213270142180093,75.81489181518555,opt -loop-idiom -div-rem-pairs -mem2reg -simple-loop-unswitch -mem2reg -mergefunc -loop-idiom -loop-instsimplify -irce -sroa -loop-distribute -libcalls-shrinkwrap -newgvn -memcpyopt -coro-elide -simplifycfg -ipconstprop -loop-unroll-and-jam -forceattrs -loweratomic -loop-reroll -barrier -lcssa -libcalls-shrinkwrap -mergereturn -name-anon-globals -flattencfg -instsimplify -loop-fusion -loop-versioning -early-cse-memssa -instcombine input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0244506678155967,76.34029912948608,opt -ee-instrument -globaldce -mem2reg -rpo-functionattrs -loop-vectorize -instcombine -strip -callsite-splitting -infer-address-spaces -alignment-from-assumptions -mldst-motion -redundant-dbg-inst-elim -strip-dead-prototypes -loop-data-prefetch -pgo-memop-opt -die -bdce -early-cse-memssa -loop-predication -reassociate -lowerinvoke -instnamer -indvars -sroa -cross-dso-cfi -mergefunc -deadargelim -gvn-hoist -instcombine -post-inline-ee-instrument -loop-data-prefetch -nary-reassociate -irce -lowerinvoke -sancov -elim-avail-extern -nary-reassociate -loop-distribute -aggressive-instcombine -tailcallelim -correlated-propagation -early-cse-memssa -loop-idiom -loop-predication -slsr -mldst-motion -loop-reroll -newgvn -coro-elide -reassociate -loop-distribute -simplifycfg -inject-tli-mappings -memcpyopt input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0263535832256214,76.55784583091736,opt -loop-distribute -speculative-execution -inferattrs -die -instnamer -loop-versioning -name-anon-globals -rewrite-statepoints-for-gc -loop-instsimplify -correlated-propagation -indvars -loop-idiom -libcalls-shrinkwrap -strip-nondebug -load-store-vectorizer -canonicalize-aliases -indvars -scalarizer -coro-elide -globalsplit -sroa -ipconstprop -lower-guard-intrinsic -nary-reassociate -mem2reg -loop-versioning -newgvn -instnamer -instsimplify -tailcallelim -memcpyopt -mergefunc -die -partially-inline-libcalls -loop-predication -loop-distribute -aggressive-instcombine -sccp -reg2mem -scalarizer -forceattrs -die -guard-widening -libcalls-shrinkwrap -libcalls-shrinkwrap -gvn-hoist -coro-cleanup -mem2reg -memcpyopt -loop-predication -scalarizer -inferattrs -loop-simplify -flattencfg -scalarizer -loop-distribute -mldst-motion -coro-early -scalarizer -infer-address-spaces -instnamer -reassociate -break-crit-edges -lowerinvoke -early-cse-memssa -ee-instrument -globalopt -called-value-propagation -guard-widening -correlated-propagation -guard-widening -loop-unroll-and-jam -partial-inliner -partial-inliner -loop-predication -loop-idiom -loop-reduce -loop-deletion -correlated-propagation -functionattrs -loop-versioning-licm -deadargelim -die -gvn-hoist -globalopt -argpromotion -strip-dead-prototypes -irce -strip-nondebug -globalopt -lower-constant-intrinsics -rpo-functionattrs -sccp -div-rem-pairs -globalopt -loop-unswitch -lower-guard-intrinsic -ipsccp -loop-predication -scalarizer -loop-reroll -licm -mergereturn -elim-avail-extern -loop-fusion -simple-loop-unswitch -loop-interchange -simplifycfg -ipsccp -dce -lcssa -sccp -strip-debug-declare -loop-versioning-licm -hotcoldsplit -coro-cleanup -add-discriminators -break-crit-edges -ee-instrument -loop-data-prefetch -functionattrs -reassociate -inject-tli-mappings -load-store-vectorizer -loop-load-elim -simple-loop-unswitch -loop-unroll -strip -pgo-memop-opt -instcombine -dce -newgvn -lower-matrix-intrinsics -hotcoldsplit -argpromotion -prune-eh -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiff2rgba,1.0282564986356453,76.88841128349304,opt -aggressive-instcombine -float2int -inject-tli-mappings -post-inline-ee-instrument -coro-elide -called-value-propagation -reg2mem -constprop -functionattrs -adce -dce -add-discriminators -pgo-memop-opt -prune-eh -attributor -mem2reg -argpromotion -coro-early -adce -mergefunc -strip -indvars -rpo-functionattrs -deadargelim -post-inline-ee-instrument -mergeicmps -coro-early -functionattrs -loop-versioning-licm -irce -mergefunc -loop-predication -lower-matrix-intrinsics -adce -strip-nondebug -gvn -dse -gvn-hoist -sancov -lower-widenable-condition -ee-instrument -rewrite-statepoints-for-gc -strip-debug-declare -barrier -insert-gcov-profiling -load-store-vectorizer -rewrite-statepoints-for-gc -hotcoldsplit -strip-debug-declare -called-value-propagation -instnamer -lower-widenable-condition -mergereturn -loop-unroll -slsr -speculative-execution -partially-inline-libcalls -jump-threading -lower-constant-intrinsics -constmerge -barrier -gvn -loop-reroll -attributor -reassociate -lower-guard-intrinsic -licm -redundant-dbg-inst-elim -guard-widening -tailcallelim -lcssa -dse -mem2reg -sroa -break-crit-edges -loop-interchange -mergeicmps -indvars -loweratomic -mergefunc -gvn-hoist -aggressive-instcombine -tailcallelim -loop-interchange -rpo-functionattrs -libcalls-shrinkwrap -lower-matrix-intrinsics -consthoist -loop-unroll-and-jam -alignment-from-assumptions -globalsplit -pgo-memop-opt -ee-instrument -coro-early -attributor -constprop -loweratomic -instnamer -prune-eh -loop-simplify -nary-reassociate -mem2reg -called-value-propagation -partial-inliner -loop-fusion -indvars -coro-elide -elim-avail-extern -strip -loop-distribute -rpo-functionattrs -loop-sink -float2int -globalopt -sink -dce -float2int -loop-reroll -forceattrs -slp-vectorizer -loop-instsimplify -mergeicmps -globaldce -load-store-vectorizer -loop-unroll-and-jam -lcssa -loop-simplify -coro-cleanup -lower-matrix-intrinsics -lower-matrix-intrinsics -loop-reroll -sroa -sink -hotcoldsplit -break-crit-edges -tailcallelim -mldst-motion -tailcallelim -globalsplit -deadargelim -lower-matrix-intrinsics -barrier -loop-distribute -name-anon-globals -instcombine -lower-guard-intrinsic -coro-elide -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.0113177623990772,77.15600180625916,opt -loop-load-elim -div-rem-pairs -prune-eh -gvn -argpromotion -div-rem-pairs -mem2reg -strip-debug-declare -add-discriminators -coro-early -attributor -dce -guard-widening -inject-tli-mappings -loop-predication -ee-instrument -simplifycfg -lower-widenable-condition -strip -cross-dso-cfi -loop-unswitch -loop-unroll -lower-widenable-condition -redundant-dbg-inst-elim -load-store-vectorizer -strip -correlated-propagation -consthoist -memcpyopt -lowerinvoke -instnamer -licm -sink -lower-matrix-intrinsics -lower-matrix-intrinsics -lower-widenable-condition -loop-unswitch -lower-guard-intrinsic -flattencfg -indvars -dce -lcssa -loop-unroll-and-jam -dce -hotcoldsplit -gvn-hoist -alignment-from-assumptions -callsite-splitting -libcalls-shrinkwrap -load-store-vectorizer -strip -break-crit-edges -lower-widenable-condition -sink -coro-early -ipsccp -lcssa -licm -load-store-vectorizer -strip-dead-prototypes -called-value-propagation -gvn -early-cse-memssa -lowerinvoke -inject-tli-mappings -early-cse-memssa -insert-gcov-profiling -aggressive-instcombine -loop-interchange -consthoist -loop-load-elim -coro-elide -prune-eh -bdce -lcssa -scalarizer -correlated-propagation -flattencfg -coro-split -licm -early-cse-memssa -ipconstprop -licm -lowerinvoke -lower-constant-intrinsics -callsite-splitting -constprop -prune-eh -guard-widening -simple-loop-unswitch -insert-gcov-profiling -break-crit-edges -strip -newgvn -correlated-propagation -loop-simplify -barrier -ipsccp -ipconstprop -loop-idiom -ipconstprop -loop-vectorize -partial-inliner -lower-expect -ipsccp -ipconstprop -simplifycfg -loop-versioning -mergeicmps -called-value-propagation -flattencfg -sink -early-cse-memssa -libcalls-shrinkwrap -loop-simplifycfg -loop-guard-widening -loop-predication -always-inline -loop-instsimplify -load-store-vectorizer -mergeicmps -instsimplify -gvn -instsimplify -mem2reg -loop-interchange -forceattrs -mem2reg -libcalls-shrinkwrap -instsimplify -lcssa -loop-sink -callsite-splitting -load-store-vectorizer -ipconstprop -die -inferattrs -loop-guard-widening -div-rem-pairs -insert-gcov-profiling -scalarizer -called-value-propagation -loop-versioning -div-rem-pairs -loop-reduce -pgo-memop-opt -ipsccp -correlated-propagation -sink -loop-versioning-licm -functionattrs -newgvn -ipconstprop -aggressive-instcombine -loop-simplify -name-anon-globals -lcssa -licm -cross-dso-cfi -loop-interchange -lower-matrix-intrinsics -mem2reg -reassociate -hotcoldsplit -add-discriminators -tailcallelim -always-inline -slsr -loweratomic -lower-matrix-intrinsics -instcombine -tailcallelim -strip -post-inline-ee-instrument -lowerinvoke -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.0122909457900806,381.1352982521057,opt -name-anon-globals -libcalls-shrinkwrap -loop-data-prefetch -float2int -lcssa -gvn -coro-elide -loop-interchange -separate-const-offset-from-gep -sroa -rewrite-statepoints-for-gc -ipconstprop -cross-dso-cfi -argpromotion -aggressive-instcombine -separate-const-offset-from-gep -functionattrs -instnamer -mldst-motion -rewrite-statepoints-for-gc -loop-predication -globaldce -gvn-hoist -loop-data-prefetch -ipsccp -hotcoldsplit -mergereturn -rewrite-statepoints-for-gc -libcalls-shrinkwrap -add-discriminators -mldst-motion -globalopt -indvars -constmerge -prune-eh -partially-inline-libcalls -loop-reroll -loop-instsimplify -adce -tailcallelim -aggressive-instcombine -mergereturn -libcalls-shrinkwrap -mergefunc -simple-loop-unswitch -post-inline-ee-instrument -name-anon-globals -barrier -coro-early -partially-inline-libcalls -licm -loop-interchange -lowerinvoke -sink -sink -simple-loop-unswitch -lower-constant-intrinsics -consthoist -loop-data-prefetch -loop-unroll -instcombine -nary-reassociate -forceattrs -scalarizer -float2int -dse -early-cse-memssa -memcpyopt -loop-interchange -div-rem-pairs -lower-matrix-intrinsics -memcpyopt -scalarizer -instcombine -simple-loop-unswitch -post-inline-ee-instrument -instsimplify -instnamer -mergeicmps -globalsplit -callsite-splitting -ipsccp -globalopt -rpo-functionattrs -ipconstprop -callsite-splitting -insert-gcov-profiling -loop-reduce -loop-simplifycfg -strip-nondebug -barrier -inject-tli-mappings -loop-distribute -licm -libcalls-shrinkwrap -coro-cleanup -name-anon-globals -post-inline-ee-instrument -strip-debug-declare -sink -lcssa -ee-instrument -loop-instsimplify -simple-loop-unswitch -simplifycfg -canonicalize-aliases -newgvn input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.0167243367935412,88.61051821708679,opt -correlated-propagation -instnamer -redundant-dbg-inst-elim -loop-idiom -loop-simplify -globalsplit -div-rem-pairs -break-crit-edges -constmerge -ipconstprop -loop-instsimplify -alignment-from-assumptions -canonicalize-aliases -coro-split -consthoist -sroa -irce -loop-versioning -lower-matrix-intrinsics -gvn -mldst-motion -coro-cleanup -loop-guard-widening -insert-gcov-profiling -load-store-vectorizer -elim-avail-extern -constprop -instcombine -gvn-hoist -die -called-value-propagation -lower-widenable-condition -newgvn -pgo-memop-opt -called-value-propagation -functionattrs -forceattrs -instcombine -guard-widening -callsite-splitting -coro-early -loop-load-elim -aggressive-instcombine -lcssa -constprop -reassociate -mem2reg -always-inline -newgvn -scalarizer -consthoist -constmerge -loop-load-elim -consthoist -coro-elide -barrier -guard-widening -loop-versioning -lower-widenable-condition -scalarizer -mldst-motion -argpromotion -adce -scalarizer -scalarizer -correlated-propagation -forceattrs -correlated-propagation -gvn -coro-elide -hotcoldsplit -jump-threading -lowerinvoke -slsr -loop-distribute -constprop -loop-sink -correlated-propagation -coro-split -break-crit-edges -loweratomic -barrier -elim-avail-extern -elim-avail-extern -dce -mem2reg -strip-dead-prototypes -lower-expect -break-crit-edges -lcssa -consthoist -adce -loop-vectorize -div-rem-pairs -correlated-propagation -lower-widenable-condition -constprop -sancov -loop-unroll-and-jam -loop-reduce -lower-constant-intrinsics -deadargelim -infer-address-spaces -coro-cleanup -deadargelim -loop-idiom -coro-early -lower-matrix-intrinsics -globalsplit -globaldce -loop-deletion -mldst-motion -nary-reassociate -coro-split -die -simplifycfg -instcombine input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.0197159746251443,78.524822473526,opt -pgo-memop-opt -consthoist -simplifycfg -gvn-hoist -nary-reassociate -instnamer -gvn-hoist -redundant-dbg-inst-elim -post-inline-ee-instrument -loop-guard-widening -lower-matrix-intrinsics -hotcoldsplit -canonicalize-aliases -simplifycfg -nary-reassociate -cross-dso-cfi -loop-versioning -instsimplify -constmerge -lowerinvoke -adce -scalarizer -pgo-memop-opt -argpromotion -hotcoldsplit -correlated-propagation -loop-idiom -loop-deletion -barrier -dse -partially-inline-libcalls -loop-simplifycfg -coro-split -lower-expect -redundant-dbg-inst-elim -loop-interchange -reg2mem -separate-const-offset-from-gep -newgvn -globaldce -elim-avail-extern -loop-sink -lcssa -coro-cleanup -strip-debug-declare -mem2reg -gvn-hoist -loop-versioning-licm -forceattrs -mldst-motion -strip-dead-prototypes -strip-dead-prototypes -instcombine -sroa -jump-threading -tailcallelim -speculative-execution -loop-unroll-and-jam -adce -mergefunc -loop-versioning -dse -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.0200043252595157,76.91719341278076,opt -loop-simplify -strip -gvn -lcssa -functionattrs -argpromotion -strip -correlated-propagation -lower-expect -prune-eh -cross-dso-cfi -tailcallelim -lower-matrix-intrinsics -simple-loop-unswitch -instcombine -instsimplify -guard-widening -inject-tli-mappings -speculative-execution -strip-debug-declare -loop-instsimplify -sink -strip-nondebug -lcssa -sccp -strip -instnamer -gvn -gvn-hoist -loop-unroll-and-jam -strip-dead-prototypes -always-inline -lower-guard-intrinsic -elim-avail-extern -lcssa -tailcallelim -constmerge -strip -rpo-functionattrs -reassociate -loop-data-prefetch -loop-reduce -elim-avail-extern -simplifycfg -lowerinvoke -coro-cleanup -break-crit-edges -cross-dso-cfi -globalopt -coro-elide -sroa -gvn-hoist -argpromotion -loweratomic -speculative-execution -guard-widening -insert-gcov-profiling -bdce -lower-widenable-condition -mergefunc -slsr -simple-loop-unswitch -called-value-propagation -partial-inliner -div-rem-pairs -instcombine -dce -add-discriminators -coro-early -canonicalize-aliases -newgvn -globaldce -name-anon-globals -simple-loop-unswitch -dce -correlated-propagation -loop-unroll -rewrite-statepoints-for-gc -loop-instsimplify -nary-reassociate -loweratomic -loop-predication -licm -constprop -instsimplify -inject-tli-mappings -tailcallelim -pgo-memop-opt -prune-eh -name-anon-globals -lower-widenable-condition -globalopt -slsr -loop-instsimplify -early-cse-memssa -deadargelim -insert-gcov-profiling -guard-widening -sroa -deadargelim -mldst-motion -alignment-from-assumptions -alignment-from-assumptions -strip-dead-prototypes -lower-expect -coro-elide -flattencfg -globalsplit -lower-widenable-condition -always-inline -forceattrs -flattencfg -always-inline -sancov -lower-constant-intrinsics -instcombine -attributor -jump-threading input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.0214821222606691,74.76235461235046,opt -inferattrs -gvn-hoist -globaldce -loop-deletion -sccp -loop-guard-widening -ipconstprop -canonicalize-aliases -coro-split -mergeicmps -insert-gcov-profiling -lower-guard-intrinsic -lower-matrix-intrinsics -adce -argpromotion -loweratomic -newgvn -strip-dead-prototypes -flattencfg -lowerinvoke -name-anon-globals -functionattrs -strip-dead-prototypes -nary-reassociate -ee-instrument -rpo-functionattrs -loop-unroll -break-crit-edges -loop-predication -dse -reassociate -sroa -instcombine -lower-widenable-condition -loop-fusion -indvars -newgvn -lower-guard-intrinsic -float2int -nary-reassociate -memcpyopt -canonicalize-aliases -inject-tli-mappings -loop-vectorize -callsite-splitting -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.021914648212226,76.11744666099548,opt -constmerge -mergereturn -early-cse-memssa -instsimplify -always-inline -libcalls-shrinkwrap -float2int -adce -simplifycfg -mldst-motion -adce -constmerge -gvn -constprop -callsite-splitting -loop-deletion -loop-simplify -coro-cleanup -infer-address-spaces -libcalls-shrinkwrap -deadargelim -memcpyopt -globalopt -speculative-execution -name-anon-globals -break-crit-edges -memcpyopt -nary-reassociate -canonicalize-aliases -loop-interchange -post-inline-ee-instrument -add-discriminators -argpromotion -indvars -gvn -dce -loop-instsimplify -libcalls-shrinkwrap -lowerinvoke -loop-reroll -lower-matrix-intrinsics -loop-deletion -aggressive-instcombine -gvn -redundant-dbg-inst-elim -globaldce -lower-widenable-condition -loop-load-elim -aggressive-instcombine -deadargelim -loop-versioning-licm -lcssa -post-inline-ee-instrument -globalsplit -sink -loop-fusion -mem2reg -irce -simple-loop-unswitch -ipsccp -coro-early -pgo-memop-opt -memcpyopt -separate-const-offset-from-gep -libcalls-shrinkwrap -nary-reassociate -rewrite-statepoints-for-gc -functionattrs -strip-debug-declare -lower-matrix-intrinsics -coro-split -instsimplify -loop-versioning -strip-nondebug -instcombine -bdce -nary-reassociate -loweratomic -loop-simplifycfg -lower-widenable-condition -hotcoldsplit -loop-unroll-and-jam -coro-elide -constprop -loop-unroll -instcombine -simplifycfg -separate-const-offset-from-gep -jump-threading -canonicalize-aliases -loop-simplifycfg -loop-sink -early-cse-memssa -prune-eh -div-rem-pairs -strip-debug-declare -memcpyopt -mergereturn -simple-loop-unswitch -lower-constant-intrinsics -die -indvars -strip-dead-prototypes -strip -lowerinvoke -loop-simplify -lower-expect -scalarizer -loweratomic -mldst-motion -lowerinvoke -loop-guard-widening -flattencfg -div-rem-pairs -forceattrs -mergefunc -newgvn input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.024617935409458,75.6703040599823,opt -reg2mem -callsite-splitting -sroa -constmerge -lower-guard-intrinsic -constprop -loop-predication -strip-nondebug -loop-unroll -adce -coro-early -scalarizer -globalopt -indvars -loweratomic -loop-simplify -mldst-motion -constprop -div-rem-pairs -loop-instsimplify -dce -partial-inliner -loop-simplify -barrier -functionattrs -gvn -speculative-execution -loop-distribute -loop-versioning-licm -lower-widenable-condition -infer-address-spaces -simple-loop-unswitch -coro-elide -speculative-execution -lower-guard-intrinsic -dce -loop-data-prefetch -instcombine -inferattrs -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.0302768166089966,115.1228277683258,opt -instnamer -loop-idiom -rewrite-statepoints-for-gc -post-inline-ee-instrument -loop-interchange -ipsccp -elim-avail-extern -ipsccp -cross-dso-cfi -name-anon-globals -tailcallelim -loop-deletion -argpromotion -reassociate -loop-simplify -lcssa -rpo-functionattrs -aggressive-instcombine -instnamer -float2int -correlated-propagation -strip-debug-declare -correlated-propagation -consthoist -prune-eh -canonicalize-aliases -loop-simplifycfg -irce -loop-data-prefetch -lower-matrix-intrinsics -called-value-propagation -add-discriminators -partially-inline-libcalls -loop-versioning-licm -strip-nondebug -jump-threading -argpromotion -inject-tli-mappings -correlated-propagation -dce -inject-tli-mappings -coro-cleanup -simplifycfg -inject-tli-mappings -mergeicmps -insert-gcov-profiling -strip-dead-prototypes -lowerinvoke -coro-elide -break-crit-edges -loop-unroll-and-jam -sccp -functionattrs -partially-inline-libcalls -mem2reg -constprop -prune-eh -loop-idiom -slsr -callsite-splitting -strip-debug-declare -redundant-dbg-inst-elim -loop-fusion -lower-matrix-intrinsics -gvn -scalarizer -rpo-functionattrs -coro-elide -loop-simplifycfg -elim-avail-extern -instcombine -add-discriminators -lower-widenable-condition -loop-reroll -break-crit-edges -loop-data-prefetch -ipsccp -load-store-vectorizer -newgvn -flattencfg -reg2mem -mem2reg -coro-cleanup -gvn-hoist -coro-elide -partial-inliner -loop-unroll -constprop -loop-distribute -gvn-hoist -sancov -instnamer -nary-reassociate -ee-instrument -loop-fusion -loop-vectorize -lower-widenable-condition -ee-instrument -correlated-propagation -gvn -loop-guard-widening -constprop -add-discriminators -barrier -infer-address-spaces -loop-reroll -sink -globalopt -ee-instrument -callsite-splitting -mergefunc -rewrite-statepoints-for-gc -loop-predication -loop-interchange -cross-dso-cfi -loop-simplifycfg -reassociate -correlated-propagation -bdce -loop-reroll -loweratomic -loop-unroll -sink -pgo-memop-opt -speculative-execution -deadargelim -irce -instnamer -instnamer -add-discriminators -lowerinvoke -sancov -guard-widening -sancov -instcombine -add-discriminators -prune-eh -cross-dso-cfi -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffdither,1.0309616493656286,74.79893708229065,opt -alignment-from-assumptions -callsite-splitting -correlated-propagation -simplifycfg -sccp -callsite-splitting -scalarizer -loop-vectorize -adce -sccp -lower-constant-intrinsics -loop-idiom -loop-unswitch -simplifycfg -partially-inline-libcalls -slsr -loop-instsimplify -pgo-memop-opt -loop-simplify -strip-dead-prototypes -instnamer -reassociate -guard-widening -rewrite-statepoints-for-gc -correlated-propagation -canonicalize-aliases -mergefunc -loweratomic -reassociate -instsimplify -pgo-memop-opt -loop-idiom -reg2mem -loop-load-elim -reg2mem -loop-deletion -post-inline-ee-instrument -scalarizer -strip-dead-prototypes -mergeicmps -loop-predication -flattencfg -loop-simplify -mldst-motion -loop-deletion -indvars -loop-load-elim -ipsccp -loop-unswitch -add-discriminators -break-crit-edges -sink -hotcoldsplit -mem2reg -globalsplit -loop-guard-widening -attributor -memcpyopt -callsite-splitting -inject-tli-mappings -loweratomic -loop-distribute -ipsccp -partially-inline-libcalls -early-cse-memssa -rewrite-statepoints-for-gc -consthoist -forceattrs -partial-inliner -coro-early -irce -float2int -libcalls-shrinkwrap -flattencfg -loop-data-prefetch -constprop -irce -instcombine -instsimplify -rewrite-statepoints-for-gc -loop-distribute -slsr -cross-dso-cfi -canonicalize-aliases -simplifycfg -inject-tli-mappings -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0072743417233017,77.22859692573547,opt -rpo-functionattrs -coro-split -loop-unroll-and-jam -mem2reg -loop-fusion -correlated-propagation -deadargelim -loop-load-elim -speculative-execution -instsimplify -mldst-motion -mergeicmps -loop-instsimplify -scalarizer -correlated-propagation -instnamer -simplifycfg -name-anon-globals -slsr -strip -strip-nondebug -post-inline-ee-instrument -inferattrs -separate-const-offset-from-gep -pgo-memop-opt -strip-dead-prototypes -argpromotion -simple-loop-unswitch -barrier -deadargelim -constprop -instcombine -loop-interchange -tailcallelim -bdce -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0072743417233019,73.91927719116211,opt -irce -elim-avail-extern -irce -called-value-propagation -slsr -inject-tli-mappings -redundant-dbg-inst-elim -scalarizer -coro-split -instsimplify -sroa -dse -rewrite-statepoints-for-gc -loop-vectorize -gvn-hoist -add-discriminators -load-store-vectorizer -sancov -irce -loop-simplify -instcombine -memcpyopt -lower-matrix-intrinsics -simple-loop-unswitch -constprop -partially-inline-libcalls -lcssa -loop-reroll -loop-load-elim -pgo-memop-opt -licm -prune-eh -rpo-functionattrs -redundant-dbg-inst-elim -attributor -nary-reassociate -lower-expect -simplifycfg -loop-sink -loop-instsimplify -instcombine -reassociate -loop-interchange -alignment-from-assumptions -loop-deletion -mem2reg -globaldce -rpo-functionattrs -loop-instsimplify -instnamer -add-discriminators -early-cse-memssa input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0106895256309552,74.7277250289917,opt -newgvn -sroa -mergefunc -strip -nary-reassociate -cross-dso-cfi -always-inline -name-anon-globals -loop-reroll -inject-tli-mappings -strip-debug-declare -coro-early -lower-guard-intrinsic -argpromotion -argpromotion -barrier -tailcallelim -callsite-splitting -div-rem-pairs -strip-nondebug -ipsccp -dce -reassociate -simplifycfg -loop-fusion -globaldce -partially-inline-libcalls -strip-debug-declare -lower-widenable-condition -elim-avail-extern -early-cse-memssa -loop-unroll-and-jam -name-anon-globals -dse -coro-cleanup -post-inline-ee-instrument -instsimplify -lower-matrix-intrinsics -cross-dso-cfi -newgvn -lower-guard-intrinsic -inject-tli-mappings -gvn -lower-matrix-intrinsics -loop-simplifycfg -loop-simplifycfg -die -coro-cleanup -name-anon-globals -tailcallelim -sink -loop-predication -hotcoldsplit -tailcallelim -ipsccp -gvn -called-value-propagation -float2int -lower-matrix-intrinsics -sink -partially-inline-libcalls -simple-loop-unswitch -loop-simplifycfg -rewrite-statepoints-for-gc -instcombine input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0140364058604556,77.69796371459961,opt -loop-unroll-and-jam -deadargelim -sancov -partially-inline-libcalls -inject-tli-mappings -loweratomic -loop-reduce -barrier -slsr -name-anon-globals -flattencfg -libcalls-shrinkwrap -pgo-memop-opt -coro-early -lower-expect -div-rem-pairs -loop-sink -loop-distribute -inject-tli-mappings -alignment-from-assumptions -globalsplit -jump-threading -instsimplify -partially-inline-libcalls -speculative-execution -loop-reduce -dse -early-cse-memssa -loop-predication -name-anon-globals -lower-expect -break-crit-edges -loop-predication -infer-address-spaces -loop-deletion -globaldce -constmerge -rewrite-statepoints-for-gc -separate-const-offset-from-gep -loweratomic -bdce -loop-distribute -alignment-from-assumptions -barrier -instsimplify -insert-gcov-profiling -strip-dead-prototypes -loop-distribute -correlated-propagation -strip-dead-prototypes -ipconstprop -attributor -post-inline-ee-instrument -sroa -flattencfg -sink -jump-threading -inject-tli-mappings -scalarizer -constprop -partially-inline-libcalls -always-inline -lower-matrix-intrinsics -slsr -attributor -indvars -loop-distribute -constmerge -gvn-hoist -slp-vectorizer -instcombine -mergereturn -insert-gcov-profiling -sink -mldst-motion -strip-dead-prototypes -ipconstprop -coro-elide -rewrite-statepoints-for-gc -redundant-dbg-inst-elim -nary-reassociate -float2int -barrier -sancov -consthoist -slp-vectorizer -correlated-propagation -lower-constant-intrinsics -lcssa -loop-data-prefetch -ipconstprop -loop-reroll -lower-expect -globalsplit -mergereturn -functionattrs -die -loop-fusion -newgvn -lower-widenable-condition -flattencfg -newgvn input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0168027048256547,74.16467475891113,opt -sroa -gvn-hoist -sroa -globaldce -hotcoldsplit -float2int -mem2reg -strip-dead-prototypes -name-anon-globals -name-anon-globals -barrier -callsite-splitting -mldst-motion -libcalls-shrinkwrap -instcombine -loop-distribute -correlated-propagation -reg2mem -lcssa -constmerge -nary-reassociate -callsite-splitting -partial-inliner -called-value-propagation -die -slsr -alignment-from-assumptions -cross-dso-cfi -dse -die -early-cse-memssa -loop-load-elim -indvars -indvars -loop-load-elim -instsimplify -loop-predication -loop-interchange -deadargelim -coro-elide -sroa -loop-vectorize -mergereturn -licm -callsite-splitting -guard-widening -infer-address-spaces -deadargelim -strip-debug-declare -globalopt -lower-matrix-intrinsics -inject-tli-mappings -jump-threading -nary-reassociate -partially-inline-libcalls -gvn input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.018066322871487,358.7716484069824,opt -loop-deletion -add-discriminators -loop-unswitch -die -callsite-splitting -strip-debug-declare -libcalls-shrinkwrap -float2int -lower-widenable-condition -argpromotion -mem2reg -newgvn -early-cse-memssa -dce -lower-matrix-intrinsics -nary-reassociate -early-cse-memssa -loop-simplifycfg -loop-deletion -instcombine -speculative-execution -pgo-memop-opt -inject-tli-mappings -loop-sink -loop-deletion -jump-threading -hotcoldsplit -globalopt -libcalls-shrinkwrap -deadargelim -callsite-splitting -lower-expect -always-inline -float2int -sroa -sccp -elim-avail-extern -early-cse-memssa -nary-reassociate input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0195007001127012,76.38189339637756,opt -lower-widenable-condition -barrier -loop-distribute -constmerge -lower-constant-intrinsics -newgvn -inferattrs -inject-tli-mappings -mldst-motion -speculative-execution -libcalls-shrinkwrap -guard-widening -hotcoldsplit -loweratomic -coro-elide -partially-inline-libcalls -break-crit-edges -attributor -mldst-motion -guard-widening -jump-threading -infer-address-spaces -hotcoldsplit -bdce -sancov -strip-dead-prototypes -coro-early -loop-idiom -name-anon-globals -lower-constant-intrinsics -loop-predication -mergefunc -irce -strip-dead-prototypes -loop-data-prefetch -reg2mem -float2int -irce -sroa -loop-data-prefetch -load-store-vectorizer -called-value-propagation -loop-versioning-licm -ipconstprop -memcpyopt -instcombine -libcalls-shrinkwrap -loop-simplify -sancov -always-inline -coro-split -lower-constant-intrinsics -strip -loop-reroll -strip -loop-interchange -loop-interchange -die -lower-constant-intrinsics -callsite-splitting -cross-dso-cfi -separate-const-offset-from-gep -redundant-dbg-inst-elim -strip-nondebug -sink -inject-tli-mappings -simplifycfg -inferattrs -loop-vectorize -mergereturn -loop-fusion -mergereturn -load-store-vectorizer -speculative-execution -early-cse-memssa -hotcoldsplit -always-inline -mergefunc -coro-early -mldst-motion -loop-unroll -sroa -loop-simplifycfg -sroa -slp-vectorizer -loop-distribute -lower-guard-intrinsic -strip-debug-declare -loop-vectorize -rewrite-statepoints-for-gc -loop-reroll -strip-dead-prototypes -hotcoldsplit -lcssa -alignment-from-assumptions -loweratomic -loop-reroll -correlated-propagation -loop-deletion -loop-load-elim -prune-eh -rewrite-statepoints-for-gc -guard-widening -loop-unroll -loop-idiom -bdce -called-value-propagation -consthoist -simplifycfg -deadargelim -instsimplify input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0216864178135994,76.33752155303955,opt -elim-avail-extern -bdce -speculative-execution -bdce -consthoist -elim-avail-extern -loop-predication -coro-cleanup -globalsplit -inject-tli-mappings -loop-versioning-licm -mergeicmps -callsite-splitting -rewrite-statepoints-for-gc -jump-threading -loweratomic -sancov -dse -loop-sink -mem2reg -instcombine -hotcoldsplit -gvn -forceattrs -post-inline-ee-instrument -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.025579727468324,74.7141592502594,opt -lower-guard-intrinsic -lower-guard-intrinsic -sancov -sink -callsite-splitting -loop-simplifycfg -guard-widening -libcalls-shrinkwrap -loop-reroll -ee-instrument -prune-eh -argpromotion -loop-reduce -argpromotion -loop-simplifycfg -loop-unroll-and-jam -loop-versioning-licm -float2int -scalarizer -infer-address-spaces -simple-loop-unswitch -deadargelim -loop-idiom -loop-reroll -lower-expect -lower-expect -mergeicmps -mergefunc -coro-cleanup -canonicalize-aliases -scalarizer -gvn-hoist -redundant-dbg-inst-elim -add-discriminators -deadargelim -post-inline-ee-instrument -indvars -name-anon-globals -mem2reg -loop-simplifycfg -speculative-execution -separate-const-offset-from-gep -lowerinvoke -float2int -load-store-vectorizer -consthoist -strip -always-inline -slp-vectorizer -correlated-propagation -slsr -coro-early -callsite-splitting -lower-guard-intrinsic -lower-widenable-condition -redundant-dbg-inst-elim -globalsplit -loop-distribute -loop-deletion -rewrite-statepoints-for-gc -instnamer -licm -loop-distribute -instcombine -simplifycfg -mldst-motion -guard-widening -loop-instsimplify -simplifycfg -newgvn -reassociate input.bc -o output.bc +benchmark://cbench-v1/tiffmedian,1.0331955875823913,76.41833972930908,opt -separate-const-offset-from-gep -coro-cleanup -die -coro-cleanup -called-value-propagation -adce -cross-dso-cfi -inject-tli-mappings -rpo-functionattrs -add-discriminators -lower-matrix-intrinsics -simplifycfg -simple-loop-unswitch -memcpyopt -instnamer -attributor -scalarizer -adce -loop-unroll-and-jam -post-inline-ee-instrument -reg2mem -flattencfg -lower-expect -loop-load-elim -strip-dead-prototypes -mergefunc -tailcallelim -barrier -inject-tli-mappings -loop-unroll -canonicalize-aliases -loop-distribute -loop-unswitch -slsr -partial-inliner -name-anon-globals -loop-interchange -lcssa -slsr -nary-reassociate -lower-constant-intrinsics -sink -loop-versioning-licm -coro-early -loop-instsimplify -pgo-memop-opt -post-inline-ee-instrument -tailcallelim -loop-distribute -loop-fusion -loop-reduce -loop-versioning -sancov -partially-inline-libcalls -instsimplify -early-cse-memssa -early-cse-memssa -coro-early -hotcoldsplit -early-cse-memssa -loop-simplify -memcpyopt -irce -mem2reg -guard-widening -canonicalize-aliases -attributor -cross-dso-cfi -attributor -globalsplit -functionattrs -strip-nondebug -instsimplify -loop-interchange -loop-predication -instcombine -gvn-hoist -globaldce -slsr -always-inline -lcssa -dce -mldst-motion -instsimplify -simple-loop-unswitch -mergefunc -lower-constant-intrinsics -newgvn -prune-eh -mergefunc -lcssa -cross-dso-cfi -loop-unroll -hotcoldsplit -loop-vectorize -loop-guard-widening -insert-gcov-profiling -name-anon-globals -early-cse-memssa -strip -loweratomic -simplifycfg -jump-threading input.bc -o output.bc diff --git a/setup.py b/setup.py index e483e1699..d361a6a57 100644 --- a/setup.py +++ b/setup.py @@ -54,6 +54,8 @@ def get_tag(self): "compiler_gym.envs.llvm.service.passes", "compiler_gym.envs.llvm.service", "compiler_gym.envs.llvm", + "compiler_gym.envs.llvm", + "compiler_gym.envs", "compiler_gym.envs", "compiler_gym.leaderboard", "compiler_gym.service.proto", @@ -73,13 +75,12 @@ def get_tag(self): }, package_data={ "compiler_gym": [ - "envs/llvm/service/passes/*.txt", "envs/llvm/service/compiler_gym-llvm-service", "envs/llvm/service/libLLVMPolly.so", + "envs/llvm/service/passes/*.txt", + "third_party/cbench/benchmarks.txt", + "third_party/cbench/cbench-v*/*", "third_party/inst2vec/*.pickle", - "third_party/cBench/benchmarks.txt", - "third_party/cBench/cBench-v*/*", - "third_party/cBench/runtime_data/**/*", ] }, install_requires=requirements, diff --git a/tests/BUILD b/tests/BUILD index 42eaaa56c..e5122cfc2 100644 --- a/tests/BUILD +++ b/tests/BUILD @@ -34,6 +34,7 @@ py_test( "//compiler_gym:random_replay", "//compiler_gym:random_search", "//tests:test_main", + "//tests/pytest_plugins:common", ], ) @@ -48,7 +49,6 @@ py_library( "//tests:__subpackages__", ], deps = [ - "//compiler_gym", "//compiler_gym/util", ], ) diff --git a/tests/bin/BUILD b/tests/bin/BUILD index 8b785896b..55d053379 100644 --- a/tests/bin/BUILD +++ b/tests/bin/BUILD @@ -18,11 +18,11 @@ py_test( name = "manual_env_bin_test", timeout = "short", srcs = ["manual_env_bin_test.py"], + flaky = 1, deps = [ "//compiler_gym/bin:manual_env", "//compiler_gym/util", "//tests:test_main", - "//tests/pytest_plugins:llvm", ], ) @@ -40,6 +40,7 @@ py_test( name = "validate_bin_test", timeout = "long", srcs = ["validate_bin_test.py"], + shard_count = 4, deps = [ "//compiler_gym", "//compiler_gym/bin:validate", diff --git a/tests/bin/datasets_bin_test.py b/tests/bin/datasets_bin_test.py index 6cc81c0bc..33d6cab8a 100644 --- a/tests/bin/datasets_bin_test.py +++ b/tests/bin/datasets_bin_test.py @@ -6,6 +6,7 @@ import pytest from compiler_gym.bin.datasets import main +from compiler_gym.util.capture_output import capture_output from tests.pytest_plugins.common import set_command_line_flags from tests.test_main import main as _test_main @@ -15,11 +16,18 @@ def run_main(*args): return main(["argv0"]) -def test_llvm_download_invalid_protocol(): - invalid_url = "invalid://facebook.com" - with pytest.raises(OSError) as ctx: - run_main("--env=llvm-v0", "--download", invalid_url) - assert invalid_url in str(ctx.value) +def test_llvm_summary(): + with capture_output() as out: + run_main("--env=llvm-v0") + + assert "cbench-v1" in out.stdout + + +def test_datasets_is_deprecated(): + with pytest.deprecated_call( + match="Command-line management of datasets is deprecated" + ): + run_main("--env=llvm-v0") if __name__ == "__main__": diff --git a/tests/bin/manual_env_bin_test.py b/tests/bin/manual_env_bin_test.py index 893fad1a2..a96a7dfec 100644 --- a/tests/bin/manual_env_bin_test.py +++ b/tests/bin/manual_env_bin_test.py @@ -18,8 +18,6 @@ FLAGS = flags.FLAGS -pytest_plugins = ["tests.pytest_plugins.llvm"] - def io_check(input, output, rnd_seed=100): """Run the shell with the given input and check the output matches the @@ -46,7 +44,7 @@ def io_check(input, output, rnd_seed=100): + output + r""" -compilergym:[a-zA-Z0-9/-]+> Exiting +compiler_gym:[a-zA-Z0-9/-]+> Exiting """ ) @@ -73,92 +71,71 @@ def io_check(input, output, rnd_seed=100): sys.stdin = old_stdin -def test_download_cBench(cBench_dataset): - del cBench_dataset # unused +def test_list_datasets(): io_check( - """require_dataset cBench-v1""", - # FIXME(cummins): Prompt should be compilergym:NO-BENCHMARK, but I've - # seen compilergym:cBench-v1/crc32 instead. Not sure why. - r"""compilergym:.+> Downloaded dataset cBench-v[0-9]+ in [0-9.mu]*s""", + """list_datasets""", r"""compiler_gym:cbench-v1/qsort> .*cbench-v[0-9]+.*""" ) -def test_list_datasets(cBench_dataset): - del cBench_dataset # unused - # FIXME(cummins): Prompt should be compilergym:NO-BENCHMARK, but I've - # seen compilergym:cBench-v1/crc32 instead. Not sure why. - io_check("""list_datasets""", r"""compilergym:.+> .*cBench-v[0-9]+.*""") - - -def test_list_benchmarks(cBench_dataset): - del cBench_dataset # unused - # FIXME(cummins): Prompt should be compilergym:NO-BENCHMARK, but I've - # seen compilergym:cBench-v1/crc32 instead. Not sure why. - io_check("""list_benchmarks""", r"""compilergym:.+> .*cBench-v[0-9]+/adpcm.*""") +def test_list_benchmarks(): + io_check( + """list_benchmarks""", + r"""compiler_gym:cbench-v1/qsort> .*cbench-v[0-9]+/adpcm.*""", + ) def test_list_actions(): - # FIXME(cummins): Prompt should be compilergym:NO-BENCHMARK, but I've - # seen compilergym:cBench-v1/crc32 instead. Not sure why. - io_check("""list_actions""", r"""compilergym:.+> .*-adce.* -strip.*""") + io_check( + """list_actions""", r"""compiler_gym:cbench-v1/qsort> .*-adce.* -strip.*""" + ) def test_list_rewards(): - # FIXME(cummins): Prompt should be compilergym:NO-BENCHMARK, but I've - # seen compilergym:cBench-v1/crc32 instead. Not sure why. io_check( """list_rewards""", - r"""compilergym:.+> .*IrInstructionCount.* ObjectTextSizeOz.*""", + r"""compiler_gym:cbench-v1/qsort> .*IrInstructionCount.* ObjectTextSizeOz.*""", ) def test_list_observations(): - # FIXME(cummins): Prompt should be compilergym:NO-BENCHMARK, but I've - # seen compilergym:cBench-v1/crc32 instead. Not sure why. io_check( """list_observations""", - r"""compilergym:.+> Autophase, .*, Programl""", + r"""compiler_gym:cbench-v1/qsort> Autophase, .*, Programl""", ) -def test_set_benchmark(cBench_dataset): - del cBench_dataset # unused - # FIXME(cummins): Prompt should be compilergym:NO-BENCHMARK, but I've - # seen compilergym:cBench-v1/crc32 instead. Not sure why. +def test_set_benchmark(): io_check( - """set_benchmark cBench-v1/adpcm""", - r"""compilergym:.+> Reset benchmark://cBench-v[0-9]+/adpcm environment in [0-9.mu]*s""", + """set_benchmark cbench-v1/adpcm""", + r"""compiler_gym:cbench-v1/qsort> Reset benchmark://cbench-v[0-9]+/adpcm environment in [0-9.mu]*s""", ) -def test_actions_stack_back_stack(cBench_dataset): - del cBench_dataset # unused - # FIXME(cummins): Prompt should be compilergym:NO-BENCHMARK, but I've - # seen compilergym:cBench-v1/crc32 instead. Not sure why. +def test_actions_stack_back_stack(): io_check( - """set_benchmark cBench-v1/adpcm + """set_benchmark cbench-v1/adpcm action -mem2reg -adce -adce stack back stack""", - r"""compilergym:.+> Reset benchmark://cBench-v[0-9]+/adpcm environment in [0-9.mu]*s + r"""compiler_gym:cbench-v1/qsort> Reset benchmark://cbench-v[0-9]+/adpcm environment in [0-9.mu]*s -compilergym:cBench-v[0-9]+/adpcm> Action -mem2reg +compiler_gym:cbench-v[0-9]+/adpcm> Action -mem2reg Action -adce Action -adce No effect Actions -mem2reg -adce -adce in [0-9.mu]*s with reward 0. -compilergym:cBench-v[0-9]+/adpcm> Depth | Action | Effect | Done | Reward | Cumulative Reward +compiler_gym:cbench-v[0-9]+/adpcm> Depth | Action | Effect | Done | Reward | Cumulative Reward ---------+----------+----------+--------+----------+--------------------- 3 | -adce | False | False | - | 0 2 | -adce | True | False | - | 0 1 | -mem2reg | True | False | - | 0 0 | | False | False | 0 | 0 -compilergym:cBench-v[0-9]+/adpcm> Undid -adce in [0-9.mu]*s +compiler_gym:cbench-v[0-9]+/adpcm> Undid -adce in [0-9.mu]*s -compilergym:cBench-v[0-9]+/adpcm> Depth | Action | Effect | Done | Reward | Cumulative Reward +compiler_gym:cbench-v[0-9]+/adpcm> Depth | Action | Effect | Done | Reward | Cumulative Reward ---------+----------+----------+--------+----------+--------------------- 2 | -adce | True | False | - | 0 1 | -mem2reg | True | False | - | 0 @@ -166,32 +143,29 @@ def test_actions_stack_back_stack(cBench_dataset): ) -def test_reward(cBench_dataset): - del cBench_dataset # unused +def test_reward(): io_check( - """set_benchmark cBench-v1/adpcm + """set_benchmark cbench-v1/adpcm set_default_reward IrInstructionCount action -mem2reg reward reward IrInstructionCountNorm stack""", - # FIXME(cummins): Prompt should be compilergym:NO-BENCHMARK, but I've - # seen compilergym:cBench-v1/crc32 instead. Not sure why. - r"""compilergym:.+> Reset benchmark://cBench-v[0-9]+/adpcm environment in [0-9.mu]*s + r"""compiler_gym:cbench-v1/qsort> Reset benchmark://cbench-v[0-9]+/adpcm environment in [0-9.mu]*s -compilergym:cBench-v[0-9]+/adpcm> Reward IrInstructionCount in [0-9.mu]*s +compiler_gym:cbench-v[0-9]+/adpcm> Reward IrInstructionCount in [0-9.mu]*s -compilergym:cBench-v[0-9]+/adpcm> Action -mem2reg +compiler_gym:cbench-v[0-9]+/adpcm> Action -mem2reg Reward: 287.000000 Actions -mem2reg in [0-9.mu]*s with reward 287.0. -compilergym:cBench-v[0-9]+/adpcm> 0.000000 +compiler_gym:cbench-v[0-9]+/adpcm> 0.000000 Reward IrInstructionCount in [0-9.mu]*s -compilergym:cBench-v[0-9]+/adpcm> 0.506173 +compiler_gym:cbench-v[0-9]+/adpcm> 0.506173 Reward IrInstructionCountNorm in [0-9.mu]*s -compilergym:cBench-v[0-9]+/adpcm> Depth | Action | Effect | Done | Reward | Cumulative Reward +compiler_gym:cbench-v[0-9]+/adpcm> Depth | Action | Effect | Done | Reward | Cumulative Reward ---------+----------+----------+--------+----------+--------------------- 1 | -mem2reg | True | False | 287 | 287 0 | | False | False | 0 | 0 @@ -199,49 +173,43 @@ def test_reward(cBench_dataset): ) -def test_observation(cBench_dataset): - del cBench_dataset # unused +def test_observation(): io_check( - """set_benchmark cBench-v1/adpcm + """set_benchmark cbench-v1/adpcm set_default_observation IrInstructionCount action -mem2reg observation observation IrInstructionCountOz """, - # FIXME(cummins): Prompt should be compilergym:NO-BENCHMARK, but I've - # seen compilergym:cBench-v1/crc32 instead. Not sure why. - r"""compilergym:.+> Reset benchmark://cBench-v[0-9]+/adpcm environment in [0-9.mu]*s + r"""compiler_gym:cbench-v1/qsort> Reset benchmark://cbench-v[0-9]+/adpcm environment in [0-9.mu]*s -compilergym:cBench-v[0-9]+/adpcm> Observation IrInstructionCount in [0-9.mu]*s +compiler_gym:cbench-v[0-9]+/adpcm> Observation IrInstructionCount in [0-9.mu]*s -compilergym:cBench-v[0-9]+/adpcm> Action -mem2reg +compiler_gym:cbench-v[0-9]+/adpcm> Action -mem2reg Observation: 280 Actions -mem2reg in [0-9.mu]*s with reward 0. -compilergym:cBench-v[0-9]+/adpcm> 280 +compiler_gym:cbench-v[0-9]+/adpcm> 280 Observation IrInstructionCount in [0-9.mu]*s -compilergym:cBench-v[0-9]+/adpcm> 209 +compiler_gym:cbench-v[0-9]+/adpcm> 209 Observation IrInstructionCountOz in [0-9.mu]*s -compilergym:cBench-v[0-9]+/adpcm> 209 +compiler_gym:cbench-v[0-9]+/adpcm> 209 Observation IrInstructionCountOz in [0-9.mu]*s""", ) -def test_try_all_actions(cBench_dataset): - del cBench_dataset # unused +def test_try_all_actions(): io_check( - """set_benchmark cBench-v1/adpcm + """set_benchmark cbench-v1/adpcm set_default_reward IrInstructionCount try_all_actions""", - # FIXME(cummins): Prompt should be compilergym:NO-BENCHMARK, but I've - # seen compilergym:cBench-v1/crc32 instead. Not sure why. - r"""compilergym:.+> Reset benchmark://cBench-v[0-9]+/adpcm environment in [0-9.mu]*s + r"""compiler_gym:cbench-v1/qsort> Reset benchmark://cbench-v[0-9]+/adpcm environment in [0-9.mu]*s -compilergym:cBench-v[0-9]+/adpcm> Reward IrInstructionCount in [0-9.mu]*s +compiler_gym:cbench-v[0-9]+/adpcm> Reward IrInstructionCount in [0-9.mu]*s -compilergym:cBench-v[0-9]+/adpcm> Action: -add-discriminators Reward: 0.000000 +compiler_gym:cbench-v[0-9]+/adpcm> Action: -add-discriminators Reward: 0.000000 Action: -adce Reward: 1.000000 (.|\n)* Got actions in [0-9.mu]*s @@ -257,21 +225,18 @@ def test_try_all_actions(cBench_dataset): ) -def test_simplify_stack(cBench_dataset): - del cBench_dataset # unused +def test_simplify_stack(): io_check( - """set_benchmark cBench-v1/adpcm + """set_benchmark cbench-v1/adpcm set_default_reward IrInstructionCount action -mem2reg -adce -adce simplify_stack stack""", - # FIXME(cummins): Prompt should be compilergym:NO-BENCHMARK, but I've - # seen compilergym:cBench-v1/crc32 instead. Not sure why. - r"""compilergym:.+> Reset benchmark://cBench-v[0-9]+/adpcm environment in [0-9.mu]*s + r"""compiler_gym:cbench-v1/qsort> Reset benchmark://cbench-v[0-9]+/adpcm environment in [0-9.mu]*s -compilergym:cBench-v[0-9]+/adpcm> Reward IrInstructionCount in [0-9.mu]*s +compiler_gym:cbench-v[0-9]+/adpcm> Reward IrInstructionCount in [0-9.mu]*s -compilergym:cBench-v[0-9]+/adpcm> Action -mem2reg +compiler_gym:cbench-v[0-9]+/adpcm> Action -mem2reg Reward: 287.000000 Action -adce Reward: 2.000000 @@ -280,8 +245,8 @@ def test_simplify_stack(cBench_dataset): No effect Actions -mem2reg -adce -adce in [0-9.mu]*s with reward 289.0. -compilergym:cBench-v[0-9]+/adpcm> -compilergym:cBench-v[0-9]+/adpcm> Depth | Action | Effect | Done | Reward | Cumulative Reward +compiler_gym:cbench-v[0-9]+/adpcm> +compiler_gym:cbench-v[0-9]+/adpcm> Depth | Action | Effect | Done | Reward | Cumulative Reward ---------+----------+----------+--------+----------+--------------------- 2 | -adce | True | False | 2 | 289 1 | -mem2reg | True | False | 287 | 287 @@ -289,25 +254,22 @@ def test_simplify_stack(cBench_dataset): ) -def test_simplify_stack_no_reward(cBench_dataset): - del cBench_dataset # unused +def test_simplify_stack_no_reward(): io_check( - """set_benchmark cBench-v1/adpcm + """set_benchmark cbench-v1/adpcm action -mem2reg -adce -adce simplify_stack stack""", - # FIXME(cummins): Prompt should be compilergym:NO-BENCHMARK, but I've - # seen compilergym:cBench-v1/crc32 instead. Not sure why. - r"""compilergym:.+> Reset benchmark://cBench-v[0-9]+/adpcm environment in [0-9.mu]*s + r"""compiler_gym:cbench-v1/qsort> Reset benchmark://cbench-v[0-9]+/adpcm environment in [0-9.mu]*s -compilergym:cBench-v[0-9]+/adpcm> Action -mem2reg +compiler_gym:cbench-v[0-9]+/adpcm> Action -mem2reg Action -adce Action -adce No effect Actions -mem2reg -adce -adce in [0-9.mu]*s with reward 0. -compilergym:cBench-v[0-9]+/adpcm> -compilergym:cBench-v[0-9]+/adpcm> Depth | Action | Effect | Done | Reward | Cumulative Reward +compiler_gym:cbench-v[0-9]+/adpcm> +compiler_gym:cbench-v[0-9]+/adpcm> Depth | Action | Effect | Done | Reward | Cumulative Reward ---------+----------+----------+--------+----------+--------------------- 2 | -adce | True | False | - | 0 1 | -mem2reg | True | False | - | 0 @@ -315,8 +277,7 @@ def test_simplify_stack_no_reward(cBench_dataset): ) -def test_hill_climb(monkeypatch, cBench_dataset): - del cBench_dataset # unused +def test_hill_climb(monkeypatch): i = 0 def incr(): @@ -327,41 +288,36 @@ def incr(): monkeypatch.setattr("random.randrange", lambda _: incr()) io_check( - """set_benchmark cBench-v1/adpcm + """set_benchmark cbench-v1/adpcm set_default_reward IrInstructionCount hill_climb 2 stack""", - # FIXME(cummins): Prompt should be compilergym:NO-BENCHMARK, but I've - # seen compilergym:cBench-v1/crc32 instead. Not sure why. - r"""compilergym:.+> Reset benchmark://cBench-v[0-9]+/adpcm environment in [0-9.mu]*s + r"""compiler_gym:cbench-v1/qsort> Reset benchmark://cbench-v[0-9]+/adpcm environment in [0-9.mu]*s -compilergym:cBench-v[0-9]+/adpcm> Reward IrInstructionCount in [0-9.mu]*s +compiler_gym:cbench-v[0-9]+/adpcm> Reward IrInstructionCount in [0-9.mu]*s -compilergym:cBench-v[0-9]+/adpcm> Step: 1 Action: -adce Reward: 1.000000 Accept: True +compiler_gym:cbench-v[0-9]+/adpcm> Step: 1 Action: -adce Reward: 1.000000 Accept: True Step: 2 Action: -aggressive-instcombine Reward: 0.000000 Accept: False Hill climb complete in [0-9.mu]*s. Accepted 1 of 2 steps for total reward of 1.0. -compilergym:cBench-v[0-9]+/adpcm> Depth | Action | Effect | Done | Reward | Cumulative Reward +compiler_gym:cbench-v[0-9]+/adpcm> Depth | Action | Effect | Done | Reward | Cumulative Reward ---------+----------+----------+--------+----------+--------------------- 1 | -adce | True | False | 1 | 1 0 | | False | False | 0 | 0""", ) -def test_greedy(cBench_dataset): - del cBench_dataset # unused +def test_greedy(): io_check( - """set_benchmark cBench-v1/adpcm + """set_benchmark cbench-v1/adpcm set_default_reward IrInstructionCount greedy stack""", - # FIXME(cummins): Prompt should be compilergym:NO-BENCHMARK, but I've - # seen compilergym:cBench-v1/crc32 instead. Not sure why. - r"""compilergym:.+> Reset benchmark://cBench-v[0-9]+/adpcm environment in [0-9.mu]*s + r"""compiler_gym:cbench-v1/qsort> Reset benchmark://cbench-v[0-9]+/adpcm environment in [0-9.mu]*s -compilergym:cBench-v[0-9]+/adpcm> Reward IrInstructionCount in [0-9.mu]*s +compiler_gym:cbench-v[0-9]+/adpcm> Reward IrInstructionCount in [0-9.mu]*s -compilergym:cBench-v[0-9]+/adpcm> Action: -add-discriminators Reward: 0.000000 +compiler_gym:cbench-v[0-9]+/adpcm> Action: -add-discriminators Reward: 0.000000 Action: -adce Reward: 1.000000 (.|\n)* Action: -mem2reg Reward: 287.000000 @@ -370,49 +326,43 @@ def test_greedy(cBench_dataset): Step: 1 Selected action: -mem2reg Reward: 287.000000 Greedy 1 steps in [0-9.mu]*s -compilergym:cBench-v[0-9]+/adpcm> Depth | Action | Effect | Done | Reward | Cumulative Reward +compiler_gym:cbench-v[0-9]+/adpcm> Depth | Action | Effect | Done | Reward | Cumulative Reward ---------+----------+----------+--------+----------+--------------------- 1 | -mem2reg | True | False | 181 | 181 0 | | False | False | 0 | 0""", ) -def test_commandline(cBench_dataset): - del cBench_dataset # unused +def test_commandline(): io_check( - """set_benchmark cBench-v1/adpcm + """set_benchmark cbench-v1/adpcm action -mem2reg -adce commandline""", - # FIXME(cummins): Prompt should be compilergym:NO-BENCHMARK, but I've - # seen compilergym:cBench-v1/crc32 instead. Not sure why. - r"""compilergym:.+> Reset benchmark://cBench-v[0-9]+/adpcm environment in [0-9.mu]*s + r"""compiler_gym:cbench-v1/qsort> Reset benchmark://cbench-v[0-9]+/adpcm environment in [0-9.mu]*s -compilergym:cBench-v[0-9]+/adpcm> Action -mem2reg +compiler_gym:cbench-v[0-9]+/adpcm> Action -mem2reg Action -adce Actions -mem2reg -adce in [0-9.mu]*s with reward 0. -compilergym:cBench-v[0-9]+/adpcm> \$ opt -mem2reg -adce input.bc -o output.bc""", +compiler_gym:cbench-v[0-9]+/adpcm> \$ opt -mem2reg -adce input.bc -o output.bc""", ) -def test_reset(cBench_dataset): - del cBench_dataset # unused +def test_reset(): io_check( - """set_benchmark cBench-v1/adpcm + """set_benchmark cbench-v1/adpcm action -mem2reg -adce reset stack""", - # FIXME(cummins): Prompt should be compilergym:NO-BENCHMARK, but I've - # seen compilergym:cBench-v1/crc32 instead. Not sure why. - r"""compilergym:.+> Reset benchmark://cBench-v[0-9]+/adpcm environment in [0-9.mu]*s + r"""compiler_gym:cbench-v1/qsort> Reset benchmark://cbench-v[0-9]+/adpcm environment in [0-9.mu]*s -compilergym:cBench-v[0-9]+/adpcm> Action -mem2reg +compiler_gym:cbench-v[0-9]+/adpcm> Action -mem2reg Action -adce Actions -mem2reg -adce in [0-9.mu]*s with reward 0. -compilergym:cBench-v[0-9]+/adpcm> Reset in [0-9.mu]*s +compiler_gym:cbench-v[0-9]+/adpcm> Reset in [0-9.mu]*s -compilergym:cBench-v[0-9]+/adpcm> Depth | Action | Effect | Done | Reward | Cumulative Reward +compiler_gym:cbench-v[0-9]+/adpcm> Depth | Action | Effect | Done | Reward | Cumulative Reward ---------+----------+----------+--------+----------+--------------------- 0 | | False | False | 0 | 0""", ) diff --git a/tests/bin/validate_bin_test.py b/tests/bin/validate_bin_test.py index d4566c1df..f4c1fa815 100644 --- a/tests/bin/validate_bin_test.py +++ b/tests/bin/validate_bin_test.py @@ -6,6 +6,7 @@ import tempfile from io import StringIO from pathlib import Path +from typing import List import pytest @@ -18,7 +19,7 @@ def test_okay_llvm_result(monkeypatch): stdin = """ benchmark,reward,commandline,walltime -benchmark://cBench-v1/crc32,0,opt input.bc -o output.bc,0.3 +benchmark://cbench-v1/crc32,0,opt input.bc -o output.bc,0.3 """.strip() set_command_line_flags(["argv0", "--env=llvm-ic-v0"]) monkeypatch.setattr("sys.stdin", StringIO(stdin)) @@ -26,7 +27,7 @@ def test_okay_llvm_result(monkeypatch): with capture_output() as out: main(["argv0", "-"]) - assert "✅ cBench-v1/crc32 " in out.stdout + assert "✅ cbench-v1/crc32 " in out.stdout assert not out.stderr @@ -37,7 +38,7 @@ def test_okay_llvm_result_file_input(): f.write( """ benchmark,reward,commandline,walltime -benchmark://cBench-v1/crc32,0,opt input.bc -o output.bc,0.3 +benchmark://cbench-v1/crc32,0,opt input.bc -o output.bc,0.3 """.strip() ) set_command_line_flags(["argv0", "--env=llvm-ic-v0"]) @@ -45,7 +46,7 @@ def test_okay_llvm_result_file_input(): with capture_output() as out: main(["argv0", str(path)]) - assert "✅ cBench-v1/crc32 " in out.stdout + assert "✅ cbench-v1/crc32 " in out.stdout assert not out.stderr @@ -63,7 +64,7 @@ def test_no_input(monkeypatch): def test_invalid_reward_llvm_result(monkeypatch): stdin = """ benchmark,reward,commandline,walltime -benchmark://cBench-v1/crc32,0.5,opt input.bc -o output.bc,0.3 +benchmark://cbench-v1/crc32,0.5,opt input.bc -o output.bc,0.3 """.strip() set_command_line_flags(["argv0", "--env=llvm-ic-v0"]) monkeypatch.setattr("sys.stdin", StringIO(stdin)) @@ -72,7 +73,7 @@ def test_invalid_reward_llvm_result(monkeypatch): main(["argv0", "-"]) assert ( - "❌ cBench-v1/crc32 Expected reward 0.5 but received reward 0.0\n" + "❌ cbench-v1/crc32 Expected reward 0.5 but received reward 0.0\n" in out.stdout ) assert not out.stderr @@ -94,9 +95,9 @@ def test_invalid_csv_format(monkeypatch): def test_multiple_valid_inputs(monkeypatch): stdin = """ benchmark,reward,walltime,commandline -benchmark://cBench-v1/crc32,,0,opt input.bc -o output.bc -benchmark://cBench-v1/crc32,,0,opt input.bc -o output.bc -benchmark://cBench-v1/crc32,,0,opt input.bc -o output.bc +benchmark://cbench-v1/crc32,,0,opt input.bc -o output.bc +benchmark://cbench-v1/crc32,,0,opt input.bc -o output.bc +benchmark://cbench-v1/crc32,,0,opt input.bc -o output.bc """.strip() set_command_line_flags(["argv0", "--env=llvm-v0"]) monkeypatch.setattr("sys.stdin", StringIO(stdin)) @@ -109,41 +110,60 @@ def test_multiple_valid_inputs(monkeypatch): @skip_on_ci -def test_validate_cBench_null_options(monkeypatch): - stdin = """ -benchmark,reward,walltime,commandline -benchmark://cBench-v1/gsm,,0,opt input.bc -o output.bc -benchmark://cBench-v1/lame,,0,opt input.bc -o output.bc -benchmark://cBench-v1/stringsearch,,0,opt input.bc -o output.bc -benchmark://cBench-v1/ghostscript,,0,opt input.bc -o output.bc -benchmark://cBench-v1/qsort,,0,opt input.bc -o output.bc -benchmark://cBench-v1/sha,,0,opt input.bc -o output.bc -benchmark://cBench-v1/ispell,,0,opt input.bc -o output.bc -benchmark://cBench-v1/blowfish,,0,opt input.bc -o output.bc -benchmark://cBench-v1/adpcm,,0,opt input.bc -o output.bc -benchmark://cBench-v1/tiffdither,,0,opt input.bc -o output.bc -benchmark://cBench-v1/bzip2,,0,opt input.bc -o output.bc -benchmark://cBench-v1/stringsearch2,,0,opt input.bc -o output.bc -benchmark://cBench-v1/bitcount,,0,opt input.bc -o output.bc -benchmark://cBench-v1/jpeg-d,,0,opt input.bc -o output.bc -benchmark://cBench-v1/jpeg-c,,0,opt input.bc -o output.bc -benchmark://cBench-v1/dijkstra,,0,opt input.bc -o output.bc -benchmark://cBench-v1/rijndael,,0,opt input.bc -o output.bc -benchmark://cBench-v1/patricia,,0,opt input.bc -o output.bc -benchmark://cBench-v1/tiff2rgba,,0,opt input.bc -o output.bc -benchmark://cBench-v1/crc32,,0,opt input.bc -o output.bc -benchmark://cBench-v1/tiff2bw,,0,opt input.bc -o output.bc -benchmark://cBench-v1/tiffmedian,,0,opt input.bc -o output.bc -benchmark://cBench-v1/susan,,0,opt input.bc -o output.bc -""".strip() +@pytest.mark.parametrize( + "benchmarks", + [ + [ + "benchmark://cbench-v1/gsm", + "benchmark://cbench-v1/lame", + "benchmark://cbench-v1/stringsearch", + "benchmark://cbench-v1/ghostscript", + ], + [ + "benchmark://cbench-v1/qsort", + "benchmark://cbench-v1/sha", + "benchmark://cbench-v1/ispell", + "benchmark://cbench-v1/blowfish", + ], + [ + "benchmark://cbench-v1/adpcm", + "benchmark://cbench-v1/tiffdither", + "benchmark://cbench-v1/bzip2", + "benchmark://cbench-v1/stringsearch2", + ], + [ + "benchmark://cbench-v1/bitcount", + "benchmark://cbench-v1/jpeg-d", + "benchmark://cbench-v1/jpeg-c", + "benchmark://cbench-v1/dijkstra", + ], + [ + "benchmark://cbench-v1/rijndael", + "benchmark://cbench-v1/patricia", + "benchmark://cbench-v1/tiff2rgba", + "benchmark://cbench-v1/crc32", + ], + [ + "benchmark://cbench-v1/tiff2bw", + "benchmark://cbench-v1/tiffmedian", + "benchmark://cbench-v1/susan", + ], + ], +) +def test_validate_cbench_null_options(monkeypatch, benchmarks: List[str]): + stdin = "\n".join( + [ + "benchmark,reward,walltime,commandline", + ] + + [f"{b},,0,opt input.bc -o output.bc" for b in benchmarks] + ) set_command_line_flags(["argv0", "--env=llvm-v0"]) monkeypatch.setattr("sys.stdin", StringIO(stdin)) - with capture_output() as out: main(["argv0", "-"]) assert not out.stderr - assert out.stdout.count("✅") == 23 # Every benchmark passed. + assert out.stdout.count("✅") == len(benchmarks) # Every benchmark passed. if __name__ == "__main__": diff --git a/tests/compiler_env_test.py b/tests/compiler_env_test.py index c84477f51..d663c9971 100644 --- a/tests/compiler_env_test.py +++ b/tests/compiler_env_test.py @@ -4,70 +4,39 @@ # LICENSE file in the root directory of this source tree. """Unit tests for //compiler_gym/envs.""" import logging -import sys import gym import pytest -from compiler_gym.datasets import LegacyDataset -from compiler_gym.envs import CompilerEnv +from compiler_gym.envs import CompilerEnv, llvm +from compiler_gym.service.connection import CompilerGymServiceConnection from tests.test_main import main pytest_plugins = ["tests.pytest_plugins.llvm"] -def make_dataset(**kwargs) -> LegacyDataset: - default_kwargs = { - "name": "test-dataset-v0", - "url": "https://dl.fbaipublicfiles.com/compiler_gym/llvm_bitcodes-10.0.0-blas-v0.tar.bz2", - "license": "MIT", - "description": "A test dataset", - "compiler": "llvm-10.0.0", - "file_count": 10, - "size_bytes": 2, - "sha256": "e724a8114709f8480adeb9873d48e426e8d9444b00cddce48e342b9f0f2b096d", - } - default_kwargs.update(kwargs) - return LegacyDataset(**default_kwargs) - - -def test_register_dataset(env: CompilerEnv): - dataset = make_dataset() - assert env.register_dataset(dataset) - assert dataset.name in env.available_datasets - - -def test_register_dataset_matching_platform(env: CompilerEnv): - platform = {"darwin": "macos"}.get(sys.platform, sys.platform) - dataset = make_dataset(platforms=[platform]) - assert env.register_dataset(dataset) - assert dataset.name in env.available_datasets - - -def test_register_dataset_different_platform(env: CompilerEnv): - dataset = make_dataset(platforms=["not-a-real-platform"]) - assert not env.register_dataset(dataset) - assert dataset.name not in env.available_datasets - - -def test_double_register_dataset(env: CompilerEnv): - dataset = make_dataset() - assert env.register_dataset(dataset) - with pytest.raises(ValueError) as ctx: - env.register_dataset(dataset) - assert str(ctx.value) == f"Dataset already registered with name: {dataset.name}" - - def test_benchmark_constructor_arg(env: CompilerEnv): env.close() # Fixture only required to pull in dataset. - env = gym.make("llvm-v0", benchmark="cBench-v1/dijkstra") + env = gym.make("llvm-v0", benchmark="cbench-v1/dijkstra") try: - assert env.benchmark == "cBench-v1/dijkstra" + assert env.benchmark == "benchmark://cbench-v1/dijkstra" finally: env.close() +def test_benchmark_setter(env: CompilerEnv): + env.benchmark = "benchmark://cbench-v1/dijkstra" + assert env.benchmark != "benchmark://cbench-v1/dijkstra" + env.reset() + assert env.benchmark == "benchmark://cbench-v1/dijkstra" + + +def test_benchmark_set_in_reset(env: CompilerEnv): + env.reset(benchmark="benchmark://cbench-v1/dijkstra") + assert env.benchmark == "benchmark://cbench-v1/dijkstra" + + def test_logger_forced(): logger = logging.getLogger("test_logger") env_a = gym.make("llvm-v0") @@ -80,5 +49,119 @@ def test_logger_forced(): env_b.close() +def test_uri_substring_no_match(env: CompilerEnv): + env.reset(benchmark="benchmark://cbench-v1/crc32") + assert env.benchmark == "benchmark://cbench-v1/crc32" + + with pytest.raises(LookupError): + env.reset(benchmark="benchmark://cbench-v1/crc3") + + with pytest.raises(LookupError): + env.reset(benchmark="benchmark://cbench-v1/cr") + + +def test_uri_substring_candidate_no_match_infer_protocol(env: CompilerEnv): + env.reset(benchmark="cbench-v1/crc32") + assert env.benchmark == "benchmark://cbench-v1/crc32" + + with pytest.raises(LookupError): + env.reset(benchmark="cbench-v1/crc3") + + with pytest.raises(LookupError): + env.reset(benchmark="cbench-v1/cr") + + +def test_reset_to_force_benchmark(env: CompilerEnv): + """Reset that calling reset() with a benchmark forces that benchmark to + be used for every subsequent episode. + """ + env.reset(benchmark="benchmark://cbench-v1/crc32") + assert env.benchmark == "benchmark://cbench-v1/crc32" + for _ in range(10): + env.reset() + assert env.benchmark == "benchmark://cbench-v1/crc32" + + +def test_unset_forced_benchmark(env: CompilerEnv): + """Test that setting benchmark "unsets" the previous benchmark.""" + env.reset(benchmark="benchmark://cbench-v1/dijkstra") + + with pytest.warns( + UserWarning, + match=r"Changing the benchmark has no effect until reset\(\) is called", + ): + env.benchmark = "benchmark://cbench-v1/crc32" + env.reset() + assert env.benchmark == "benchmark://cbench-v1/crc32" + + +def test_change_benchmark_mid_episode(env: CompilerEnv): + """Test that changing the benchmark while in an episode has no effect until + the next call to reset().""" + env.reset(benchmark="benchmark://cbench-v1/crc32") + assert env.benchmark == "benchmark://cbench-v1/crc32" + with pytest.warns( + UserWarning, + match=r"Changing the benchmark has no effect until reset\(\) is called", + ): + env.benchmark = "benchmark://cbench-v1/dijkstra" + assert env.benchmark == "benchmark://cbench-v1/crc32" + env.reset() + assert env.benchmark == "benchmark://cbench-v1/dijkstra" + + +def test_set_benchmark_invalid_type(env: CompilerEnv): + with pytest.raises(TypeError) as ctx: + env.benchmark = 10 + assert str(ctx.value) == "Expected a Benchmark or str, received: 'int'" + + +def test_gym_make_kwargs(): + """Test that passing kwargs to gym.make() are forwarded to environment + constructor. + """ + env = gym.make( + "llvm-v0", observation_space="Autophase", reward_space="IrInstructionCount" + ) + try: + assert env.observation_space_spec.id == "Autophase" + assert env.reward_space.id == "IrInstructionCount" + finally: + env.close() + + +def test_step_session_id_not_found(env: CompilerEnv): + """Test that step() recovers gracefully from an unknown session error from + the service.""" + env._session_id = 15 # pylint: disable=protected-access + observation, reward, done, info = env.step(0) + assert done + assert info["error_details"] == "Session not found: 15" + assert observation is None + assert reward is None + assert not env.in_episode + + +@pytest.fixture(scope="function") +def remote_env() -> CompilerEnv: + """A test fixture that yields a connection to a remote service.""" + service = CompilerGymServiceConnection(llvm.LLVM_SERVICE_BINARY) + env = CompilerEnv(service=service.connection.url) + try: + yield env + finally: + env.close() + service.close() + + +def test_base_class_has_no_benchmark(remote_env: CompilerEnv): + """Test that when instantiating the base CompilerEnv class there are no + datasets available. + """ + assert remote_env.benchmark is None + with pytest.raises(TypeError, match="No benchmark set"): + remote_env.reset() + + if __name__ == "__main__": main() diff --git a/tests/fuzzing/llvm_stress_fuzz_test.py b/tests/fuzzing/llvm_stress_fuzz_test.py index 9a50ad212..6c6446716 100644 --- a/tests/fuzzing/llvm_stress_fuzz_test.py +++ b/tests/fuzzing/llvm_stress_fuzz_test.py @@ -25,7 +25,7 @@ def test_fuzz(env: LlvmEnv, observation_space: str, reward_space: str): seed = random.randint(0, 2 << 31) llvm_ir = subprocess.check_output([str(llvm.llvm_stress_path()), f"--seed={seed}"]) print(f"llvm-stress --seed={seed}") # For debugging in case of failure. - env.benchamrk = Benchmark(uri="stress", program=File(contents=llvm_ir)) + env.benchmark = Benchmark(uri="stress", program=File(contents=llvm_ir)) env.observation_space = observation_space env.reward_space = reward_space diff --git a/tests/fuzzing/llvm_validate_fuzz_test.py b/tests/fuzzing/llvm_validate_fuzz_test.py index 454640a3e..eae460a0b 100644 --- a/tests/fuzzing/llvm_validate_fuzz_test.py +++ b/tests/fuzzing/llvm_validate_fuzz_test.py @@ -6,10 +6,7 @@ import random from compiler_gym.envs import LlvmEnv -from compiler_gym.envs.llvm.legacy_datasets import ( - get_llvm_benchmark_validation_callback, -) -from tests.pytest_plugins.llvm import VALIDATABLE_BENCHMARKS +from tests.pytest_plugins.llvm import VALIDATABLE_CBENCH_URIS from tests.test_main import main pytest_plugins = ["tests.pytest_plugins.llvm"] @@ -21,7 +18,7 @@ def test_fuzz(env: LlvmEnv): """This test generates a random trajectory and validates the semantics.""" - benchmark = random.choice(VALIDATABLE_BENCHMARKS) + benchmark = random.choice(VALIDATABLE_CBENCH_URIS) num_actions = random.randint(*RANDOM_TRAJECTORY_LENGTH_RANGE) while True: @@ -32,9 +29,7 @@ def test_fuzz(env: LlvmEnv): break # Broken trajectory, retry. else: print(f"Validating state {env.state}") - validation_cb = get_llvm_benchmark_validation_callback(env) - assert validation_cb - assert validation_cb(env) is None + assert env.validate() == [] # Stop the test. break diff --git a/tests/llvm/BUILD b/tests/llvm/BUILD index 275b7e6c9..cca590e6e 100644 --- a/tests/llvm/BUILD +++ b/tests/llvm/BUILD @@ -40,20 +40,6 @@ py_test( ], ) -py_test( - name = "benchmark_semantics_validation_test", - timeout = "eternal", - srcs = ["benchmark_semantics_validation_test.py"], - shard_count = 10, - deps = [ - "//compiler_gym", - "//compiler_gym/datasets", - "//compiler_gym/envs", - "//tests:test_main", - "//tests/pytest_plugins:llvm", - ], -) - py_test( name = "benchmarks_random_actions_test", timeout = "long", @@ -73,7 +59,7 @@ py_test( srcs = ["custom_benchmarks_test.py"], data = [ "invalid_ir.ll", - "//compiler_gym/third_party/cBench:crc32", + "//compiler_gym/third_party/cbench:crc32", ], deps = [ "//compiler_gym/envs", @@ -101,7 +87,7 @@ py_test( timeout = "long", srcs = ["fork_env_test.py"], data = [ - "//compiler_gym/third_party/cBench:crc32", + "//compiler_gym/third_party/cbench:crc32", ], deps = [ "//compiler_gym/envs", @@ -151,6 +137,18 @@ py_test( ], ) +py_test( + name = "invalid_ir_test", + srcs = ["invalid_ir_test.py"], + data = ["invalid_ir.ll"], + deps = [ + "//compiler_gym/util", + "//tests:test_main", + "//tests/pytest_plugins:common", + "//tests/pytest_plugins:llvm", + ], +) + py_test( name = "llvm_benchmarks_test", srcs = ["llvm_benchmarks_test.py"], @@ -234,17 +232,31 @@ py_test( name = "threading_test", timeout = "short", srcs = ["threading_test.py"], + flaky = 1, deps = [ "//compiler_gym", "//tests:test_main", ], ) +py_test( + name = "validate_test", + timeout = "moderate", + srcs = ["validate_test.py"], + deps = [ + "//compiler_gym", + "//compiler_gym/datasets", + "//compiler_gym/envs", + "//tests:test_main", + "//tests/pytest_plugins:llvm", + ], +) + py_test( name = "validation_regression_test", timeout = "long", srcs = ["validation_regression_test.py"], - shard_count = 6, + shard_count = 4, deps = [ "//compiler_gym", "//tests:test_main", diff --git a/tests/llvm/all_actions_single_step_test.py b/tests/llvm/all_actions_single_step_test.py index 5f5f7dd04..5e64a34f6 100644 --- a/tests/llvm/all_actions_single_step_test.py +++ b/tests/llvm/all_actions_single_step_test.py @@ -17,7 +17,7 @@ def test_step(env: CompilerEnv, action_name: str): """Run each action on a single benchmark.""" env.reward_space = "IrInstructionCount" env.observation_space = "Autophase" - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") observation, reward, done, _ = env.step(env.action_space.from_string(action_name)) assert isinstance(observation, np.ndarray) diff --git a/tests/llvm/autophase_test.py b/tests/llvm/autophase_test.py index 86241c0b2..a466a2957 100644 --- a/tests/llvm/autophase_test.py +++ b/tests/llvm/autophase_test.py @@ -10,8 +10,8 @@ def test_autophase_crc32_feature_vector(env: CompilerEnv): - env.benchmark = "cBench-v1/crc32" - env.reset() + env.reset(benchmark="cbench-v1/crc32") + print(env.benchmark) # For debugging in case of error. features = env.observation["AutophaseDict"] print(features) # For debugging on failure. assert features == { diff --git a/tests/llvm/custom_benchmarks_test.py b/tests/llvm/custom_benchmarks_test.py index a469defc5..35fe0e0cd 100644 --- a/tests/llvm/custom_benchmarks_test.py +++ b/tests/llvm/custom_benchmarks_test.py @@ -24,7 +24,7 @@ # The path of an IR file that assembles but does not compile. INVALID_IR_PATH = runfiles_path("tests/llvm/invalid_ir.ll") EXAMPLE_BITCODE_FILE = runfiles_path( - "compiler_gym/third_party/cBench/cBench-v1/crc32.bc" + "compiler_gym/third_party/cbench/cbench-v1/crc32.bc" ) EXAMPLE_BITCODE_IR_INSTRUCTION_COUNT = 242 @@ -34,7 +34,7 @@ def test_reset_invalid_benchmark(env: LlvmEnv): with pytest.raises(ValueError) as ctx: env.reset(benchmark=invalid_benchmark) - assert str(ctx.value) == f'Unknown benchmark "{invalid_benchmark}"' + assert str(ctx.value) == f"Invalid benchmark URI: 'benchmark://{invalid_benchmark}'" def test_invalid_benchmark_data(env: LlvmEnv): @@ -100,7 +100,7 @@ def test_benchmark_path_invalid_protocol(env: LlvmEnv): assert ( str(ctx.value) - == 'Unsupported benchmark URI protocol: "invalid_protocol://test"' + == 'Invalid benchmark data URI. Only the file:/// protocol is supported: "invalid_protocol://test"' ) diff --git a/tests/llvm/datasets/BUILD b/tests/llvm/datasets/BUILD index d48865c18..9077658ba 100644 --- a/tests/llvm/datasets/BUILD +++ b/tests/llvm/datasets/BUILD @@ -35,7 +35,7 @@ py_test( name = "cbench_validate_test", timeout = "eternal", srcs = ["cbench_validate_test.py"], - shard_count = 8, + shard_count = 6, deps = [ "//compiler_gym", "//compiler_gym/datasets", diff --git a/tests/llvm/datasets/cbench_validate_test.py b/tests/llvm/datasets/cbench_validate_test.py index 7d0e424de..156e47b46 100644 --- a/tests/llvm/datasets/cbench_validate_test.py +++ b/tests/llvm/datasets/cbench_validate_test.py @@ -10,10 +10,10 @@ pytest_plugins = ["tests.pytest_plugins.llvm"] -def test_validate_benchmark_semantics(env: LlvmEnv, validatable_benchmark_name: str): +def test_validate_benchmark_semantics(env: LlvmEnv, validatable_cbench_uri: str): """Run the validation routine on all benchmarks.""" env.reward_space = "IrInstructionCount" - env.reset(benchmark=validatable_benchmark_name) + env.reset(benchmark=validatable_cbench_uri) # Run a single step. env.step(env.action_space.flags.index("-mem2reg")) @@ -30,11 +30,11 @@ def test_validate_benchmark_semantics(env: LlvmEnv, validatable_benchmark_name: def test_non_validatable_benchmark_validate( - env: LlvmEnv, non_validatable_benchmark_name: str + env: LlvmEnv, non_validatable_cbench_uri: str ): """Run the validation routine on all benchmarks.""" env.reward_space = "IrInstructionCount" - env.reset(benchmark=non_validatable_benchmark_name) + env.reset(benchmark=non_validatable_cbench_uri) # Run a single step. env.step(env.action_space.flags.index("-mem2reg")) diff --git a/tests/llvm/fork_env_test.py b/tests/llvm/fork_env_test.py index 0f7b41582..59d239f1d 100644 --- a/tests/llvm/fork_env_test.py +++ b/tests/llvm/fork_env_test.py @@ -12,13 +12,13 @@ pytest_plugins = ["tests.pytest_plugins.llvm"] EXAMPLE_BITCODE_FILE = runfiles_path( - "compiler_gym/third_party/cBench/cBench-v1/crc32.bc" + "compiler_gym/third_party/cbench/cbench-v1/crc32.bc" ) EXAMPLE_BITCODE_IR_INSTRUCTION_COUNT = 196 def test_fork_child_process_is_not_orphaned(env: LlvmEnv): - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") fkd = env.fork() try: # Check that both environments share the same service. @@ -49,7 +49,7 @@ def test_fork_child_process_is_not_orphaned(env: LlvmEnv): def test_fork_chain_child_processes_are_not_orphaned(env: LlvmEnv): - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") # Create a chain of forked environments. a = env.fork() @@ -93,13 +93,12 @@ def test_fork_before_reset(env: LlvmEnv): try: assert env.in_episode assert fkd.in_episode - assert env.benchmark == fkd.benchmark finally: fkd.close() def test_fork_closed_service(env: LlvmEnv): - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") _, _, done, _ = env.step(0) assert not done @@ -119,7 +118,7 @@ def test_fork_closed_service(env: LlvmEnv): def test_fork_spaces_are_same(env: LlvmEnv): env.observation_space = "Autophase" env.reward_space = "IrInstructionCount" - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") fkd = env.fork() try: @@ -131,7 +130,7 @@ def test_fork_spaces_are_same(env: LlvmEnv): def test_fork_state(env: LlvmEnv): - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") env.step(0) assert env.actions == [0] @@ -144,7 +143,7 @@ def test_fork_state(env: LlvmEnv): def test_fork_reset(env: LlvmEnv): - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") env.step(0) env.step(1) env.step(2) @@ -183,7 +182,7 @@ def ir(env): def test_fork_twice_test(env: LlvmEnv): """Test that fork() on a forked environment works.""" - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") fork_a = env.fork() fork_b = fork_a.fork() try: @@ -196,7 +195,7 @@ def test_fork_twice_test(env: LlvmEnv): def test_fork_modified_ir_is_the_same(env: LlvmEnv): """Test that the IR of a forked environment is the same.""" - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") # Apply an action that modifies the benchmark. _, _, done, info = env.step(env.action_space.flags.index("-mem2reg")) @@ -222,7 +221,7 @@ def test_fork_modified_ir_is_the_same(env: LlvmEnv): def test_fork_rewards(env: LlvmEnv, reward_space: str): """Test that rewards are equal after fork() is called.""" env.reward_space = reward_space - env.reset("cBench-v1/dijkstra") + env.reset("cbench-v1/dijkstra") actions = [env.action_space.flags.index(n) for n in ["-mem2reg", "-simplifycfg"]] @@ -240,7 +239,7 @@ def test_fork_rewards(env: LlvmEnv, reward_space: str): def test_fork_previous_cost_reward_update(env: LlvmEnv): env.reward_space = "IrInstructionCount" - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") env.step(env.action_space.flags.index("-mem2reg")) fkd = env.fork() @@ -253,7 +252,7 @@ def test_fork_previous_cost_reward_update(env: LlvmEnv): def test_fork_previous_cost_lazy_reward_update(env: LlvmEnv): - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") env.step(env.action_space.flags.index("-mem2reg")) env.reward["IrInstructionCount"] diff --git a/tests/llvm/fresh_environment_observation_reward_test.py b/tests/llvm/fresh_environment_observation_reward_test.py index 262e24480..e1cf71018 100644 --- a/tests/llvm/fresh_environment_observation_reward_test.py +++ b/tests/llvm/fresh_environment_observation_reward_test.py @@ -14,7 +14,7 @@ def test_step(env: CompilerEnv, observation_space: str, reward_space: str): """Request every combination of observation and reward in a fresh environment.""" env.reward_space = None env.observation_space = None - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") observation = env.observation[observation_space] assert observation is not None diff --git a/tests/llvm/fuzzing_regression_test.py b/tests/llvm/fuzzing_regression_test.py index 09e30801c..8a628bf8c 100644 --- a/tests/llvm/fuzzing_regression_test.py +++ b/tests/llvm/fuzzing_regression_test.py @@ -18,7 +18,7 @@ @pytest.mark.xfail(reason="-separate-const-offset-from-gep", strict=True) def test_regression_test_const_offset_from_gep(env, tmpwd, llvm_diff, llvm_opt): - env.reset(benchmark="benchmark://cBench-v1/blowfish") + env.reset(benchmark="benchmark://cbench-v1/blowfish") env.write_ir("input.ll") # FIXME: Removing the -separate-const-offset-from-gep actions from the below # commandline "fixes" the test. diff --git a/tests/llvm/gvn_sink_test.py b/tests/llvm/gvn_sink_test.py index 9c8bfba9d..df5c592d8 100644 --- a/tests/llvm/gvn_sink_test.py +++ b/tests/llvm/gvn_sink_test.py @@ -19,24 +19,24 @@ @pytest.mark.parametrize( "benchmark_name", [ - "benchmark://cBench-v1/adpcm", - "benchmark://cBench-v1/bitcount", - "benchmark://cBench-v1/blowfish", - "benchmark://cBench-v1/bzip2", - "benchmark://cBench-v1/ghostscript", - "benchmark://cBench-v1/gsm", - "benchmark://cBench-v1/ispell", - "benchmark://cBench-v1/jpeg-c", - "benchmark://cBench-v1/jpeg-d", - "benchmark://cBench-v1/patricia", - "benchmark://cBench-v1/rijndael", - "benchmark://cBench-v1/stringsearch", - "benchmark://cBench-v1/stringsearch2", - "benchmark://cBench-v1/susan", - "benchmark://cBench-v1/tiff2bw", - "benchmark://cBench-v1/tiff2rgba", - "benchmark://cBench-v1/tiffdither", - "benchmark://cBench-v1/tiffmedian", + "benchmark://cbench-v1/adpcm", + "benchmark://cbench-v1/bitcount", + "benchmark://cbench-v1/blowfish", + "benchmark://cbench-v1/bzip2", + "benchmark://cbench-v1/ghostscript", + "benchmark://cbench-v1/gsm", + "benchmark://cbench-v1/ispell", + "benchmark://cbench-v1/jpeg-c", + "benchmark://cbench-v1/jpeg-d", + "benchmark://cbench-v1/patricia", + "benchmark://cbench-v1/rijndael", + "benchmark://cbench-v1/stringsearch", + "benchmark://cbench-v1/stringsearch2", + "benchmark://cbench-v1/susan", + "benchmark://cbench-v1/tiff2bw", + "benchmark://cbench-v1/tiff2rgba", + "benchmark://cbench-v1/tiffdither", + "benchmark://cbench-v1/tiffmedian", ], ) def test_gvn_sink_non_determinism(env: LlvmEnv, benchmark_name: str): diff --git a/tests/llvm/invalid_ir_test.py b/tests/llvm/invalid_ir_test.py new file mode 100644 index 000000000..1fc7c8123 --- /dev/null +++ b/tests/llvm/invalid_ir_test.py @@ -0,0 +1,32 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +"""Tests for LLVM benchmark handling.""" +import pytest + +from compiler_gym.datasets.benchmark import BenchmarkInitError +from compiler_gym.envs import llvm +from compiler_gym.envs.llvm import LlvmEnv +from compiler_gym.util.runfiles_path import runfiles_path +from tests.pytest_plugins.common import bazel_only +from tests.test_main import main + +pytest_plugins = ["tests.pytest_plugins.llvm"] + +INVALID_IR_PATH = runfiles_path("tests/llvm/invalid_ir.ll") + + +@bazel_only # invalid_ir.ll not installed +def test_reset_invalid_ir(env: LlvmEnv): + """Test that setting the $CXX to an invalid binary raises an error.""" + benchmark = llvm.make_benchmark(INVALID_IR_PATH) + + with pytest.raises(BenchmarkInitError) as e_ctx: + env.reset(benchmark=benchmark) + + assert "Failed to compute .text size cost" in str(e_ctx.value) + + +if __name__ == "__main__": + main() diff --git a/tests/llvm/llvm_benchmarks_test.py b/tests/llvm/llvm_benchmarks_test.py index 076385c2a..0986da359 100644 --- a/tests/llvm/llvm_benchmarks_test.py +++ b/tests/llvm/llvm_benchmarks_test.py @@ -8,8 +8,10 @@ import pytest +from compiler_gym.datasets import Benchmark from compiler_gym.envs import CompilerEnv -from compiler_gym.service.proto import Benchmark, File +from compiler_gym.service.proto import Benchmark as BenchmarkProto +from compiler_gym.service.proto import File from tests.test_main import main pytest_plugins = ["tests.pytest_plugins.llvm"] @@ -19,12 +21,14 @@ def test_add_benchmark_invalid_protocol(env: CompilerEnv): with pytest.raises(ValueError) as ctx: env.reset( benchmark=Benchmark( - uri="benchmark://foo", program=File(uri="https://invalid/protocol") + BenchmarkProto( + uri="benchmark://foo", program=File(uri="https://invalid/protocol") + ), ) ) - assert ( - str(ctx.value) - == 'Unsupported benchmark URI protocol: "https://invalid/protocol"' + assert str(ctx.value) == ( + "Invalid benchmark data URI. " + 'Only the file:/// protocol is supported: "https://invalid/protocol"' ) @@ -32,12 +36,9 @@ def test_add_benchmark_invalid_path(env: CompilerEnv): with tempfile.TemporaryDirectory() as d: tmp = Path(d) / "not_a_file" with pytest.raises(FileNotFoundError) as ctx: - env.reset( - benchmark=Benchmark( - uri="benchmark://foo", program=File(uri=f"file:///{tmp}") - ) - ) - assert str(ctx.value) == f'File not found: "{tmp}"' + env.reset(benchmark=Benchmark.from_file("benchmark://foo", tmp)) + # Use endswith() because on macOS there may be a /private prefix. + assert str(ctx.value).endswith(str(tmp)) if __name__ == "__main__": diff --git a/tests/llvm/llvm_env_test.py b/tests/llvm/llvm_env_test.py index cb516b73d..8cfd9cee0 100644 --- a/tests/llvm/llvm_env_test.py +++ b/tests/llvm/llvm_env_test.py @@ -16,6 +16,7 @@ from compiler_gym.envs.llvm.llvm_env import LlvmEnv from compiler_gym.service.connection import CompilerGymServiceConnection from compiler_gym.util import debug_util as dbg +from tests.pytest_plugins import llvm as llvm_plugin from tests.test_main import main pytest_plugins = ["tests.pytest_plugins.common", "tests.pytest_plugins.llvm"] @@ -26,7 +27,6 @@ def env(request) -> CompilerEnv: """Create an LLVM environment.""" if request.param == "local": env = gym.make("llvm-v0") - env.require_dataset("cBench-v1") try: yield env finally: @@ -34,7 +34,6 @@ def env(request) -> CompilerEnv: else: service = CompilerGymServiceConnection(llvm.LLVM_SERVICE_BINARY) env = LlvmEnv(service=service.connection.url) - env.require_dataset("cBench-v1") try: yield env finally: @@ -50,11 +49,11 @@ def test_compiler_version(env: LlvmEnv): assert env.compiler_version.startswith("10.0.0") -def test_action_space_names(env: CompilerEnv, action_names: List[str]): +def test_action_space_names(env: LlvmEnv, action_names: List[str]): assert set(env.action_space.names) == set(action_names) -def test_action_spaces_names(env: CompilerEnv): +def test_action_spaces_names(env: LlvmEnv): assert {a.name for a in env.action_spaces} == {"PassesAll"} @@ -62,26 +61,26 @@ def test_all_flags_are_unique(env: LlvmEnv): assert sorted(env.action_space.flags) == sorted(set(env.action_space.flags)) -def test_benchmark_names(env: CompilerEnv, benchmark_names: List[str]): - # Use a subset check as benchmark_names may exclude certain benchmarks for - # testing. - assert set(benchmark_names).issubset(set(env.benchmarks)) +@pytest.mark.parametrize("benchmark_name", llvm_plugin.BENCHMARK_NAMES) +def test_benchmark_names(env: LlvmEnv, benchmark_name: str): + """Check that all benchmark names can be found in the datasets.""" + assert env.datasets.benchmark(benchmark_name) -def test_double_reset(env: CompilerEnv): - env.reset(benchmark="cBench-v1/crc32") - env.reset(benchmark="cBench-v1/crc32") +def test_double_reset(env: LlvmEnv): + env.reset(benchmark="cbench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") assert env.in_episode -def test_commandline_no_actions(env: CompilerEnv): - env.reset(benchmark="cBench-v1/crc32") +def test_commandline_no_actions(env: LlvmEnv): + env.reset(benchmark="cbench-v1/crc32") assert env.commandline() == "opt input.bc -o output.bc" assert env.commandline_to_actions(env.commandline()) == [] -def test_commandline(env: CompilerEnv): - env.reset(benchmark="cBench-v1/crc32") +def test_commandline(env: LlvmEnv): + env.reset(benchmark="cbench-v1/crc32") env.step(env.action_space.flags.index("-mem2reg")) env.step(env.action_space.flags.index("-reg2mem")) assert env.commandline() == "opt -mem2reg -reg2mem input.bc -o output.bc" @@ -91,91 +90,9 @@ def test_commandline(env: CompilerEnv): ] -def test_uri_substring_candidate_match(env: CompilerEnv): - env.reset(benchmark="benchmark://cBench-v1/crc32") - assert env.benchmark == "benchmark://cBench-v1/crc32" - - env.reset(benchmark="benchmark://cBench-v1/crc3") - assert env.benchmark == "benchmark://cBench-v1/crc32" - - env.reset(benchmark="benchmark://cBench-v1/cr") - assert env.benchmark == "benchmark://cBench-v1/crc32" - - -def test_uri_substring_candidate_match_infer_protocol(env: CompilerEnv): - env.reset(benchmark="cBench-v1/crc32") - assert env.benchmark == "benchmark://cBench-v1/crc32" - - env.reset(benchmark="cBench-v1/crc3") - assert env.benchmark == "benchmark://cBench-v1/crc32" - - env.reset(benchmark="cBench-v1/cr") - assert env.benchmark == "benchmark://cBench-v1/crc32" - - -def test_reset_to_force_benchmark(env: CompilerEnv): - """Reset that calling reset() with a benchmark forces that benchmark to - be used for every subsequent episode. - """ - env.benchmark = None - env.reset(benchmark="benchmark://cBench-v1/crc32") - assert env.benchmark == "benchmark://cBench-v1/crc32" - for _ in range(10): - env.reset() - assert env.benchmark == "benchmark://cBench-v1/crc32" - - -def test_unset_forced_benchmark(env: CompilerEnv): - """Test that setting benchmark to None "unsets" the user benchmark for - every subsequent episode. - """ - env.reset(benchmark="benchmark://cBench-v1/crc32") - assert env.benchmark == "benchmark://cBench-v1/crc32" - env.benchmark = None - for _ in range(50): - env.reset() - if env.benchmark != "benchmark://cBench-v1/crc32": - break - else: - pytest.fail( - "Improbably selected the same benchmark 50 times! " "Expected random." - ) - - -def test_change_benchmark_mid_episode(env: LlvmEnv): - """Test that changing the benchmark while in an episode has no effect until - the next call to reset().""" - env.reset(benchmark="benchmark://cBench-v1/crc32") - assert env.benchmark == "benchmark://cBench-v1/crc32" - env.benchmark = "benchmark://cBench-v1/dijkstra" - assert env.benchmark == "benchmark://cBench-v1/crc32" - env.reset() - assert env.benchmark == "benchmark://cBench-v1/dijkstra" - - -def test_set_benchmark_invalid_type(env: LlvmEnv): - with pytest.raises(TypeError) as ctx: - env.benchmark = 10 - assert str(ctx.value) == "Unsupported benchmark type: int" - - -def test_gym_make_kwargs(): - """Test that passing kwargs to gym.make() are forwarded to environment - constructor. - """ - env = gym.make( - "llvm-v0", observation_space="Autophase", reward_space="IrInstructionCount" - ) - try: - assert env.observation_space_spec.id == "Autophase" - assert env.reward_space.id == "IrInstructionCount" - finally: - env.close() - - def test_connection_dies_default_reward(env: LlvmEnv): env.reward_space = "IrInstructionCount" - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") env.reward_space.default_negates_returns = False env.reward_space.default_value = 2.5 @@ -190,7 +107,7 @@ def test_connection_dies_default_reward(env: LlvmEnv): def test_connection_dies_default_reward_negated(env: LlvmEnv): env.reward_space = "IrInstructionCount" - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") env.reward_space.default_negates_returns = True env.reward_space.default_value = 2.5 @@ -204,7 +121,7 @@ def test_connection_dies_default_reward_negated(env: LlvmEnv): def test_state_to_csv_from_csv(env: LlvmEnv): - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") env.episode_reward = 10 state = env.state @@ -217,7 +134,7 @@ def test_state_to_csv_from_csv(env: LlvmEnv): def test_apply_state(env: LlvmEnv): """Test that apply() on a clean environment produces same state.""" env.reward_space = "IrInstructionCount" - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") env.step(env.action_space.flags.index("-mem2reg")) other = gym.make("llvm-v0", reward_space="IrInstructionCount") @@ -250,7 +167,7 @@ def test_same_reward_after_reset(env: LlvmEnv): same reward. """ env.reward_space = "IrInstructionCount" - env.benchmark = "cBench-v1/dijkstra" + env.benchmark = "cbench-v1/dijkstra" action = env.action_space.flags.index("-instcombine") env.reset() @@ -264,19 +181,19 @@ def test_same_reward_after_reset(env: LlvmEnv): def test_write_bitcode(env: LlvmEnv, tmpwd: Path): - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") env.write_bitcode("file.bc") assert Path("file.bc").is_file() def test_write_ir(env: LlvmEnv, tmpwd: Path): - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") env.write_bitcode("file.ll") assert Path("file.ll").is_file() def test_ir_sha1(env: LlvmEnv, tmpwd: Path): - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") before = env.ir_sha1 _, _, done, info = env.step(env.action_space.flags.index("-mem2reg")) @@ -298,7 +215,7 @@ def test_logging_default_level(env: LlvmEnv): def test_step_multiple_actions_list(env: LlvmEnv): """Pass a list of actions to step().""" - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") actions = [ env.action_space.flags.index("-mem2reg"), env.action_space.flags.index("-reg2mem"), @@ -310,7 +227,7 @@ def test_step_multiple_actions_list(env: LlvmEnv): def test_step_multiple_actions_generator(env: LlvmEnv): """Pass an iterable of actions to step().""" - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") actions = ( env.action_space.flags.index("-mem2reg"), env.action_space.flags.index("-reg2mem"), diff --git a/tests/llvm/multiprocessing_test.py b/tests/llvm/multiprocessing_test.py index b18216197..bcd5c4e7c 100644 --- a/tests/llvm/multiprocessing_test.py +++ b/tests/llvm/multiprocessing_test.py @@ -42,7 +42,7 @@ def test_running_environment_in_background_process(): queue = mp.Queue(maxsize=3) process = mp.Process( target=process_worker, - args=("llvm-autophase-ic-v0", "cBench-v1/crc32", [0, 0, 0], queue), + args=("llvm-autophase-ic-v0", "cbench-v1/crc32", [0, 0, 0], queue), ) process.start() try: @@ -69,7 +69,7 @@ def test_moving_environment_to_background_process_macos(): queue = mp.Queue(maxsize=3) env = gym.make("llvm-autophase-ic-v0") - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") process = mp.Process(target=process_worker_with_env, args=(env, [0, 0, 0], queue)) @@ -83,10 +83,10 @@ def test_moving_environment_to_background_process_macos(): def test_port_collision_test(): """Test that attempting to connect to a port that is already in use succeeds.""" env_a = gym.make("llvm-autophase-ic-v0") - env_a.reset(benchmark="cBench-v1/crc32") + env_a.reset(benchmark="cbench-v1/crc32") env_b = LlvmEnv(service=env_a.service.connection.url) - env_b.reset(benchmark="cBench-v1/crc32") + env_b.reset(benchmark="cbench-v1/crc32") env_b.close() env_a.close() diff --git a/tests/llvm/observation_spaces_test.py b/tests/llvm/observation_spaces_test.py index 3e0f561b1..9d76826e8 100644 --- a/tests/llvm/observation_spaces_test.py +++ b/tests/llvm/observation_spaces_test.py @@ -35,7 +35,7 @@ def test_default_observation_space(env: LlvmEnv): def test_observation_spaces(env: LlvmEnv): - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") assert set(env.observation.spaces.keys()) == { "Ir", @@ -63,7 +63,7 @@ def test_observation_spaces(env: LlvmEnv): def test_ir_observation_space(env: LlvmEnv): - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") key = "Ir" space = env.observation.spaces[key] assert isinstance(space.space, Sequence) @@ -80,7 +80,7 @@ def test_ir_observation_space(env: LlvmEnv): def test_bitcode_observation_space(env: LlvmEnv): - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") key = "BitcodeFile" space = env.observation.spaces[key] assert isinstance(space.space, Sequence) @@ -100,7 +100,7 @@ def test_bitcode_observation_space(env: LlvmEnv): assert not space.platform_dependent -# The Autophase feature vector for benchmark://cBench-v1/crc32 in its initial +# The Autophase feature vector for benchmark://cbench-v1/crc32 in its initial # state. AUTOPHASE_CBENCH_CRC32 = [ 0, @@ -165,13 +165,13 @@ def test_bitcode_observation_space(env: LlvmEnv): def test_autophase_observation_space_reset(env: LlvmEnv): """Test that the intial observation is returned on env.reset().""" env.observation_space = "Autophase" - observation = env.reset("cBench-v1/crc32") + observation = env.reset("cbench-v1/crc32") print(observation.tolist()) # For debugging on error. np.testing.assert_array_equal(observation, AUTOPHASE_CBENCH_CRC32) def test_instcount_observation_space(env: LlvmEnv): - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") key = "InstCount" space = env.observation.spaces[key] assert isinstance(space.space, Box) @@ -265,7 +265,7 @@ def test_instcount_observation_space(env: LlvmEnv): def test_instcount_dict_observation_space(env: LlvmEnv): - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") key = "InstCountDict" space = env.observation.spaces[key] assert isinstance(space.space, DictSpace) @@ -278,7 +278,7 @@ def test_instcount_dict_observation_space(env: LlvmEnv): def test_instcount_norm_observation_space(env: LlvmEnv): - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") key = "InstCountNorm" space = env.observation.spaces[key] assert isinstance(space.space, Box) @@ -299,7 +299,7 @@ def test_instcount_norm_observation_space(env: LlvmEnv): def test_instcount_norm_dict_observation_space(env: LlvmEnv): - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") key = "InstCountNormDict" space = env.observation.spaces[key] assert isinstance(space.space, DictSpace) @@ -312,7 +312,7 @@ def test_instcount_norm_dict_observation_space(env: LlvmEnv): def test_autophase_observation_space(env: LlvmEnv): - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") key = "Autophase" space = env.observation.spaces[key] assert isinstance(space.space, Box) @@ -330,7 +330,7 @@ def test_autophase_observation_space(env: LlvmEnv): def test_autophase_dict_observation_space(env: LlvmEnv): - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") key = "AutophaseDict" space = env.observation.spaces[key] assert isinstance(space.space, DictSpace) @@ -343,7 +343,7 @@ def test_autophase_dict_observation_space(env: LlvmEnv): def test_programl_observation_space(env: LlvmEnv): - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") key = "Programl" space = env.observation.spaces[key] assert isinstance(space.space, Sequence) @@ -364,7 +364,7 @@ def test_programl_observation_space(env: LlvmEnv): def test_cpuinfo_observation_space(env: LlvmEnv): - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") key = "CpuInfo" space = env.observation.spaces[key] assert isinstance(space.space, DictSpace) @@ -398,7 +398,7 @@ def test_cpuinfo_observation_space(env: LlvmEnv): @pytest.fixture def cbench_crc32_inst2vec_embedding_indices() -> List[int]: - """The expected inst2vec embedding indices for cBench-v1/crc32.""" + """The expected inst2vec embedding indices for cbench-v1/crc32.""" # The linux/macOS builds of clang produce slightly different bitcodes. if sys.platform.lower().startswith("linux"): return [ @@ -975,7 +975,7 @@ def cbench_crc32_inst2vec_embedding_indices() -> List[int]: def test_inst2vec_preprocessed_observation_space( env: LlvmEnv, cbench_crc32_inst2vec_embedding_indices: List[int] ): - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") key = "Inst2vecPreprocessedText" space = env.observation.spaces[key] assert isinstance(space.space, Sequence) @@ -996,7 +996,7 @@ def test_inst2vec_preprocessed_observation_space( def test_inst2vec_embedding_indices_observation_space( env: LlvmEnv, cbench_crc32_inst2vec_embedding_indices: List[int] ): - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") key = "Inst2vecEmbeddingIndices" space = env.observation.spaces[key] assert isinstance(space.space, Sequence) @@ -1016,7 +1016,7 @@ def test_inst2vec_embedding_indices_observation_space( def test_inst2vec_observation_space( env: LlvmEnv, cbench_crc32_inst2vec_embedding_indices: List[int] ): - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") key = "Inst2vec" space = env.observation.spaces[key] assert isinstance(space.space, Sequence) @@ -1042,7 +1042,7 @@ def test_inst2vec_observation_space( def test_ir_instruction_count_observation_spaces(env: LlvmEnv): - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") key = "IrInstructionCount" space = env.observation.spaces[key] @@ -1086,7 +1086,7 @@ def test_ir_instruction_count_observation_spaces(env: LlvmEnv): def test_object_text_size_observation_spaces(env: LlvmEnv): - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") # Expected .text sizes for this benchmark: -O0, -O3, -Oz. crc32_code_sizes = {"darwin": [1171, 3825, 3289], "linux": [1183, 3961, 3286]} diff --git a/tests/llvm/reward_spaces_test.py b/tests/llvm/reward_spaces_test.py index 02b741c8d..b7f5b3ddd 100644 --- a/tests/llvm/reward_spaces_test.py +++ b/tests/llvm/reward_spaces_test.py @@ -11,7 +11,7 @@ pytest_plugins = ["tests.pytest_plugins.llvm"] -# Instruction counts for cBench-v1/crc32 benchmark that are used for testing +# Instruction counts for cbench-v1/crc32 benchmark that are used for testing # reward signals. CRC32_INSTRUCTION_COUNT = 242 CRC32_INSTRUCTION_COUNT_AFTER_REG2MEM = 249 @@ -20,7 +20,7 @@ def test_instruction_count_reward(env: LlvmEnv): - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") assert env.observation.IrInstructionCount() == CRC32_INSTRUCTION_COUNT action = env.action_space.flags.index("-reg2mem") @@ -52,7 +52,7 @@ def test_reward_space(env: LlvmEnv): def test_invalid_reward_space_name(env: LlvmEnv): - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") invalid = "invalid value" with pytest.raises(KeyError) as ctx: _ = env.reward[invalid] @@ -60,7 +60,7 @@ def test_invalid_reward_space_name(env: LlvmEnv): def test_reward_spaces(env: LlvmEnv): - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") assert set(env.reward.spaces.keys()) == { "IrInstructionCount", @@ -75,7 +75,7 @@ def test_reward_spaces(env: LlvmEnv): def test_instruction_count_reward_spaces(env: LlvmEnv): - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") key = "IrInstructionCount" space = env.reward.spaces[key] @@ -119,7 +119,7 @@ def test_instruction_count_reward_spaces(env: LlvmEnv): def test_native_test_size_reward_spaces(env: LlvmEnv): - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") key = "ObjectTextSizeBytes" space = env.reward.spaces[key] diff --git a/tests/llvm/service/BUILD b/tests/llvm/service/BUILD index 48385ea7f..0f2e73416 100644 --- a/tests/llvm/service/BUILD +++ b/tests/llvm/service/BUILD @@ -22,7 +22,7 @@ cc_test( # cc_test( # name = "GvnSinkTest", # srcs = ["GvnSinkTest.cc"], -# data = ["//compiler_gym/third_party/cBench:blowfish"], +# data = ["//compiler_gym/third_party/cbench:blowfish"], # deps = [ # "//compiler_gym/envs/llvm/service:BenchmarkFactory", # "//compiler_gym/envs/llvm/service:LlvmSession", diff --git a/tests/llvm/service/GvnSinkTest.cc b/tests/llvm/service/GvnSinkTest.cc index 8204b857a..2b25a216a 100644 --- a/tests/llvm/service/GvnSinkTest.cc +++ b/tests/llvm/service/GvnSinkTest.cc @@ -36,12 +36,12 @@ class GvnSinkTest : public ::testing::Test { TEST_F(GvnSinkTest, runGvnSinkOnBlowfish) { const auto blowfish = - util::getRunfilesPath("compiler_gym/third_party/cBench/cBench-v1/blowfish.bc"); + util::getRunfilesPath("compiler_gym/third_party/cbench/cbench-v1/blowfish.bc"); BenchmarkFactory factory(workingDirectory_); - ASSERT_OK(factory.addBitcodeFile("benchmark://cBench-v1/blowfish", blowfish)); + ASSERT_OK(factory.addBitcodeFile("benchmark://cbench-v1/blowfish", blowfish)); std::unique_ptr benchmark; - ASSERT_OK(factory.getBenchmark("benchmark://cBench-v1/blowfish", &benchmark)); + ASSERT_OK(factory.getBenchmark("benchmark://cbench-v1/blowfish", &benchmark)); LlvmSession env(std::move(benchmark), LlvmActionSpace::PASSES_ALL, LlvmObservationSpace::IR, std::nullopt, workingDirectory_); diff --git a/tests/llvm/service_connection_test.py b/tests/llvm/service_connection_test.py index b7e808247..db67e73d9 100644 --- a/tests/llvm/service_connection_test.py +++ b/tests/llvm/service_connection_test.py @@ -23,7 +23,6 @@ def env(request) -> CompilerEnv: # connections. if request.param == "local": env = gym.make("llvm-v0") - env.require_dataset("cBench-v1") try: yield env finally: @@ -31,7 +30,6 @@ def env(request) -> CompilerEnv: else: service = CompilerGymServiceConnection(llvm.LLVM_SERVICE_BINARY) env = LlvmEnv(service=service.connection.url) - env.require_dataset("cBench-v1") try: yield env finally: @@ -42,7 +40,7 @@ def env(request) -> CompilerEnv: def test_service_env_dies_reset(env: CompilerEnv): env.observation_space = "Autophase" env.reward_space = "IrInstructionCount" - env.reset("cBench-v1/crc32") + env.reset("cbench-v1/crc32") # Kill the service. env.service.close() @@ -57,7 +55,7 @@ def test_service_env_dies_reset(env: CompilerEnv): assert reward == 0 # Reset the environment and check that it works. - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") assert env.in_episode observation, reward, done, info = env.step(0) diff --git a/tests/llvm/threading_test.py b/tests/llvm/threading_test.py index eb66b9386..20cc15d76 100644 --- a/tests/llvm/threading_test.py +++ b/tests/llvm/threading_test.py @@ -57,7 +57,7 @@ def test_running_environment_in_background_thread(): """Test launching and running an LLVM environment in a background thread.""" thread = ThreadedWorker( env_name="llvm-autophase-ic-v0", - benchmark="cBench-v1/crc32", + benchmark="cbench-v1/crc32", actions=[0, 0, 0], ) thread.start() @@ -74,7 +74,7 @@ def test_moving_environment_to_background_thread(): is made in the main thread and used in the background thread. """ env = gym.make("llvm-autophase-ic-v0") - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") thread = ThreadedWorkerWithEnv(env=env, actions=[0, 0, 0]) thread.start() diff --git a/tests/llvm/benchmark_semantics_validation_test.py b/tests/llvm/validate_test.py similarity index 54% rename from tests/llvm/benchmark_semantics_validation_test.py rename to tests/llvm/validate_test.py index 8a08ba5a5..1099ba8db 100644 --- a/tests/llvm/benchmark_semantics_validation_test.py +++ b/tests/llvm/validate_test.py @@ -7,12 +7,10 @@ from pathlib import Path import gym +import pytest -from compiler_gym import CompilerEnvState, ValidationResult +from compiler_gym import CompilerEnvState from compiler_gym.envs import LlvmEnv -from compiler_gym.envs.llvm.legacy_datasets import ( - get_llvm_benchmark_validation_callback, -) from tests.test_main import main pytest_plugins = ["tests.pytest_plugins.llvm"] @@ -20,32 +18,30 @@ def test_validate_state_no_reward(): state = CompilerEnvState( - benchmark="benchmark://cBench-v1/crc32", + benchmark="benchmark://cbench-v1/crc32", walltime=1, commandline="opt input.bc -o output.bc", ) env = gym.make("llvm-v0") try: - env.require_dataset("cBench-v1") result = env.validate(state) finally: env.close() assert result.okay() assert not result.reward_validated - assert str(result) == "✅ cBench-v1/crc32" + assert str(result) == "✅ cbench-v1/crc32" def test_validate_state_with_reward(): state = CompilerEnvState( - benchmark="benchmark://cBench-v1/crc32", + benchmark="benchmark://cbench-v1/crc32", walltime=1, reward=0, commandline="opt input.bc -o output.bc", ) env = gym.make("llvm-v0", reward_space="IrInstructionCount") try: - env.require_dataset("cBench-v1") result = env.validate(state) finally: env.close() @@ -53,19 +49,18 @@ def test_validate_state_with_reward(): assert result.okay() assert result.reward_validated assert not result.reward_validation_failed - assert str(result) == "✅ cBench-v1/crc32 0.0000" + assert str(result) == "✅ cbench-v1/crc32 0.0000" def test_validate_state_invalid_reward(): state = CompilerEnvState( - benchmark="benchmark://cBench-v1/crc32", + benchmark="benchmark://cbench-v1/crc32", walltime=1, reward=1, commandline="opt input.bc -o output.bc", ) env = gym.make("llvm-v0", reward_space="IrInstructionCount") try: - env.require_dataset("cBench-v1") result = env.validate(state) finally: env.close() @@ -74,37 +69,19 @@ def test_validate_state_invalid_reward(): assert result.reward_validated assert result.reward_validation_failed assert ( - str(result) == "❌ cBench-v1/crc32 Expected reward 1.0 but received reward 0.0" + str(result) == "❌ cbench-v1/crc32 Expected reward 1.0 but received reward 0.0" ) -def test_no_validation_callback_for_custom_benchmark(env: LlvmEnv): - """Test that a custom benchmark has no validation callback.""" - with tempfile.TemporaryDirectory() as d: - p = Path(d) / "example.c" - with open(p, "w") as f: - print("int main() {return 0;}", file=f) - benchmark = env.make_benchmark(p) - - env.benchmark = benchmark - env.reset() - - validation_cb = get_llvm_benchmark_validation_callback(env) - - assert validation_cb is None - - -def test_validate_state_without_env_reward(): - """Validating state when environment has no reward space.""" +def test_validate_state_without_state_reward(): + """Validating state when state has no reward value.""" state = CompilerEnvState( - benchmark="benchmark://cBench-v1/crc32", + benchmark="benchmark://cbench-v1/crc32", walltime=1, - reward=0, commandline="opt input.bc -o output.bc", ) - env = gym.make("llvm-v0") + env = gym.make("llvm-v0", reward_space="IrInstructionCount") try: - env.require_dataset("cBench-v1") result = env.validate(state) finally: env.close() @@ -114,17 +91,24 @@ def test_validate_state_without_env_reward(): assert not result.reward_validation_failed -def test_validate_state_without_state_reward(): - """Validating state when state has no reward value.""" +def test_validate_state_without_env_reward(): + """Validating state when environment has no reward space.""" state = CompilerEnvState( - benchmark="benchmark://cBench-v1/crc32", + benchmark="benchmark://cbench-v1/crc32", walltime=1, + reward=0, commandline="opt input.bc -o output.bc", ) - env = gym.make("llvm-v0", reward_space="IrInstructionCount") + env = gym.make("llvm-v0") try: - env.require_dataset("cBench-v1") - result = env.validate(state) + with pytest.warns( + UserWarning, + match=( + "Validating state with reward, " + "but environment has no reward space set" + ), + ): + result = env.validate(state) finally: env.close() @@ -133,44 +117,17 @@ def test_validate_state_without_state_reward(): assert not result.reward_validation_failed -def test_validate_benchmark_semantics(env: LlvmEnv, validatable_benchmark_name: str): - """Run the validation routine on all benchmarks.""" - env.reward_space = "IrInstructionCount" - env.reset(benchmark=validatable_benchmark_name) - - # Run a single step. - env.step(env.action_space.flags.index("-mem2reg")) - - # Validate the environment state. - result: ValidationResult = env.validate() - assert not result.error_details - assert result.reward_validated - assert not result.actions_replay_failed - assert not result.reward_validation_failed - assert result.benchmark_semantics_validated - assert not result.benchmark_semantics_validation_failed - assert result.okay() - - -def test_non_validatable_benchmark_validate( - env: LlvmEnv, non_validatable_benchmark_name: str -): - """Run the validation routine on all benchmarks.""" - env.reward_space = "IrInstructionCount" - env.reset(benchmark=non_validatable_benchmark_name) +def test_no_validation_callback_for_custom_benchmark(env: LlvmEnv): + """Test that a custom benchmark has no validation callback.""" + with tempfile.TemporaryDirectory() as d: + p = Path(d) / "example.c" + with open(p, "w") as f: + print("int main() {return 0;}", file=f) + benchmark = env.make_benchmark(p) - # Run a single step. - env.step(env.action_space.flags.index("-mem2reg")) + env.reset(benchmark=benchmark) - # Validate the environment state. - result: ValidationResult = env.validate() - assert not result.error_details - assert result.reward_validated - assert not result.actions_replay_failed - assert not result.reward_validation_failed - assert not result.benchmark_semantics_validated - assert not result.benchmark_semantics_validation_failed - assert result.okay() + assert not env.benchmark.is_validatable() if __name__ == "__main__": diff --git a/tests/llvm/validation_regression_test.py b/tests/llvm/validation_regression_test.py index db27dc5bd..11b3fc104 100644 --- a/tests/llvm/validation_regression_test.py +++ b/tests/llvm/validation_regression_test.py @@ -20,14 +20,14 @@ # A list of CSV states that should pass validation, to be used as regression # tests. REGRESSION_TEST_STATES = """ -benchmark://cBench-v1/rijndael,,,opt -gvn -loop-unroll -instcombine -gvn -loop-unroll -instcombine input.bc -o output.bc -benchmark://cBench-v1/rijndael,,,opt -gvn -loop-unroll -mem2reg -loop-rotate -gvn -loop-unroll -mem2reg -loop-rotate input.bc -o output.bc -benchmark://cBench-v1/rijndael,,,opt -gvn-hoist input.bc -o output.bc -benchmark://cBench-v1/rijndael,,,opt -jump-threading -sink -partial-inliner -mem2reg -inline -jump-threading -sink -partial-inliner -mem2reg -inline input.bc -o output.bc -benchmark://cBench-v1/rijndael,,,opt -mem2reg -indvars -loop-unroll -simplifycfg -mem2reg -indvars -loop-unroll -simplifycfg input.bc -o output.bc -benchmark://cBench-v1/rijndael,,,opt -mem2reg -instcombine -early-cse-memssa -loop-unroll input.bc -o output.bc -benchmark://cBench-v1/rijndael,,,opt -reg2mem -licm -reg2mem -licm -reg2mem -licm input.bc -o output.bc -benchmark://cBench-v1/rijndael,,,opt -sroa -simplifycfg -partial-inliner input.bc -o output.bc +benchmark://cbench-v1/rijndael,,,opt -gvn -loop-unroll -instcombine -gvn -loop-unroll -instcombine input.bc -o output.bc +benchmark://cbench-v1/rijndael,,,opt -gvn -loop-unroll -mem2reg -loop-rotate -gvn -loop-unroll -mem2reg -loop-rotate input.bc -o output.bc +benchmark://cbench-v1/rijndael,,,opt -gvn-hoist input.bc -o output.bc +benchmark://cbench-v1/rijndael,,,opt -jump-threading -sink -partial-inliner -mem2reg -inline -jump-threading -sink -partial-inliner -mem2reg -inline input.bc -o output.bc +benchmark://cbench-v1/rijndael,,,opt -mem2reg -indvars -loop-unroll -simplifycfg -mem2reg -indvars -loop-unroll -simplifycfg input.bc -o output.bc +benchmark://cbench-v1/rijndael,,,opt -mem2reg -instcombine -early-cse-memssa -loop-unroll input.bc -o output.bc +benchmark://cbench-v1/rijndael,,,opt -reg2mem -licm -reg2mem -licm -reg2mem -licm input.bc -o output.bc +benchmark://cbench-v1/rijndael,,,opt -sroa -simplifycfg -partial-inliner input.bc -o output.bc """ REGRESSION_TEST_STATES = [ CompilerEnvState.from_csv(s) for s in REGRESSION_TEST_STATES.strip().split("\n") @@ -38,7 +38,7 @@ # A list of CSV states that are known to fail validation. KNOWN_BAD_STATES = """ -benchmark://cBench-v1/susan,0.40581008446378297,6.591785192489624,opt -mem2reg -reg2mem -gvn -reg2mem -gvn -newgvn input.bc -o output.bc +benchmark://cbench-v1/susan,0.40581008446378297,6.591785192489624,opt -mem2reg -reg2mem -gvn -reg2mem -gvn -newgvn input.bc -o output.bc """ KNOWN_BAD_STATES = [ CompilerEnvState.from_csv(s) for s in KNOWN_BAD_STATES.strip().split("\n") if s @@ -48,10 +48,10 @@ # NOTE(github.com/facebookresearch/CompilerGym/issues/103): The following # regresison tests are deprecated after -structurizecfg was deactivated: # -# benchmark://cBench-v1/tiff2bw,,,opt -structurizecfg input.bc -o output.bc -# benchmark://cBench-v1/tiff2rgba,,,opt -structurizecfg input.bc -o output.bc -# benchmark://cBench-v1/tiffdither,,,opt -structurizecfg input.bc -o output.bc -# benchmark://cBench-v1/tiffmedian,,,opt -structurizecfg input.bc -o output.bc +# benchmark://cbench-v1/tiff2bw,,,opt -structurizecfg input.bc -o output.bc +# benchmark://cbench-v1/tiff2rgba,,,opt -structurizecfg input.bc -o output.bc +# benchmark://cbench-v1/tiffdither,,,opt -structurizecfg input.bc -o output.bc +# benchmark://cbench-v1/tiffmedian,,,opt -structurizecfg input.bc -o output.bc @skip_on_ci diff --git a/tests/pytest_plugins/BUILD b/tests/pytest_plugins/BUILD index 04d82fe5e..6c2b9f1ad 100644 --- a/tests/pytest_plugins/BUILD +++ b/tests/pytest_plugins/BUILD @@ -14,11 +14,12 @@ py_library( srcs = ["llvm.py"], data = [ "//compiler_gym/envs/llvm/service/passes:actions_genfiles", - "//compiler_gym/third_party/cBench:benchmarks_list", + "//compiler_gym/third_party/cbench:benchmarks_list", ], deps = [ - "//compiler_gym", + "//compiler_gym/envs/llvm", "//compiler_gym/third_party/llvm", + "//compiler_gym/util", ], ) diff --git a/tests/pytest_plugins/llvm.py b/tests/pytest_plugins/llvm.py index 2b93a14cc..8a1f84b7b 100644 --- a/tests/pytest_plugins/llvm.py +++ b/tests/pytest_plugins/llvm.py @@ -10,8 +10,8 @@ import gym import pytest -from compiler_gym.envs import CompilerEnv -from compiler_gym.envs.llvm.legacy_datasets import VALIDATORS +from compiler_gym.envs.llvm import LlvmEnv +from compiler_gym.envs.llvm.datasets.cbench import VALIDATORS from compiler_gym.third_party import llvm from compiler_gym.util.runfiles_path import runfiles_path @@ -19,7 +19,7 @@ runfiles_path("compiler_gym/envs/llvm/service/passes/actions_flags.txt") ) -BENCHMARKS_LIST = Path(runfiles_path("compiler_gym/third_party/cBench/benchmarks.txt")) +BENCHMARKS_LIST = Path(runfiles_path("compiler_gym/third_party/cbench/benchmarks.txt")) def _read_list_file(path: Path) -> Iterable[str]: @@ -35,13 +35,12 @@ def _read_list_file(path: Path) -> Iterable[str]: # Skip ghostscript on CI as it is just too heavy. if bool(os.environ.get("CI")): BENCHMARK_NAMES = [ - b for b in BENCHMARK_NAMES if b != "benchmark://cBench-v1/ghostscript" + b for b in BENCHMARK_NAMES if b != "benchmark://cbench-v1/ghostscript" ] -_env = gym.make("llvm-v0") -OBSERVATION_SPACE_NAMES = sorted(_env.observation.spaces.keys()) -REWARD_SPACE_NAMES = sorted(_env.reward.spaces.keys()) -_env.close() +with gym.make("llvm-v0") as env: + OBSERVATION_SPACE_NAMES = sorted(env.observation.spaces.keys()) + REWARD_SPACE_NAMES = sorted(env.reward.spaces.keys()) @pytest.fixture(scope="module") @@ -78,43 +77,32 @@ def benchmark_name(request) -> str: yield request.param -VALIDATABLE_BENCHMARKS = [b for b in BENCHMARK_NAMES if b in VALIDATORS] -NON_VALIDATABLE_BENCHMARKS = [b for b in BENCHMARK_NAMES if b not in VALIDATORS] +VALIDATABLE_CBENCH_URIS = [b for b in BENCHMARK_NAMES if b in VALIDATORS] +NON_VALIDATABLE_CBENCH_URIS = [b for b in BENCHMARK_NAMES if b not in VALIDATORS] -@pytest.fixture(scope="module", params=VALIDATABLE_BENCHMARKS) -def validatable_benchmark_name(request) -> str: +@pytest.fixture(scope="module", params=VALIDATABLE_CBENCH_URIS) +def validatable_cbench_uri(request) -> str: """Enumerate the names of benchmarks whose semantics can be validated.""" yield request.param -@pytest.fixture(scope="module", params=NON_VALIDATABLE_BENCHMARKS) -def non_validatable_benchmark_name(request) -> str: +@pytest.fixture(scope="module", params=NON_VALIDATABLE_CBENCH_URIS) +def non_validatable_cbench_uri(request) -> str: """Enumerate the names of benchmarks whose semantics cannot be validated.""" yield request.param @pytest.fixture(scope="function") -def env() -> CompilerEnv: +def env() -> LlvmEnv: """Create an LLVM environment.""" env = gym.make("llvm-v0") - env.require_dataset("cBench-v1") try: yield env finally: env.close() -@pytest.fixture(scope="module") -def cBench_dataset(): - """Test fixture that ensures that cBench is available.""" - env = gym.make("llvm-v0") - try: - env.require_dataset("cBench-v1") - finally: - env.close() - - @pytest.fixture(scope="module") def llvm_opt() -> Path: """Test fixture that yields the path of opt.""" diff --git a/tests/random_search_test.py b/tests/random_search_test.py index 884b9dc1d..d29a78483 100644 --- a/tests/random_search_test.py +++ b/tests/random_search_test.py @@ -7,25 +7,23 @@ from pathlib import Path import gym -from absl import flags from compiler_gym.random_replay import replay_actions_from_logs from compiler_gym.random_search import random_search +from tests.pytest_plugins.common import set_command_line_flags from tests.test_main import main def make_env(): env = gym.make("llvm-autophase-ic-v0") - env.require_dataset("cBench-v1") - env.benchmark = "cBench-v1/dijkstra" + env.benchmark = "cbench-v1/dijkstra" return env def test_random_search_smoke_test(): with tempfile.TemporaryDirectory() as tmp: outdir = Path(tmp) - flags.FLAGS.unparse_flags() - flags.FLAGS(["argv0"]) + set_command_line_flags(["argv0"]) random_search( make_env=make_env, outdir=outdir, diff --git a/tests/test_main.py b/tests/test_main.py index ede3f6324..f303acc5e 100644 --- a/tests/test_main.py +++ b/tests/test_main.py @@ -6,10 +6,8 @@ import sys from typing import List, Optional -import gym import pytest -import compiler_gym # noqa Register environments. from compiler_gym.util import debug_util as dbg @@ -40,14 +38,6 @@ def test_foo(): os.environ["COMPILER_GYM_SITE_DATA"] = "/tmp/compiler_gym/tests/site_data" os.environ["COMPILER_GYM_CACHE"] = "/tmp/compiler_gym/tests/cache" - # Install some benchmarks for the LLVM environment as otherwise - # reset() will fail. - env = gym.make("llvm-v0") - try: - env.require_dataset("cBench-v1") - finally: - env.close() - pytest_args = sys.argv + ["-vv"] # Support for sharding. If a py_test target has the shard_count attribute # set (in the range [1,50]), then the pytest-shard module is used to divide diff --git a/tests/util/minimize_trajectory_test.py b/tests/util/minimize_trajectory_test.py index e4fb105d0..5cb33a6a1 100644 --- a/tests/util/minimize_trajectory_test.py +++ b/tests/util/minimize_trajectory_test.py @@ -150,7 +150,7 @@ def hypothesis(env): def test_minimize_trajectory_iteratively_llvm_crc32(env): """Test trajectory minimization on a real environment.""" - env.reset(benchmark="cBench-v1/crc32") + env.reset(benchmark="cbench-v1/crc32") env.step( [ env.action_space["-mem2reg"], diff --git a/tests/validate_test.py b/tests/validate_test.py index 596799b25..0bce2cbaf 100644 --- a/tests/validate_test.py +++ b/tests/validate_test.py @@ -14,7 +14,7 @@ @pytest.mark.parametrize("nproc", (1, 2)) def test_validate_states_lambda_callback(inorder, nproc): state = CompilerEnvState( - benchmark="benchmark://cBench-v1/crc32", + benchmark="benchmark://cbench-v1/crc32", walltime=1, commandline="opt input.bc -o output.bc", ) @@ -22,7 +22,6 @@ def test_validate_states_lambda_callback(inorder, nproc): validate_states( make_env=lambda: gym.make("llvm-v0"), states=[state], - datasets=["cBench-v1"], inorder=inorder, nproc=nproc, )