react-native-quick-crypto 1.0.18 → 1.1.0

package/deps/simdutf/benchmarks/src/benchmark.cpp

@@ -0,0 +1,3899 @@
+#include "benchmark.h"
+#include "simdutf.h"
+
+#include <cassert>
+#include <array>
+#include <iostream>
+#include <chrono>
+#include <thread>
+#include <string>
+#include <vector>
+#ifdef __x86_64__
+/**
+ * utf8lut: Vectorized UTF-8 converter.
+ * by stgatilov (2019)
+ *  https://dirtyhandscoding.github.io/posts/utf8lut-vectorized-utf-8-converter-introduction.html
+ */
+SIMDUTF_TARGET_WESTMERE
+namespace {
+  #include "benchmarks/competition/utf8lut/src/utf8lut.h"
+}
+SIMDUTF_UNTARGET_REGION
+
+  /**
+   * Bob Steagall, CppCon2018
+   * https://github.com/BobSteagall/CppCon2018/
+   *
+   * Fast Conversion From UTF-8 with C++, DFAs, and SSE Intrinsics
+   * https://www.youtube.com/watch?v=5FQ87-Ecb-A
+   */
+  #include "benchmarks/competition/CppCon2018/utf_utils.cpp"
+#endif
+
+/**
+ * Bjoern Hoehrmann
+ * http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+ */
+#include "benchmarks/competition/hoehrmann/hoehrmann.h"
+/**
+ * LLVM relies on code from the Unicode Consortium
+ * https://en.wikipedia.org/wiki/Unicode_Consortium
+ */
+#include "benchmarks/competition/llvm/ConvertUTF.cpp"
+#ifdef __x86_64__
+  /**
+   * Olivier Goffart, UTF-8 processing using SIMD (SSE4), 2012.
+   * https://woboq.com/blog/utf-8-processing-using-simd.html
+   */
+  #include "benchmarks/competition/utf8sse4/fromutf8-sse.cpp"
+#endif
+
+#ifdef __x86_64__
+  /**
+   * benchmarks/competition/u8u16 contains an open source version of u8u16,
+   * referenced in Cameron, Robert D, A case study in SIMD text processing with
+   * parallel bit streams: UTF-8 to UTF-16 transcoding, Proceedings of the 13th
+   * ACM SIGPLAN Symposium on Principles and practice of parallel programming,
+   * 91--98.
+   */
+  // It seems that u8u16 is not good at scoping macros.
+  #undef LITTLE_ENDIAN
+  #undef BYTE_ORDER
+  #undef BIG_ENDIAN
+  #include "benchmarks/competition/u8u16/config/p4_config.h"
+  #include "benchmarks/competition/u8u16/src/libu8u16.c"
+#endif
+
+/**
+ * Nemanja Trifunovic, UTF8-CPP: UTF-8 with C++ in a Portable Way
+ * https://github.com/nemtrif/utfcpp/releases/tag/v3.2.2
+ */
+#include "benchmarks/competition/utfcpp/source/utf8.h"
+
+namespace simdutf::benchmarks {
+
+template <typename Fn>
+void Benchmark::register_function(std::string name, Fn function,
+                                  std::set<simdutf::encoding_type> set) {
+
+  if (name.find('+') == std::string::npos) {
+    // adding simdutf benchmark, populate for all known architectures
+    for (const auto &impl : simdutf::get_available_implementations()) {
+      const auto full_name = name + '+' + impl->name();
+      benchmarks.insert({full_name, std::make_pair(function, set)});
+    }
+  } else {
+    benchmarks.insert({name, std::make_pair(function, set)});
+  }
+}
+
+template <typename Fn>
+void Benchmark::register_function(std::string name, Fn function,
+                                  simdutf::encoding_type enc1) {
+  std::set<simdutf::encoding_type> set{enc1};
+  register_function(name, function, set);
+}
+
+template <typename Fn>
+void Benchmark::register_function(std::string name, Fn function,
+                                  simdutf::encoding_type enc1,
+                                  simdutf::encoding_type enc2) {
+  std::set<simdutf::encoding_type> set{enc1, enc2};
+  register_function(name, function, set);
+}
+
+template <typename Fn>
+void Benchmark::register_function(std::string name, Fn function,
+                                  simdutf::encoding_type enc1,
+                                  simdutf::encoding_type enc2,
+                                  simdutf::encoding_type enc3) {
+  std::set<simdutf::encoding_type> set{enc1, enc2, enc3};
+  register_function(name, function, set);
+}
+
+Benchmark::Benchmark(std::vector<input::Testcase> &&testcases)
+    : BenchmarkBase(std::move(testcases)) {
+  register_function("to_well_formed_utf16le",
+                    &Benchmark::run_to_well_formed_utf16le,
+                    simdutf::encoding_type::UTF16_LE);
+  register_function("naive_validate_ascii",
+                    &Benchmark::run_naive_validate_ascii,
+                    simdutf::encoding_type::UTF8);
+  register_function("validate_ascii", &Benchmark::run_validate_ascii,
+                    simdutf::encoding_type::UTF8);
+  register_function("validate_ascii_with_errors",
+                    &Benchmark::run_validate_ascii_with_errors,
+                    simdutf::encoding_type::UTF8);
+  register_function("validate_utf8", &Benchmark::run_validate_utf8,
+                    simdutf::encoding_type::UTF8);
+  register_function("validate_utf8_with_errors",
+                    &Benchmark::run_validate_utf8_with_errors,
+                    simdutf::encoding_type::UTF8);
+  register_function("validate_utf16le", &Benchmark::run_validate_utf16le,
+                    simdutf::encoding_type::UTF16_LE);
+  register_function("validate_utf16le_with_errors",
+                    &Benchmark::run_validate_utf16le_with_errors,
+                    simdutf::encoding_type::UTF16_LE);
+  register_function("validate_utf32", &Benchmark::run_validate_utf32,
+                    simdutf::encoding_type::UTF32_LE);
+  register_function("validate_utf32_with_errors",
+                    &Benchmark::run_validate_utf32_with_errors,
+                    simdutf::encoding_type::UTF32_LE);
+
+  register_function("count_utf8", &Benchmark::run_count_utf8,
+                    simdutf::encoding_type::UTF8);
+  register_function("count_utf16le", &Benchmark::run_count_utf16le,
+                    simdutf::encoding_type::UTF16_LE);
+
+  register_function("utf8_length_from_latin1",
+                    &Benchmark::run_utf8_length_from_latin1,
+                    simdutf::encoding_type::Latin1);
+  register_function("utf8_length_from_utf16le",
+                    &Benchmark::run_utf8_length_from_utf16le,
+                    simdutf::encoding_type::UTF16_LE);
+  register_function("utf8_length_from_utf16le_with_replacement",
+                    &Benchmark::run_utf8_length_from_utf16le_with_replacement,
+                    simdutf::encoding_type::UTF16_LE);
+  register_function("utf8_length_from_utf16be",
+                    &Benchmark::run_utf8_length_from_utf16be,
+                    simdutf::encoding_type::UTF16_BE);
+  register_function("utf8_length_from_utf16be_with_replacement",
+                    &Benchmark::run_utf8_length_from_utf16be_with_replacement,
+                    simdutf::encoding_type::UTF16_BE);
+  register_function("utf8_length_from_utf32",
+                    &Benchmark::run_utf8_length_from_utf32,
+                    simdutf::encoding_type::UTF32_LE);
+  register_function("utf16_length_from_utf8",
+                    &Benchmark::run_utf16_length_from_utf8,
+                    simdutf::encoding_type::UTF8);
+  register_function("convert_latin1_to_utf8",
+                    &Benchmark::run_convert_latin1_to_utf8,
+                    simdutf::encoding_type::Latin1);
+  register_function("convert_latin1_to_utf16le",
+                    &Benchmark::run_convert_latin1_to_utf16le,
+                    simdutf::encoding_type::Latin1);
+  register_function("convert_latin1_to_utf32",
+                    &Benchmark::run_convert_latin1_to_utf32,
+                    simdutf::encoding_type::Latin1);
+
+  register_function("convert_utf8_to_latin1",
+                    &Benchmark::run_convert_utf8_to_latin1,
+                    simdutf::encoding_type::UTF8);
+  register_function("convert_utf8_to_latin1_with_errors",
+                    &Benchmark::run_convert_utf8_to_latin1_with_errors,
+                    simdutf::encoding_type::UTF8);
+  register_function("convert_valid_utf8_to_latin1",
+                    &Benchmark::run_convert_valid_utf8_to_latin1,
+                    simdutf::encoding_type::UTF8);
+
+  register_function("convert_utf8_to_utf16le",
+                    &Benchmark::run_convert_utf8_to_utf16le,
+                    simdutf::encoding_type::UTF8);
+  register_function("convert_utf8_to_utf16le_with_errors",
+                    &Benchmark::run_convert_utf8_to_utf16le_with_errors,
+                    simdutf::encoding_type::UTF8);
+  register_function(
+      "convert_utf8_to_utf16le_with_dynamic_allocation",
+      &Benchmark::run_convert_utf8_to_utf16le_with_dynamic_allocation,
+      simdutf::encoding_type::UTF8);
+  register_function("convert_valid_utf8_to_utf16le",
+                    &Benchmark::run_convert_valid_utf8_to_utf16le,
+                    simdutf::encoding_type::UTF8);
+
+  register_function("convert_utf8_to_utf32",
+                    &Benchmark::run_convert_utf8_to_utf32,
+                    simdutf::encoding_type::UTF8);
+  register_function("convert_utf8_to_utf32_with_errors",
+                    &Benchmark::run_convert_utf8_to_utf32_with_errors,
+                    simdutf::encoding_type::UTF8);
+  register_function(
+      "convert_utf8_to_utf32_with_dynamic_allocation",
+      &Benchmark::run_convert_utf8_to_utf32_with_dynamic_allocation,
+      simdutf::encoding_type::UTF8);
+  register_function("convert_valid_utf8_to_utf32",
+                    &Benchmark::run_convert_valid_utf8_to_utf32,
+                    simdutf::encoding_type::UTF8);
+
+  register_function("convert_utf16le_to_latin1",
+                    &Benchmark::run_convert_utf16le_to_latin1,
+                    simdutf::encoding_type::UTF16_LE);
+  register_function("convert_utf16le_to_latin1_with_errors",
+                    &Benchmark::run_convert_utf16le_to_latin1_with_errors,
+                    simdutf::encoding_type::UTF16_LE);
+  register_function("convert_valid_utf16le_to_latin1",
+                    &Benchmark::run_convert_valid_utf16le_to_latin1,
+                    simdutf::encoding_type::UTF16_LE);
+#if SIMDUTF_IS_BIG_ENDIAN
+  register_function("convert_utf16_to_utf8_safe",
+                    &Benchmark::run_convert_utf16_to_utf8_safe,
+                    simdutf::encoding_type::UTF16_BE);
+#else
+  register_function("convert_utf16_to_utf8_safe",
+                    &Benchmark::run_convert_utf16_to_utf8_safe,
+                    simdutf::encoding_type::UTF16_LE);
+#endif // SIMDUTF_IS_BIG_ENDIAN
+  register_function("convert_utf16le_to_utf8",
+                    &Benchmark::run_convert_utf16le_to_utf8,
+                    simdutf::encoding_type::UTF16_LE);
+  register_function("convert_utf16le_to_utf8_with_errors",
+                    &Benchmark::run_convert_utf16le_to_utf8_with_errors,
+                    simdutf::encoding_type::UTF16_LE);
+  register_function(
+      "convert_utf16le_to_utf8_with_dynamic_allocation",
+      &Benchmark::run_convert_utf16le_to_utf8_with_dynamic_allocation,
+      simdutf::encoding_type::UTF16_LE);
+  register_function("convert_valid_utf16le_to_utf8",
+                    &Benchmark::run_convert_valid_utf16le_to_utf8,
+                    simdutf::encoding_type::UTF16_LE);
+
+  register_function("convert_utf16le_to_utf32",
+                    &Benchmark::run_convert_utf16le_to_utf32,
+                    simdutf::encoding_type::UTF16_LE);
+  register_function("convert_utf16le_to_utf32_with_errors",
+                    &Benchmark::run_convert_utf16le_to_utf32_with_errors,
+                    simdutf::encoding_type::UTF16_LE);
+  register_function(
+      "convert_utf16le_to_utf32_with_dynamic_allocation",
+      &Benchmark::run_convert_utf16le_to_utf32_with_dynamic_allocation,
+      simdutf::encoding_type::UTF16_LE);
+  register_function("convert_valid_utf16le_to_utf32",
+                    &Benchmark::run_convert_valid_utf16le_to_utf32,
+                    simdutf::encoding_type::UTF16_LE);
+
+  register_function("convert_utf32_to_latin1",
+                    &Benchmark::run_convert_utf32_to_latin1,
+                    simdutf::encoding_type::UTF32_LE);
+  register_function("convert_utf32_to_latin1_with_errors",
+                    &Benchmark::run_convert_utf32_to_latin1_with_errors,
+                    simdutf::encoding_type::UTF32_LE);
+  register_function("convert_valid_utf32_to_latin1",
+                    &Benchmark::run_convert_valid_utf32_to_latin1,
+                    simdutf::encoding_type::UTF32_LE);
+
+  register_function("convert_utf32_to_utf8",
+                    &Benchmark::run_convert_utf32_to_utf8,
+                    simdutf::encoding_type::UTF32_LE);
+  register_function("convert_utf32_to_utf8_with_errors",
+                    &Benchmark::run_convert_utf32_to_utf8_with_errors,
+                    simdutf::encoding_type::UTF32_LE);
+  register_function("convert_valid_utf32_to_utf8",
+                    &Benchmark::run_convert_valid_utf32_to_utf8,
+                    simdutf::encoding_type::UTF32_LE);
+
+  register_function("convert_utf32_to_utf16le",
+                    &Benchmark::run_convert_utf32_to_utf16<endianness::LITTLE>,
+                    simdutf::encoding_type::UTF32_LE);
+  register_function("convert_utf32_to_utf16be",
+                    &Benchmark::run_convert_utf32_to_utf16<endianness::BIG>,
+                    simdutf::encoding_type::UTF32_LE);
+  register_function(
+      "convert_utf32_to_utf16le_with_errors",
+      &Benchmark::run_convert_utf32_to_utf16_with_errors<endianness::LITTLE>,
+      simdutf::encoding_type::UTF32_LE);
+  register_function(
+      "convert_utf32_to_utf16be_with_errors",
+      &Benchmark::run_convert_utf32_to_utf16_with_errors<endianness::BIG>,
+      simdutf::encoding_type::UTF32_LE);
+  register_function(
+      "convert_valid_utf32_to_utf16le",
+      &Benchmark::run_convert_valid_utf32_to_utf16<endianness::LITTLE>,
+      simdutf::encoding_type::UTF32_LE);
+  register_function(
+      "convert_valid_utf32_to_utf16be",
+      &Benchmark::run_convert_valid_utf32_to_utf16<endianness::BIG>,
+      simdutf::encoding_type::UTF32_LE);
+
+  register_function("detect_encodings", &Benchmark::run_detect_encodings,
+                    simdutf::encoding_type::UTF8,
+                    simdutf::encoding_type::UTF16_LE,
+                    simdutf::encoding_type::UTF32_LE);
+
+#ifdef ICU_AVAILABLE
+  register_function("convert_latin1_to_utf8+icu",
+                    &Benchmark::run_convert_latin1_to_utf8_icu,
+                    simdutf::encoding_type::Latin1);
+  register_function("convert_latin1_to_utf16+icu",
+                    &Benchmark::run_convert_latin1_to_utf16_icu,
+                    simdutf::encoding_type::Latin1);
+  register_function("convert_latin1_to_utf32+icu",
+                    &Benchmark::run_convert_latin1_to_utf32_icu,
+                    simdutf::encoding_type::Latin1);
+  register_function("convert_utf8_to_latin1+icu",
+                    &Benchmark::run_convert_utf8_to_latin1_icu,
+                    simdutf::encoding_type::UTF8);
+  register_function("convert_utf8_to_utf16+icu",
+                    &Benchmark::run_convert_utf8_to_utf16_icu,
+                    simdutf::encoding_type::UTF8);
+  register_function("convert_utf16_to_utf8+icu",
+                    &Benchmark::run_convert_utf16_to_utf8_icu,
+                    simdutf::encoding_type::UTF16_LE);
+  register_function("convert_utf16_to_latin1+icu",
+                    &Benchmark::run_convert_utf16_to_latin1_icu,
+                    simdutf::encoding_type::UTF16_LE);
+  register_function("convert_utf32_to_latin1+icu",
+                    &Benchmark::run_convert_utf32_to_latin1_icu,
+                    simdutf::encoding_type::UTF32_LE);
+#endif
+#ifdef ICONV_AVAILABLE
+  register_function("convert_latin1_to_utf8+iconv",
+                    &Benchmark::run_convert_latin1_to_utf8_iconv,
+                    simdutf::encoding_type::Latin1);
+  register_function("convert_latin1_to_utf16+iconv",
+                    &Benchmark::run_convert_latin1_to_utf16_iconv,
+                    simdutf::encoding_type::Latin1);
+  register_function("convert_latin1_to_utf32+iconv",
+                    &Benchmark::run_convert_latin1_to_utf32_iconv,
+                    simdutf::encoding_type::Latin1);
+  register_function("convert_utf8_to_latin1+iconv",
+                    &Benchmark::run_convert_utf8_to_latin1_iconv,
+                    simdutf::encoding_type::UTF8);
+  register_function("convert_utf8_to_utf16+iconv",
+                    &Benchmark::run_convert_utf8_to_utf16_iconv,
+                    simdutf::encoding_type::UTF8);
+  register_function("convert_utf16_to_utf8+iconv",
+                    &Benchmark::run_convert_utf16_to_utf8_iconv,
+                    simdutf::encoding_type::UTF16_LE);
+  register_function("convert_utf16_to_latin1+iconv",
+                    &Benchmark::run_convert_utf16_to_latin1_iconv,
+                    simdutf::encoding_type::UTF16_LE);
+  register_function("convert_utf32_to_latin1+iconv",
+                    &Benchmark::run_convert_utf32_to_latin1_iconv,
+                    simdutf::encoding_type::UTF32_LE);
+#endif
+#ifdef INOUE2008
+  register_function("convert_valid_utf8_to_utf16+inoue2008",
+                    &Benchmark::run_convert_valid_utf8_to_utf16_inoue2008,
+                    simdutf::encoding_type::UTF8);
+#endif
+#ifdef __x86_64__
+  register_function("convert_utf8_to_utf16+u8u16",
+                    &Benchmark::run_convert_utf8_to_utf16_u8u16,
+                    simdutf::encoding_type::UTF8);
+  register_function("convert_utf16_to_utf8+utf8lut",
+                    &Benchmark::run_convert_valid_utf8_to_utf16_utf8lut,
+                    simdutf::encoding_type::UTF16_LE);
+  register_function("convert_valid_utf16_to_utf8+utf8lut",
+                    &Benchmark::run_convert_valid_utf16_to_utf8_utf8lut,
+                    simdutf::encoding_type::UTF16_LE);
+  register_function("convert_utf8_to_utf16+utf8lut",
+                    &Benchmark::run_convert_valid_utf8_to_utf16_utf8lut,
+                    simdutf::encoding_type::UTF8);
+  register_function("convert_utf8_to_utf32+utf8lut",
+                    &Benchmark::run_convert_utf8_to_utf32_utf8lut,
+                    simdutf::encoding_type::UTF8);
+  register_function("convert_valid_utf8_to_utf16+utf8lut",
+                    &Benchmark::run_convert_valid_utf8_to_utf16_utf8lut,
+                    simdutf::encoding_type::UTF8);
+  register_function("convert_utf32_to_utf8+utf8lut",
+                    &Benchmark::run_convert_valid_utf32_to_utf8_utf8lut,
+                    simdutf::encoding_type::UTF32_LE);
+  register_function("convert_valid_utf32_to_utf8+utf8lut",
+                    &Benchmark::run_convert_valid_utf32_to_utf8_utf8lut,
+                    simdutf::encoding_type::UTF32_BE);
+  register_function("convert_valid_utf8_to_utf32+utf8lut",
+                    &Benchmark::run_convert_utf8_to_utf32_utf8lut,
+                    simdutf::encoding_type::UTF8);
+  register_function("convert_utf8_to_utf16+utf8sse4",
+                    &Benchmark::run_convert_utf8_to_utf16_utf8sse4,
+                    simdutf::encoding_type::UTF8);
+  register_function("convert_utf8_to_utf16+cppcon2018",
+                    &Benchmark::run_convert_utf8_to_utf16_cppcon2018,
+                    simdutf::encoding_type::UTF8);
+  register_function("convert_utf8_to_utf32+cppcon2018",
+                    &Benchmark::run_convert_utf8_to_utf32_cppcon2018,
+                    simdutf::encoding_type::UTF8);
+#endif
+  register_function("convert_utf8_to_utf16+hoehrmann",
+                    &Benchmark::run_convert_utf8_to_utf16_hoehrmann,
+                    simdutf::encoding_type::UTF8);
+  register_function("convert_utf8_to_utf32+hoehrmann",
+                    &Benchmark::run_convert_utf8_to_utf32_hoehrmann,
+                    simdutf::encoding_type::UTF8);
+
+  register_function("convert_utf8_to_utf16+llvm",
+                    &Benchmark::run_convert_utf8_to_utf16_llvm,
+                    simdutf::encoding_type::UTF8);
+  register_function("convert_utf8_to_utf32+llvm",
+                    &Benchmark::run_convert_utf8_to_utf32_llvm,
+                    simdutf::encoding_type::UTF8);
+  register_function("convert_utf16_to_utf8+llvm",
+                    &Benchmark::run_convert_utf16_to_utf8_llvm,
+                    simdutf::encoding_type::UTF16_LE);
+  register_function("convert_utf32_to_utf8+llvm",
+                    &Benchmark::run_convert_utf32_to_utf8_llvm,
+                    simdutf::encoding_type::UTF32_LE);
+  register_function("convert_utf32_to_utf16+llvm",
+                    &Benchmark::run_convert_utf32_to_utf16_llvm,
+                    simdutf::encoding_type::UTF32_LE);
+  register_function("convert_utf16_to_utf32+llvm",
+                    &Benchmark::run_convert_utf16_to_utf32_llvm,
+                    simdutf::encoding_type::UTF16_LE);
+
+  register_function("convert_utf8_to_utf16+utfcpp",
+                    &Benchmark::run_convert_utf8_to_utf16_utfcpp,
+                    simdutf::encoding_type::UTF8);
+  register_function("convert_utf8_to_utf32+utfcpp",
+                    &Benchmark::run_convert_utf8_to_utf32_utfcpp,
+                    simdutf::encoding_type::UTF8);
+  register_function("convert_utf16_to_utf8+utfcpp",
+                    &Benchmark::run_convert_utf16_to_utf8_utfcpp,
+                    simdutf::encoding_type::UTF16_LE);
+  register_function("convert_utf32_to_utf8+utfcpp",
+                    &Benchmark::run_convert_utf32_to_utf8_utfcpp,
+                    simdutf::encoding_type::UTF32_LE);
+
+  register_function("utf8_length_from_latin1+node",
+                    &Benchmark::run_utf8_length_from_latin1_node,
+                    simdutf::encoding_type::Latin1);
+}
+
+// static
+Benchmark Benchmark::create(const CommandLine &cmdline) {
+  std::vector<input::Testcase> testcases;
+
+  using input::File;
+  using input::random_utf8;
+  using input::Testcase;
+
+  for (const size_t iterations : cmdline.iterations) {
+    for (const auto &path : cmdline.files) {
+      testcases.emplace_back(
+          Testcase{cmdline.procedures, iterations, File{path}});
+    }
+
+    for (const size_t size : cmdline.random_size) {
+      testcases.emplace_back(
+          Testcase{cmdline.procedures, iterations, random_utf8{size}});
+    }
+  }
+
+  return Benchmark{std::move(testcases)};
+}
+
+void Benchmark::list_procedures(ListingMode lm) const {
+  switch (lm) {
+  case ListingMode::None:
+    break;
+
+  case ListingMode::HumanReadable: {
+    const auto &known_procedures = all_procedures();
+    printf("Available procedures (%zu)\n", size_t(known_procedures.size()));
+    for (const auto &name : known_procedures) {
+      printf("- %s\n", name.c_str());
+    }
+  } break;
+
+  case ListingMode::PlainLines: {
+    const auto &known_procedures = all_procedures();
+    for (const auto &name : known_procedures) {
+      puts(name.c_str());
+    }
+    break;
+  }
+
+  case ListingMode::Json: {
+    printf("[\n");
+    auto first = true;
+    for (const auto &item : benchmarks) {
+      const auto &name = item.first;
+      const auto &entry = item.second;
+      if (!first) {
+        putchar(',');
+      }
+      first = false;
+
+      printf(" {\n");
+      printf("    \"name\": \"%s\",\n", name.c_str());
+      if (std::holds_alternative<thirdparty_fn>(entry.first)) {
+        printf("    \"simdutf\": false,\n");
+      } else if (std::holds_alternative<simdutf_fn>(entry.first)) {
+        printf("    \"simdutf\": true,\n");
+      }
+
+      {
+        printf("    \"encodings\": [");
+        bool first = true;
+        for (const auto &enc : entry.second) {
+          if (!first) {
+            putchar(',');
+          }
+          first = false;
+
+          switch (enc) {
+          case simdutf::UTF8:
+            printf("\"utf8\"");
+            break;
+          case simdutf::UTF16_LE:
+            printf("\"utf16le\"");
+            break;
+          case simdutf::UTF16_BE:
+            printf("\"utf16be\"");
+            break;
+          case simdutf::UTF32_LE:
+            printf("\"utf32le\"");
+            break;
+          case simdutf::UTF32_BE:
+            printf("\"utf32be\"");
+            break;
+          case simdutf::Latin1:
+            printf("\"latin1\"");
+            break;
+          default:
+            printf("\"unknown\"");
+            break;
+          }
+        }
+        printf("]\n");
+      } // encodings
+      printf(" }");
+    } // for
+    printf("]\n");
+    break;
+  }
+  }
+}
+
+void Benchmark::run(const std::string &procedure_name, size_t iterations) {
+  const auto item = benchmarks.find(procedure_name);
+  if (item == benchmarks.end()) {
+    std::cerr << "Unsupported procedure: " << procedure_name << '\n';
+    std::cerr << "Report the issue.\n";
+    std::cerr << " Aborting ! " << '\n';
+    exit(1);
+  }
+
+  const auto &entry = item->second;
+  if (std::holds_alternative<thirdparty_fn>(entry.first)) {
+    const auto fn = std::get<thirdparty_fn>(entry.first);
+
+    (this->*fn)(iterations);
+  } else if (std::holds_alternative<simdutf_fn>(entry.first)) {
+    const auto p = procedure_name.find('+');
+    const std::string name{procedure_name.substr(0, p)};
+    const std::string impl{procedure_name.substr(p + 1)};
+
+    auto implementation = simdutf::get_available_implementations()[impl];
+    if (implementation == nullptr) {
+      throw std::runtime_error("Wrong implementation " + impl);
+    }
+    // If you want to skip the CPU feature checks, you can set
+    // a variable when calling the benchmark program. E.g.,
+    // SIMDUTF_SKIP_CPU_CHECK=ON benchmark -F myfile.txt
+    // This might result in a crash (E.g., Illegal instruction).
+    SIMDUTF_PUSH_DISABLE_WARNINGS
+    SIMDUTF_DISABLE_DEPRECATED_WARNING // Disable CRT_SECURE warning on MSVC:
+                                       // manually verified this is safe
+        static const char *skip_check = getenv("SIMDUTF_SKIP_CPU_CHECK");
+    SIMDUTF_POP_DISABLE_WARNINGS
+    if (!skip_check && !implementation->supported_by_runtime_system()) {
+      std::cout << procedure_name << ": unsupported by the system\n";
+      return;
+    }
+
+    const auto fn = std::get<simdutf_fn>(entry.first);
+    (this->*fn)(*implementation, iterations);
+  } else {
+    throw std::logic_error("The entry for '" + procedure_name +
+                           "' is not valid. Please report an issue.");
+  }
+
+  // We pause after each call to make sure
+  // that other benchmarks are not affected by frequency throttling.
+  // This was initially introduced for AVX-512 only, but it is probably
+  // wise to have it always.
+  std::this_thread::sleep_for(std::chrono::milliseconds(10));
+}
+
+void Benchmark::run_validate_utf8(const simdutf::implementation &implementation,
+                                  size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  volatile bool sink{false};
+
+  auto proc = [&implementation, data, size, &sink]() {
+    sink = implementation.validate_utf8(data, size);
+  };
+
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == false) && (iterations > 0)) {
+    std::cerr << "The input was declared invalid.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_validate_utf8_with_errors(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  volatile bool sink{false};
+
+  auto proc = [&implementation, data, size, &sink]() {
+    result res = implementation.validate_utf8_with_errors(data, size);
+    sink = !(res.error);
+  };
+
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == false) && (iterations > 0)) {
+    std::cerr << "The input was declared invalid.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+namespace details {
+bool ascii_is_valid(const char *data, size_t size) {
+  unsigned char result = 0;
+  for (size_t i = 0; i < size; i++) {
+    result |= static_cast<unsigned char>(data[i]);
+  }
+  return (result <= 0x7F);
+}
+} // namespace details
+
+void Benchmark::run_naive_validate_ascii(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  volatile bool sink{false};
+  auto proc = [&implementation, data, size, &sink]() {
+    sink = details::ascii_is_valid(data, size);
+  };
+
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == false) && (iterations > 0)) {
+    std::cerr << "The input was declared invalid.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_validate_ascii(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  volatile bool sink{false};
+
+  auto proc = [&implementation, data, size, &sink]() {
+    sink = implementation.validate_ascii(data, size);
+  };
+
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == false) && (iterations > 0)) {
+    std::cerr << "The input was declared invalid.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_validate_ascii_with_errors(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  volatile bool sink{false};
+
+  auto proc = [&implementation, data, size, &sink]() {
+    result res = implementation.validate_ascii_with_errors(data, size);
+    sink = !(res.error);
+  };
+
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == false) && (iterations > 0)) {
+    std::cerr << "The input was declared invalid.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_validate_utf16le(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char16_t *data = reinterpret_cast<const char16_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 2;
+
+  volatile bool sink{false};
+
+  auto proc = [&implementation, data, size, &sink]() {
+    sink = implementation.validate_utf16le(data, size);
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == false) && (iterations > 0)) {
+    std::cerr << "The input was declared invalid.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_validate_utf16le_with_errors(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char16_t *data = reinterpret_cast<const char16_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 2;
+
+  volatile bool sink{false};
+
+  auto proc = [&implementation, data, size, &sink]() {
+    result res = implementation.validate_utf16le_with_errors(data, size);
+    sink = !(res.error);
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == false) && (iterations > 0)) {
+    std::cerr << "The input was declared invalid.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_validate_utf32(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char32_t *data = reinterpret_cast<const char32_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 4;
+
+  volatile bool sink{false};
+
+  auto proc = [&implementation, data, size, &sink]() {
+    sink = implementation.validate_utf32(data, size);
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == false) && (iterations > 0)) {
+    std::cerr << "The input was declared invalid.\n";
+  }
+  size_t char_count = size;
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_validate_utf32_with_errors(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char32_t *data = reinterpret_cast<const char32_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 4 != 0) {
+    printf(
+        "# The input size is not divisible by four (it is %zu + %zu for BOM)",
+        size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 4;
+
+  volatile bool sink{false};
+
+  auto proc = [&implementation, data, size, &sink]() {
+    result res = implementation.validate_utf32_with_errors(data, size);
+    sink = !(res.error);
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == false) && (iterations > 0)) {
+    std::cerr << "The input was declared invalid.\n";
+  }
+  size_t char_count = size;
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_convert_latin1_to_utf8(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char[]> output_buffer{new char[size * 2]};
+  volatile size_t sink{0};
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    sink =
+        implementation.convert_latin1_to_utf8(data, size, output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = size;
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_latin1_to_utf16le(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char16_t[]> output_buffer{new char16_t[size * 2]};
+  volatile size_t sink{0};
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    sink = implementation.convert_latin1_to_utf16le(data, size,
+                                                    output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = size;
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_latin1_to_utf32(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char32_t[]> output_buffer{new char32_t[size]};
+  volatile size_t sink{0};
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    sink =
+        implementation.convert_latin1_to_utf32(data, size, output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = size;
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_utf8_length_from_latin1(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  volatile size_t sink{0};
+
+  auto proc = [&implementation, data, size, &sink]() {
+    sink = implementation.utf8_length_from_latin1(data, size);
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_utf8_length_from_utf16le(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char16_t *data = reinterpret_cast<const char16_t *>(input_data.data());
+  const size_t size = input_data.size() / 2;
+  volatile size_t sink{0};
+
+  auto proc = [&implementation, data, size, &sink]() {
+    sink = implementation.utf8_length_from_utf16le(data, size);
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  print_summary(result, size, size);
+}
+
+void Benchmark::run_utf8_length_from_utf16be(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char16_t *data = reinterpret_cast<const char16_t *>(input_data.data());
+  const size_t size = input_data.size() / 2;
+  volatile size_t sink{0};
+
+  auto proc = [&implementation, data, size, &sink]() {
+    sink = implementation.utf8_length_from_utf16be(data, size);
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  print_summary(result, size, size);
+}
+
+void Benchmark::run_utf8_length_from_utf16le_with_replacement(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char16_t *data = reinterpret_cast<const char16_t *>(input_data.data());
+  const size_t size = input_data.size() / 2;
+  volatile size_t sink{0};
+
+  auto proc = [&implementation, data, size, &sink]() {
+    auto r =
+        implementation.utf8_length_from_utf16le_with_replacement(data, size);
+    sink = r.count;
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  print_summary(result, size, size);
+}
+
+void Benchmark::run_utf8_length_from_utf16be_with_replacement(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char16_t *data = reinterpret_cast<const char16_t *>(input_data.data());
+  const size_t size = input_data.size() / 2;
+  volatile size_t sink{0};
+
+  auto proc = [&implementation, data, size, &sink]() {
+    auto r =
+        implementation.utf8_length_from_utf16be_with_replacement(data, size);
+    sink = r.count;
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  print_summary(result, size, size);
+}
+
+void Benchmark::run_utf8_length_from_utf32(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char32_t *data = reinterpret_cast<const char32_t *>(input_data.data());
+  const size_t size = input_data.size() / 4;
+  volatile size_t sink{0};
+
+  auto proc = [&implementation, data, size, &sink]() {
+    sink = implementation.utf8_length_from_utf32(data, size);
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  print_summary(result, size, size);
+}
+
+void Benchmark::run_to_well_formed_utf16le(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char16_t *data = reinterpret_cast<const char16_t *>(input_data.data());
+  const size_t size = input_data.size() / 2;
+  std::unique_ptr<char16_t[]> output_buffer{new char16_t[size]};
+  auto proc = [&implementation, data, size, &output_buffer]() {
+    implementation.to_well_formed_utf16le(data, size, output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_utf16_length_from_utf8(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size() / 4;
+  volatile size_t sink{0};
+
+  auto proc = [&implementation, data, size, &sink]() {
+    sink = implementation.utf16_length_from_utf8(data, size);
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  print_summary(result, size, size);
+}
+
+static inline uint32_t portable_popcount(uint64_t v) {
+#ifdef __GNUC__
+  return static_cast<uint32_t>(__builtin_popcountll(v));
+#elif defined(_WIN64) && defined(_MSC_VER) && _MSC_VER >= 1400 &&              \
+    !defined(_M_ARM64)
+  return static_cast<uint32_t>(__popcnt64(static_cast<__int64>(v)));
+#else
+  v = v - ((v >> 1) & 0x5555555555555555);
+  v = (v & 0x3333333333333333) + ((v >> 2) & 0x3333333333333333);
+  v = ((v + (v >> 4)) & 0x0F0F0F0F0F0F0F0F);
+  return static_cast<uint32_t>((v * (0x0101010101010101)) >> 56);
+#endif
+}
+
+void Benchmark::run_utf8_length_from_latin1_node(size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  volatile size_t sink{0};
+
+  auto proc = [data, size, &sink]() {
+    // from https://github.com/nodejs/node/pull/54345
+    uint32_t length = size;
+    uint32_t result = length;
+    uint32_t i = 0;
+    const auto length8 = length & ~0x7;
+    while (i < length8) {
+      // Original PR used std::popcount, but it is not available pre-C++20.
+      result += portable_popcount(
+          *reinterpret_cast<const uint64_t *>(data + i) & 0x8080808080808080);
+      i += 8;
+    }
+    while (i < length) {
+      result += (data[i] >> 7);
+      i++;
+    }
+    sink = result;
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_utf8_to_latin1(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char[]> output_buffer{new char[size]};
+  volatile size_t sink{0};
+
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    sink =
+        implementation.convert_utf8_to_latin1(data, size, output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_utf8_to_latin1_with_errors(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char[]> output_buffer{new char[size]};
+  volatile bool sink{false};
+
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    result res = implementation.convert_utf8_to_latin1_with_errors(
+        data, size, output_buffer.get());
+    sink = !(res.error);
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == false) && (iterations > 0)) {
+    std::cerr << "The input was declared invalid.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_valid_utf8_to_latin1(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char[]> output_buffer{new char[size]};
+  volatile size_t sink{0};
+
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    sink = implementation.convert_valid_utf8_to_latin1(data, size,
+                                                       output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_utf8_to_utf16le(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char16_t[]> output_buffer{new char16_t[size]};
+  volatile size_t sink{0};
+
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    sink =
+        implementation.convert_utf8_to_utf16le(data, size, output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_utf8_to_utf16le_with_errors(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char16_t[]> output_buffer{new char16_t[size]};
+  volatile bool sink{false};
+
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    result res = implementation.convert_utf8_to_utf16le_with_errors(
+        data, size, output_buffer.get());
+    sink = !(res.error);
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == false) && (iterations > 0)) {
+    std::cerr << "The input was declared invalid.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_utf8_to_utf32(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char32_t[]> output_buffer{new char32_t[size]};
+  volatile size_t sink{0};
+
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    sink =
+        implementation.convert_utf8_to_utf32(data, size, output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_utf8_to_utf32_with_errors(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char32_t[]> output_buffer{new char32_t[size]};
+  volatile bool sink{false};
+
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    result res = implementation.convert_utf8_to_utf32_with_errors(
+        data, size, output_buffer.get());
+    sink = !(res.error);
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == false) && (iterations > 0)) {
+    std::cerr << "The input was declared invalid.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_utf8_to_utf16le_with_dynamic_allocation(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  volatile size_t sink{0};
+  auto proc = [&implementation, data, size, &sink]() {
+    auto dyn_size = implementation.utf16_length_from_utf8(data, size);
+    std::unique_ptr<char16_t[]> output_buffer{new char16_t[dyn_size]};
+    sink =
+        implementation.convert_utf8_to_utf16le(data, size, output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_utf8_to_utf32_with_dynamic_allocation(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  volatile size_t sink{0};
+  auto proc = [&implementation, data, size, &sink]() {
+    auto dyn_size = implementation.utf32_length_from_utf8(data, size);
+    std::unique_ptr<char32_t[]> output_buffer{new char32_t[dyn_size]};
+    sink =
+        implementation.convert_utf8_to_utf32(data, size, output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+#ifdef ICU_AVAILABLE
+
+void Benchmark::run_convert_latin1_to_utf8_icu(size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  volatile size_t sink{0};
+
+  // Allocate target buffer
+  int32_t targetCapacity = size * 2;
+  std::unique_ptr<char[]> target(new char[targetCapacity]);
+
+  auto proc = [data, size, &sink, &target, targetCapacity]() {
+    UErrorCode status = U_ZERO_ERROR;
+
+    // Open converters for source and target encodings
+    UConverter *latin1conv = ucnv_open("ISO-8859-1", &status);
+    assert(U_SUCCESS(status));
+    UConverter *utf8conv = ucnv_open("UTF-8", &status);
+    assert(U_SUCCESS(status));
+
+    // Pointers for source and target
+    const char *source = data;
+    const char *sourceLimit = data + size;
+    char *targetStart = target.get();
+    char *targetLimit = target.get() + targetCapacity;
+
+    // Convert from ISO-8859-1 to UTF-8
+    ucnv_convertEx(utf8conv, latin1conv, &targetStart, targetLimit, &source,
+                   sourceLimit, nullptr, nullptr, nullptr, nullptr, true, true,
+                   &status);
+    assert(U_SUCCESS(status));
+
+    // Calculate the output size
+    sink = targetStart - target.get();
+
+    // Clean up
+    ucnv_close(utf8conv);
+    ucnv_close(latin1conv);
+  };
+
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr
+        << "The output is zero which might indicate a misconfiguration.\n";
+  }
+  size_t char_count = size;
+  std::unique_ptr<char[]> output_buffer{new char[size * 2]};
+  size_t expected = get_active_implementation()->convert_latin1_to_utf8(
+      data, size, output_buffer.get());
+  if (expected != sink) {
+    std::cerr << "The number of characters outputted does not match.\n";
+    std::cout << "Expected: " << expected << ", Sink: " << sink
+              << std::endl; // print values
+  }
+
+  if (memcmp(target.get(), output_buffer.get(), sink) != 0) {
+    std::cerr << "The output data does not match.\n";
+  }
+
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_latin1_to_utf16_icu(size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  volatile size_t sink{0};
+
+  // Allocate target buffer outside lambda
+  std::unique_ptr<UChar[]> target(new UChar[size * 2]);
+
+  auto proc = [data, size, &sink, &target]() {
+    UErrorCode status = U_ZERO_ERROR;
+
+    // Open converter for source encoding
+    UConverter *latin1conv = ucnv_open("ISO-8859-1", &status);
+    assert(U_SUCCESS(status));
+
+    // Convert from ISO-8859-1 to UTF-16 directly
+    int32_t actualTargetSize =
+        ucnv_toUChars(latin1conv, target.get(), size * 2, data, size, &status);
+    assert(U_SUCCESS(status));
+
+    // Calculate the output size in bytes
+    sink = actualTargetSize * sizeof(UChar);
+
+    // Clean up
+    ucnv_close(latin1conv);
+  };
+
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr
+        << "The output is zero which might indicate a misconfiguration.\n";
+  }
+  size_t char_count = size;
+  std::unique_ptr<char16_t[]> output_buffer{new char16_t[size]};
+  size_t expected = get_active_implementation()->convert_latin1_to_utf16le(
+      data, size, output_buffer.get()); // expected char16_t units
+  if (2 * expected != sink) {
+    std::cerr << "The number of utf16le code units does not match.\n";
+    std::cerr << "Expected: " << 2 * expected + 1 << ", Sink: " << sink
+              << std::endl; // print values
+  }
+
+  if (memcmp(target.get(), output_buffer.get(), sink) != 0) {
+    std::cerr << "The output data does not match.\n";
+    // compare first 20 characters and print their hexadecimal values
+    std::cout << "First 20 characters of target data: ";
+    for (size_t i = 0; i < 20; i++) {
+      std::cout << std::hex << static_cast<int>(target.get()[i]) << " ";
+    }
+    std::cout << "\nFirst 20 characters of output buffer: ";
+    for (size_t i = 0; i < 20; i++) {
+      std::cout << std::hex << static_cast<int>(output_buffer[i]) << " ";
+    }
+
+    // compare last 20 characters and print their hexadecimal values
+    size_t num_chars = sink / sizeof(UChar);
+    size_t start = num_chars < 20 ? 0 : num_chars - 20;
+    std::cout << "\nLast 20 characters of target data: ";
+    for (size_t i = start; i < num_chars; i++) {
+      std::cout << std::hex << static_cast<int>(target.get()[i]) << " ";
+    }
+    std::cout << "\nLast 20 characters of output buffer: ";
+    for (size_t i = start; i < num_chars; i++) {
+      std::cout << std::hex << static_cast<int>(output_buffer[i]) << " ";
+    }
+  }
+
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_latin1_to_utf32_icu(size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  volatile size_t sink{0};
+
+  std::unique_ptr<char[]> target;
+
+  auto proc = [&target, data, size, &sink]() {
+    UErrorCode status = U_ZERO_ERROR;
+
+    // Open converters for source and target encodings
+    UConverter *latin1conv = ucnv_open("ISO-8859-1", &status);
+    assert(U_SUCCESS(status));
+    UConverter *utf32conv = ucnv_open("UTF-32LE", &status);
+    assert(U_SUCCESS(status));
+
+    // Allocate target buffer
+    int32_t targetCapacity = size * 4; // UTF-32 takes four bytes.
+    target.reset(new char[targetCapacity]);
+
+    // Pointers for source and target
+    const char *source = data;
+    const char *sourceLimit = data + size;
+    char *targetStart = target.get();
+    char *targetLimit = target.get() + targetCapacity;
+
+    // Convert from ISO-8859-1 to UTF-32
+    ucnv_convertEx(utf32conv, latin1conv, &targetStart, targetLimit, &source,
+                   sourceLimit, nullptr, nullptr, nullptr, nullptr, true, true,
+                   &status);
+    assert(U_SUCCESS(status));
+
+    // Calculate the output size in bytes
+    sink = targetStart - target.get();
+
+    // Clean up
+    ucnv_close(utf32conv);
+    ucnv_close(latin1conv);
+  };
+
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr
+        << "The output is zero which might indicate a misconfiguration.\n";
+  }
+  size_t char_count = size;
+  std::unique_ptr<char32_t[]> output_buffer{new char32_t[size]};
+  size_t expected = get_active_implementation()->convert_latin1_to_utf32(
+      data, size, output_buffer.get()); // expected is the # of UTF32 characters
+  if (4 * expected != sink) {
+    std::cerr
+        << "The number of characters outputted does not match.\n"; // each UTF32
+                                                                   // character
+                                                                   // takes four
+                                                                   // bytes
+    std::cout << "Expected: " << expected << ", Sink: " << sink
+              << std::endl; // print values
+  }
+
+  if (memcmp(target.get(), output_buffer.get(), sink) != 0) {
+    std::cerr << "The output data does not match.\n";
+    // compare first 20 characters and print their hexadecimal values
+    std::cout << "First 20 characters of target data: ";
+    for (size_t i = 0; i < 20; i++) {
+      std::cout << std::hex << static_cast<int>(target.get()[i]) << " ";
+    }
+    std::cout << "\nFirst 20 characters of output buffer: ";
+    for (size_t i = 0; i < 20; i++) {
+      std::cout << std::hex << static_cast<int>(output_buffer[i]) << " ";
+    }
+
+    // compare last 20 characters and print their hexadecimal values
+    size_t num_chars = sink / sizeof(UChar);
+    size_t start = num_chars < 20 ? 0 : num_chars - 20;
+    std::cout << "\nLast 20 characters of target data: ";
+    for (size_t i = start; i < num_chars; i++) {
+      std::cout << std::hex << static_cast<int>(target.get()[i]) << " ";
+    }
+    std::cout << "\nLast 20 characters of output buffer: ";
+    for (size_t i = start; i < num_chars; i++) {
+      std::cout << std::hex << static_cast<int>(output_buffer[i]) << " ";
+    }
+  }
+
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_utf8_to_latin1_icu(size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  volatile size_t sink{0};
+
+  std::unique_ptr<char[]> target;
+
+  auto proc = [&target, data, size, &sink]() {
+    UErrorCode status = U_ZERO_ERROR;
+
+    // Open converters for source and target encodings
+    UConverter *utf8conv = ucnv_open("UTF-8", &status);
+    assert(U_SUCCESS(status));
+    UConverter *latin1conv = ucnv_open("ISO-8859-1", &status);
+    assert(U_SUCCESS(status));
+
+    // Allocate target buffer
+    int32_t targetCapacity = size * 2;
+    target.reset(new char[targetCapacity]);
+
+    // Pointers for source and target
+    const char *source = data;
+    const char *sourceLimit = data + size;
+    char *targetStart = target.get();
+    char *targetLimit = target.get() + targetCapacity;
+
+    // Convert from ISO-8859-1 to UTF-8
+    ucnv_convertEx(latin1conv, utf8conv, &targetStart, targetLimit, &source,
+                   sourceLimit, nullptr, nullptr, nullptr, nullptr, true, true,
+                   &status);
+    assert(U_SUCCESS(status));
+
+    // Calculate the output size
+    sink = targetStart - target.get();
+
+    // Clean up
+    ucnv_close(utf8conv);
+    ucnv_close(latin1conv);
+  };
+
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr
+        << "The output is zero which might indicate a misconfiguration.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  std::unique_ptr<char[]> output_buffer{new char[size]};
+  size_t expected = get_active_implementation()->convert_utf8_to_latin1(
+      data, size, output_buffer.get());
+  if (expected != sink) {
+    std::cerr << "The number of latin1 code units does not match.\n";
+  }
+
+  if (memcmp(target.get(), output_buffer.get(), sink) != 0) {
+    std::cerr << "The output data does not match.\n";
+    // compare first 20 characters and print their hexadecimal values
+    std::cout << "First 20 characters of target data: ";
+    for (size_t i = 0; i < 20; i++) {
+      std::cout << std::hex << static_cast<int>(target.get()[i]) << " ";
+    }
+    std::cout << "\nFirst 20 characters of output buffer: ";
+    for (size_t i = 0; i < 20; i++) {
+      std::cout << std::hex << static_cast<int>(output_buffer[i]) << " ";
+    }
+  }
+
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_utf8_to_utf16_icu(size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  volatile size_t sink{0};
+  auto proc = [data, size, &sink]() {
+    auto str =
+        U_ICU_NAMESPACE::UnicodeString::fromUTF8(std::string_view(data, size));
+    sink = str.length();
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr
+        << "The output is zero which might indicate a misconfiguration.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  // checking
+  std::unique_ptr<char16_t[]> output_buffer{new char16_t[size]};
+  size_t expected = convert_utf8_to_utf16le(data, size, output_buffer.get());
+  if (expected != sink) {
+    std::cerr << "The number of UTF-16 code units does not match.\n";
+  }
+  print_summary(result, size, char_count);
+}
+void Benchmark::run_convert_utf16_to_utf8_icu(size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char16_t *data = reinterpret_cast<const char16_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+  size /= 2;
+  volatile size_t sink{0};
+
+  auto proc = [data, size, &sink]() {
+    U_ICU_NAMESPACE::UnicodeString str(data, size);
+    std::string out;
+    out = str.toUTF8String(out);
+    sink = out.size();
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_convert_utf16_to_latin1_icu(size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char16_t *data = reinterpret_cast<const char16_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+  size /= 2;
+  volatile size_t sink{0};
+
+  std::unique_ptr<char[]> target;
+
+  auto proc = [&target, data, size, &sink]() {
+    UErrorCode status = U_ZERO_ERROR;
+    UConverter *conv =
+        ucnv_open("ISO-8859-1", &status); // open a converter for ISO-8859-1
+    assert(U_SUCCESS(status));
+
+    int32_t targetCapacity = size; // adjust as needed
+    target.reset(new char[targetCapacity]);
+    char *targetStart = target.get();
+
+    sink =
+        ucnv_fromUChars(conv, targetStart, targetCapacity,
+                        reinterpret_cast<const UChar *>(data), size, &status);
+    assert(U_SUCCESS(status));
+
+    // Clean up
+    ucnv_close(conv);
+  };
+
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr
+        << "The output is zero which might indicate a misconfiguration.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  std::unique_ptr<char[]> output_buffer{new char[size]};
+  size_t expected = get_active_implementation()->convert_utf16le_to_latin1(
+      data, size, output_buffer.get());
+  if (expected != sink) {
+    std::cerr << "The number of expected bytes does not match.\n";
+    std::cout << "Expected: " << expected << ", Sink: " << sink
+              << std::endl; // print values
+  }
+
+  if (memcmp(target.get(), output_buffer.get(), sink) != 0) {
+    std::cerr << "The output data does not match.\n";
+    // compare first 20 characters and print their hexadecimal values
+    std::cout << "First 20 characters of target data: ";
+    for (size_t i = 0; i < 20; i++) {
+      std::cout << std::hex << static_cast<int>(target.get()[i]) << " ";
+    }
+    std::cout << "\nFirst 20 characters of output buffer: ";
+    for (size_t i = 0; i < 20; i++) {
+      std::cout << std::hex << static_cast<int>(output_buffer[i]) << " ";
+    }
+  }
+
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_convert_utf32_to_latin1_icu(size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char32_t *data = reinterpret_cast<const char32_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 4 != 0) {
+    printf(
+        "# The input size is not divisible by four (it is %zu + %zu for BOM)",
+        size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 4;
+  volatile size_t sink{0};
+  std::unique_ptr<char[]> target;
+
+  auto proc = [&target, data, size, &sink]() {
+    UErrorCode status = U_ZERO_ERROR;
+
+    UConverter *utf32conv =
+        ucnv_open("UTF-32LE", &status); // create a UTF-32 converter
+    assert(U_SUCCESS(status));
+
+    UConverter *latin1conv =
+        ucnv_open("ISO-8859-1", &status); // create a Latin1 converter
+    assert(U_SUCCESS(status));
+
+    int32_t targetCapacity = size; // adjust as needed
+    target.reset(new char[targetCapacity]);
+    char *targetStart = target.get();
+
+    const char *sourceStart = reinterpret_cast<const char *>(data);
+    const char *sourceEnd = sourceStart + size * sizeof(char32_t);
+
+    // Convert from UTF-32 to Latin1
+    ucnv_convertEx(latin1conv, utf32conv, &targetStart,
+                   targetStart + targetCapacity, &sourceStart, sourceEnd,
+                   nullptr, nullptr, nullptr, nullptr, true, true, &status);
+    assert(U_SUCCESS(status));
+
+    // Calculate the output size
+    sink = targetStart - target.get();
+
+    // Clean up
+    ucnv_close(utf32conv);
+    ucnv_close(latin1conv);
+  };
+
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr
+        << "The output is zero which might indicate a misconfiguration.\n";
+  }
+  size_t char_count = size;
+  std::unique_ptr<char[]> output_buffer{new char[size]};
+  size_t expected = get_active_implementation()->convert_utf32_to_latin1(
+      data, size, output_buffer.get());
+  if (expected != sink) {
+    std::cerr << "The number of expected bytes does not match.\n";
+    std::cout << "Expected: " << expected << ", Sink: " << sink
+              << std::endl; // print values
+  }
+
+  if (memcmp(target.get(), output_buffer.get(), sink) != 0) {
+    std::cerr << "The output data does not match.\n";
+    // compare first 20 characters and print their hexadecimal values
+    std::cout << "First 20 characters of target data: ";
+    for (size_t i = 0; i < 20; i++) {
+      std::cout << std::hex << static_cast<int>(target.get()[i]) << " ";
+    }
+    std::cout << "\nFirst 20 characters of output buffer: ";
+    for (size_t i = 0; i < 20; i++) {
+      std::cout << std::hex << static_cast<int>(output_buffer[i]) << " ";
+    }
+  }
+
+  print_summary(result, input_data.size(), char_count);
+}
+
+#endif
+
+#ifdef ICONV_AVAILABLE
+void Benchmark::run_convert_latin1_to_utf8_iconv(size_t iterations) {
+  iconv_t cv = iconv_open("UTF-8", "ISO-8859-1");
+  if (cv == (iconv_t)(-1)) {
+    fprintf(stderr,
+            "[iconv] cannot initialize ISO-8859-1 to UTF-8 converter\n");
+    return;
+  }
+  char *data = reinterpret_cast<char *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char[]> output_buffer{new char[size * 2]}; // 2 for safety
+  volatile size_t sink{0};
+  auto proc = [&cv, data, size, &output_buffer, &sink]() {
+    size_t inbytes = size;
+    size_t outbytes = sizeof(uint8_t) * size * 2;
+  #ifdef WINICONV_CONST
+    WINICONV_CONST char *inptr = reinterpret_cast<WINICONV_CONST char *>(data);
+  #else
+    char *inptr = data;
+  #endif
+    char *outptr = reinterpret_cast<char *>(output_buffer.get());
+    size_t result = iconv(cv, &inptr, &inbytes, &outptr, &outbytes);
+    if (result == static_cast<size_t>(-1)) {
+      sink = 0;
+    } else {
+      sink = (sizeof(uint8_t) * size - outbytes) / sizeof(char);
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  iconv_close(cv);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = size;
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_latin1_to_utf16_iconv(size_t iterations) {
+  iconv_t cv = iconv_open("UTF-16", "ISO-8859-1");
+  if (cv == (iconv_t)(-1)) {
+    fprintf(stderr,
+            "[iconv] cannot initialize ISO-8859-1 to UTF-16 converter\n");
+    return;
+  }
+  char *data = reinterpret_cast<char *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char16_t[]> output_buffer{new char16_t[size]};
+  volatile size_t sink{0};
+  auto proc = [&cv, data, size, &output_buffer, &sink]() {
+    size_t inbytes = size;
+    size_t outbytes = sizeof(uint16_t) * size;
+  #ifdef WINICONV_CONST
+    WINICONV_CONST char *inptr = reinterpret_cast<WINICONV_CONST char *>(data);
+  #else
+    char *inptr = data;
+  #endif
+    char *outptr = reinterpret_cast<char *>(output_buffer.get());
+    size_t result = iconv(cv, &inptr, &inbytes, &outptr, &outbytes);
+    if (result == static_cast<size_t>(-1)) {
+      sink = 0;
+    } else {
+      sink = (sizeof(uint16_t) * size - outbytes) / sizeof(char);
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  iconv_close(cv);
+  size_t char_count = size;
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_latin1_to_utf32_iconv(size_t iterations) {
+  iconv_t cv = iconv_open("UTF-32LE", "ISO-8859-1");
+  if (cv == (iconv_t)(-1)) {
+    fprintf(stderr,
+            "[iconv] cannot initialize ISO-8859-1 to UTF-32 converter\n");
+    return;
+  }
+  char *data = reinterpret_cast<char *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char32_t[]> output_buffer{new char32_t[size]};
+  volatile size_t sink{0};
+  auto proc = [&cv, data, size, &output_buffer, &sink]() {
+    size_t inbytes = size;
+    size_t outbytes = sizeof(uint32_t) * size;
+  #ifdef WINICONV_CONST
+    WINICONV_CONST char *inptr = reinterpret_cast<WINICONV_CONST char *>(data);
+  #else
+    char *inptr = data;
+  #endif
+    char *outptr = reinterpret_cast<char *>(output_buffer.get());
+    size_t result = iconv(cv, &inptr, &inbytes, &outptr, &outbytes);
+    if (result == static_cast<size_t>(-1)) {
+      sink = 0;
+    } else {
+      sink = (sizeof(uint32_t) * size - outbytes) / sizeof(char);
+      ;
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  iconv_close(cv);
+  size_t char_count = size;
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_utf8_to_latin1_iconv(size_t iterations) {
+  iconv_t cv = iconv_open("ISO-8859-1", "UTF-8");
+  if (cv == (iconv_t)(-1)) {
+    fprintf(stderr, "[iconv] cannot initialize UTF-8 to Latin1 converter\n");
+    return;
+  }
+  char *data = reinterpret_cast<char *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char[]> output_buffer{new char[size]};
+  volatile size_t sink{0};
+
+  auto proc = [&cv, data, size, &output_buffer, &sink]() {
+    size_t inbytes = size;
+    size_t outbytes = sizeof(uint8_t) * size;
+    // win-iconv includes WINICONV_CONST in its function signatures
+    // https://github.com/simdutf/simdutf/pull/178
+  #ifdef WINICONV_CONST
+    WINICONV_CONST char *inptr = reinterpret_cast<WINICONV_CONST char *>(data);
+  #else
+    char *inptr = data;
+  #endif
+    char *outptr = reinterpret_cast<char *>(output_buffer.get());
+    size_t result = iconv(cv, &inptr, &inbytes, &outptr, &outbytes);
+    if (result == static_cast<size_t>(-1)) {
+      sink = 0;
+    } else {
+      sink = (sizeof(uint8_t) * size - outbytes) / sizeof(char);
+      ;
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  iconv_close(cv);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_utf8_to_utf16_iconv(size_t iterations) {
+  iconv_t cv = iconv_open("UTF-16LE", "UTF-8");
+  if (cv == (iconv_t)(-1)) {
+    fprintf(stderr, "[iconv] cannot initialize UTF-8 to UTF-16LE converter\n");
+    return;
+  }
+  char *data = reinterpret_cast<char *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char16_t[]> output_buffer{new char16_t[size]};
+  volatile size_t sink{0};
+
+  auto proc = [&cv, data, size, &output_buffer, &sink]() {
+    size_t inbytes = size;
+    size_t outbytes = sizeof(uint16_t) * size;
+    // win-iconv includes WINICONV_CONST in its function signatures
+    // https://github.com/simdutf/simdutf/pull/178
+  #ifdef WINICONV_CONST
+    WINICONV_CONST char *inptr = reinterpret_cast<WINICONV_CONST char *>(data);
+  #else
+    char *inptr = data;
+  #endif
+    char *outptr = reinterpret_cast<char *>(output_buffer.get());
+    size_t result = iconv(cv, &inptr, &inbytes, &outptr, &outbytes);
+    if (result == static_cast<size_t>(-1)) {
+      sink = 0;
+    } else {
+      sink = (sizeof(uint16_t) * size - outbytes) / sizeof(char);
+      ;
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  iconv_close(cv);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_utf16_to_latin1_iconv(size_t iterations) {
+  iconv_t cv = iconv_open("ISO-8859-1", "UTF-16LE");
+  if (cv == (iconv_t)(-1)) {
+    fprintf(stderr,
+            "[iconv] cannot initialize the UTF-16LE to ISO-8859-1 converter\n");
+    return;
+  }
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  char16_t *data =
+      reinterpret_cast<char16_t *>(input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 2;
+
+  // Note: non-surrogate code units can yield up to 3 bytes, a surrogate pair
+  // yields 4 bytes,
+  //       thus we're making safe assumption that each 16-bit word will be
+  //       expanded to four bytes.
+  std::unique_ptr<char[]> output_buffer{new char[size]};
+
+  volatile size_t sink{0};
+
+  auto proc = [cv, data, size, &output_buffer, &sink]() {
+    size_t inbytes = sizeof(uint16_t) * size;
+    size_t outbytes = size;
+  #ifdef WINICONV_CONST
+    WINICONV_CONST char *inptr = reinterpret_cast<WINICONV_CONST char *>(data);
+  #else
+    char *inptr = reinterpret_cast<char *>(data);
+  #endif
+    char *outptr = output_buffer.get();
+    size_t result = iconv(cv, &inptr, &inbytes, &outptr, &outbytes);
+    if (result == static_cast<size_t>(-1)) {
+      sink = 0;
+    } else {
+      sink = (size - outbytes) / sizeof(char16_t);
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  iconv_close(cv);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_convert_utf16_to_utf8_iconv(size_t iterations) {
+  iconv_t cv = iconv_open("UTF-8", "UTF-16LE");
+  if (cv == (iconv_t)(-1)) {
+    fprintf(stderr,
+            "[iconv] cannot initialize the UTF-16LE to UTF-8 converter\n");
+    return;
+  }
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  char16_t *data =
+      reinterpret_cast<char16_t *>(input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 2;
+
+  // Note: non-surrogate code units can yield up to 3 bytes, a surrogate pair
+  // yields 4 bytes,
+  //       thus we're making safe assumption that each 16-bit word will be
+  //       expanded to four bytes.
+  std::unique_ptr<char[]> output_buffer{new char[size * 4]};
+
+  volatile size_t sink{0};
+
+  auto proc = [cv, data, size, &output_buffer, &sink]() {
+    size_t inbytes = sizeof(uint16_t) * size;
+    size_t outbytes = 4 * size;
+  #ifdef WINICONV_CONST
+    WINICONV_CONST char *inptr = reinterpret_cast<WINICONV_CONST char *>(data);
+  #else
+    char *inptr = reinterpret_cast<char *>(data);
+  #endif
+    char *outptr = output_buffer.get();
+    size_t result = iconv(cv, &inptr, &inbytes, &outptr, &outbytes);
+    if (result == static_cast<size_t>(-1)) {
+      sink = 0;
+    } else {
+      sink = (4 * size - outbytes) / sizeof(char16_t);
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  iconv_close(cv);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_convert_utf32_to_latin1_iconv(size_t iterations) {
+  iconv_t cv = iconv_open("ISO-8859-1", "UTF-32LE");
+  if (cv == (iconv_t)(-1)) {
+    fprintf(stderr,
+            "[iconv] cannot initialize the UTF-32 to ISO-8859-1 converter\n");
+    return;
+  }
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  char32_t *data =
+      reinterpret_cast<char32_t *>(input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 4 != 0) {
+    printf(
+        "# The input size is not divisible by four (it is %zu + %zu for BOM)",
+        size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 4;
+
+  // Note: non-surrogate code units can yield up to 3 bytes, a surrogate pair
+  // yields 4 bytes,
+  //       thus we're making safe assumption that each 16-bit word will be
+  //       expanded to four bytes.
+  std::unique_ptr<char[]> output_buffer{new char[size]};
+
+  volatile size_t sink{0};
+
+  auto proc = [cv, data, size, &output_buffer, &sink]() {
+    size_t inbytes = sizeof(uint32_t) * size;
+    size_t outbytes = size;
+  #ifdef WINICONV_CONST
+    WINICONV_CONST char *inptr = reinterpret_cast<WINICONV_CONST char *>(data);
+  #else
+    char *inptr = reinterpret_cast<char *>(data);
+  #endif
+    char *outptr = output_buffer.get();
+    size_t result = iconv(cv, &inptr, &inbytes, &outptr, &outbytes);
+    if (result == static_cast<size_t>(-1)) {
+      sink = 0;
+      abort();
+    } else {
+      sink = (size - outbytes) / sizeof(char32_t);
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  iconv_close(cv);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = size;
+  print_summary(result, input_data.size(), char_count);
+}
+#endif
+
+#ifdef INOUE2008
+void Benchmark::run_convert_valid_utf8_to_utf16_inoue2008(size_t iterations) {
+  // Inoue2008 is only up to 3-byte UTF8 sequence.
+  for (uint8_t c : input_data) {
+    if (c >= 0b11110000) {
+      std::cerr << "Warning: Inoue 2008 does not support 4-byte inputs!"
+                << std::endl;
+      break;
+    }
+  }
+  // This is currently minimally tested. It is possible that the transcoding
+  // could be wrong. It is also unsafe: it could fail in disastrous ways if the
+  // input is adversarial.
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char16_t[]> output_buffer{new char16_t[size]};
+  volatile size_t sink{0};
+  auto proc = [data, size, &output_buffer, &sink]() {
+    sink = inoue2008::convert_valid(data, size, output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr
+        << "The output is zero which might indicate a misconfiguration.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+#endif
+/**
+ * Bjoern Hoehrmann
+ * http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+ */
+void Benchmark::run_convert_utf8_to_utf16_hoehrmann(size_t iterations) {
+  uint8_t const *data = input_data.data();
+  const size_t size = input_data.size();
+  std::unique_ptr<char16_t[]> output_buffer{new char16_t[size]};
+  volatile size_t sink{0};
+  auto proc = [data, size, &output_buffer, &sink]() {
+    sink = hoehrmann::toUtf16(data, size, output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(
+      reinterpret_cast<const char *>(data), size);
+  print_summary(result, size, char_count);
+}
+/**
+ * Bjoern Hoehrmann
+ * http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+ */
+void Benchmark::run_convert_utf8_to_utf32_hoehrmann(size_t iterations) {
+  uint8_t const *data = input_data.data();
+  const size_t size = input_data.size();
+  std::unique_ptr<char32_t[]> output_buffer{new char32_t[size]};
+  volatile size_t sink{0};
+  auto proc = [data, size, &output_buffer, &sink]() {
+    sink = hoehrmann::toUtf32(data, size, output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(
+      reinterpret_cast<const char *>(data), size);
+  print_summary(result, size, char_count);
+}
+
+#ifdef __x86_64__
+/**
+ * utf8lut: Vectorized UTF-8 converter.
+ * by stgatilov (2019)
+ *  https://dirtyhandscoding.github.io/posts/utf8lut-vectorized-utf-8-converter-introduction.html
+ */
+void Benchmark::run_convert_utf16_to_utf8_utf8lut(size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char16_t *data = reinterpret_cast<const char16_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 2;
+
+  // Note: non-surrogate code units can yield up to 3 bytes, a surrogate pair
+  // yields 4 bytes,
+  //       thus we're making safe assumption that each 16-bit word will be
+  //       expanded to four bytes.
+  // utf8lut requires an extra 16 bytes of padding.
+  std::unique_ptr<char[]> output_buffer{new char[size * 4 + 16]};
+
+  volatile size_t sink{0};
+
+  auto proc = [data, size, &output_buffer, &sink]() {
+    std::unique_ptr<BaseBufferProcessor> processor(
+        ProcessorSelector<dfUtf16, dfUtf8>::WithOptions<cmValidate>::Create());
+    ConversionResult result = ConvertInMemory(
+        *processor, reinterpret_cast<const char *>(data), 2 * size,
+        reinterpret_cast<char *>(output_buffer.get()), size * 4 + 16);
+    if (result.status != 0) {
+      sink = 0;
+    } else {
+      sink = result.outputSize;
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+}
+/**
+ * utf8lut: Vectorized UTF-8 converter.
+ * by stgatilov (2019)
+ *  https://dirtyhandscoding.github.io/posts/utf8lut-vectorized-utf-8-converter-introduction.html
+ */
+void Benchmark::run_convert_valid_utf16_to_utf8_utf8lut(size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char16_t *data = reinterpret_cast<const char16_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 2;
+
+  // Note: non-surrogate code units can yield up to 3 bytes, a surrogate pair
+  // yields 4 bytes,
+  //       thus we're making safe assumption that each 16-bit word will be
+  //       expanded to four bytes.
+  // utf8lut requires an extra 16 bytes of padding.
+  std::unique_ptr<char[]> output_buffer{new char[size * 4 + 16]};
+
+  volatile size_t sink{0};
+
+  auto proc = [data, size, &output_buffer, &sink]() {
+    std::unique_ptr<BaseBufferProcessor> processor(
+        ProcessorSelector<dfUtf16, dfUtf8>::WithOptions<cmFull>::Create());
+    ConversionResult result = ConvertInMemory(
+        *processor, reinterpret_cast<const char *>(data), 2 * size,
+        reinterpret_cast<char *>(output_buffer.get()), size * 4 + 16);
+    if (result.status != 0) {
+      sink = 0;
+    } else {
+      sink = result.outputSize;
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+}
+/**
+ * utf8lut: Vectorized UTF-8 converter.
+ * by stgatilov (2019)
+ *  https://dirtyhandscoding.github.io/posts/utf8lut-vectorized-utf-8-converter-introduction.html
+ */
+void Benchmark::run_convert_utf8_to_utf16_utf8lut(size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  // utf8lut requires an extra 8 bytes of padding.
+  std::unique_ptr<char16_t[]> output_buffer{new char16_t[size * 2 + 8]};
+  volatile size_t sink{0};
+  auto proc = [data, size, &output_buffer, &sink]() {
+    std::unique_ptr<BaseBufferProcessor> processor(
+        ProcessorSelector<dfUtf8, dfUtf16>::WithOptions<cmValidate>::Create());
+    ConversionResult result = ConvertInMemory(
+        *processor, data, size, reinterpret_cast<char *>(output_buffer.get()),
+        size * 2 + 16);
+    if (result.status != 0) {
+      sink = 0;
+    } else {
+      sink = result.outputSize / 2;
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr
+        << "The output is zero which might indicate a misconfiguration.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+/**
+ * utf8lut: Vectorized UTF-8 converter.
+ * by stgatilov (2019)
+ *  https://dirtyhandscoding.github.io/posts/utf8lut-vectorized-utf-8-converter-introduction.html
+ */
+void Benchmark::run_convert_utf8_to_utf32_utf8lut(size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+
+  std::unique_ptr<char32_t[]> output_buffer{new char32_t[size + 4]};
+  volatile size_t sink{0};
+  auto proc = [data, size, &output_buffer, &sink]() {
+    std::unique_ptr<BaseBufferProcessor> processor(
+        ProcessorSelector<dfUtf8, dfUtf32>::WithOptions<cmValidate>::Create());
+    ConversionResult result = ConvertInMemory(
+        *processor, data, size, reinterpret_cast<char *>(output_buffer.get()),
+        size * 4 + 16);
+    if (result.status != 0) {
+      sink = 0;
+    } else {
+      sink = result.outputSize / 2;
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr
+        << "The output is zero which might indicate a misconfiguration.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+/**
+ * utf8lut: Vectorized UTF-8 converter.
+ * by stgatilov (2019)
+ *  https://dirtyhandscoding.github.io/posts/utf8lut-vectorized-utf-8-converter-introduction.html
+ */
+void Benchmark::run_convert_valid_utf8_to_utf16_utf8lut(size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  // utf8lut requires an extra 8 bytes of padding.
+  std::unique_ptr<char16_t[]> output_buffer{new char16_t[size * 2 + 8]};
+  volatile size_t sink{0};
+  auto proc = [data, size, &output_buffer, &sink]() {
+    std::unique_ptr<BaseBufferProcessor> processor(
+        ProcessorSelector<dfUtf8, dfUtf16>::WithOptions<cmFull>::Create());
+    ConversionResult result = ConvertInMemory(
+        *processor, data, size, reinterpret_cast<char *>(output_buffer.get()),
+        size * 2 + 16);
+    if (result.status != 0) {
+      sink = 0;
+    } else {
+      sink = result.outputSize / 2;
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr
+        << "The output is zero which might indicate a misconfiguration.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+/**
+ * utf8lut: Vectorized UTF-8 converter.
+ * by stgatilov (2019)
+ *  https://dirtyhandscoding.github.io/posts/utf8lut-vectorized-utf-8-converter-introduction.html
+ */
+void Benchmark::run_convert_utf32_to_utf8_utf8lut(size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char32_t *data = reinterpret_cast<const char32_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 4 != 0) {
+    printf(
+        "# The input size is not divisible by four (it is %zu + %zu for BOM)",
+        size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 4;
+
+  // Note: a single 32-bit word can yield up to four UTF-8 bytes. We are
+  //       making a safe assumption that each 32-bit word will yield four
+  //       UTF-8 bytes.
+  // utf8lut requires an extra 16 bytes of padding.
+  std::unique_ptr<char[]> output_buffer{new char[size * 4 + 16]};
+
+  volatile size_t sink{0};
+
+  auto proc = [data, size, &output_buffer, &sink]() {
+    std::unique_ptr<BaseBufferProcessor> processor(
+        ProcessorSelector<dfUtf32, dfUtf8>::WithOptions<cmValidate>::Create());
+    ConversionResult result = ConvertInMemory(
+        *processor, reinterpret_cast<const char *>(data), 4 * size,
+        reinterpret_cast<char *>(output_buffer.get()), size * 4 + 16);
+    if (result.status != 0) {
+      sink = 0;
+    } else {
+      sink = result.outputSize;
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = size;
+  print_summary(result, input_data.size(), char_count);
+}
+
+/**
+ * utf8lut: Vectorized UTF-8 converter.
+ * by stgatilov (2019)
+ *  https://dirtyhandscoding.github.io/posts/utf8lut-vectorized-utf-8-converter-introduction.html
+ */
+void Benchmark::run_convert_valid_utf8_to_utf32_utf8lut(size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+
+  std::unique_ptr<char32_t[]> output_buffer{new char32_t[size + 4]};
+  volatile size_t sink{0};
+  auto proc = [data, size, &output_buffer, &sink]() {
+    std::unique_ptr<BaseBufferProcessor> processor(
+        ProcessorSelector<dfUtf8, dfUtf32>::WithOptions<cmFull>::Create());
+    ConversionResult result = ConvertInMemory(
+        *processor, data, size, reinterpret_cast<char *>(output_buffer.get()),
+        size * 4 + 16);
+    if (result.status != 0) {
+      sink = 0;
+    } else {
+      sink = result.outputSize / 2;
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = size;
+  print_summary(result, input_data.size(), char_count);
+}
+/**
+ * utf8lut: Vectorized UTF-8 converter.
+ * by stgatilov (2019)
+ *  https://dirtyhandscoding.github.io/posts/utf8lut-vectorized-utf-8-converter-introduction.html
+ */
+/**
+ * utf8lut: Vectorized UTF-8 converter.
+ * by stgatilov (2019)
+ *  https://dirtyhandscoding.github.io/posts/utf8lut-vectorized-utf-8-converter-introduction.html
+ */
+void Benchmark::run_convert_valid_utf32_to_utf8_utf8lut(size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char32_t *data = reinterpret_cast<const char32_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 4 != 0) {
+    printf(
+        "# The input size is not divisible by four (it is %zu + %zu for BOM)",
+        size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 4;
+
+  // Note: a single 32-bit word can yield up to four UTF-8 bytes. We are
+  //       making a safe assumption that each 32-bit word will yield four
+  //       UTF-8 bytes.
+  // utf8lut requires an extra 16 bytes of padding.
+  std::unique_ptr<char[]> output_buffer{new char[size * 4 + 16]};
+
+  volatile size_t sink{0};
+
+  auto proc = [data, size, &output_buffer, &sink]() {
+    std::unique_ptr<BaseBufferProcessor> processor(
+        ProcessorSelector<dfUtf32, dfUtf8>::WithOptions<cmFull>::Create());
+    ConversionResult result = ConvertInMemory(
+        *processor, reinterpret_cast<const char *>(data), 4 * size,
+        reinterpret_cast<char *>(output_buffer.get()), size * 4 + 16);
+    if (result.status != 0) {
+      sink = 0;
+    } else {
+      sink = result.outputSize;
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = size;
+  print_summary(result, input_data.size(), char_count);
+}
+/**
+ * Bob Steagall, CppCon2018
+ * https://github.com/BobSteagall/CppCon2018/
+ *
+ * Fast Conversion From UTF-8 with C++, DFAs, and SSE Intrinsics
+ * https://www.youtube.com/watch?v=5FQ87-Ecb-A
+ */
+void Benchmark::run_convert_utf8_to_utf16_cppcon2018(size_t iterations) {
+  using char8_t = unsigned char;
+  const char8_t *data = reinterpret_cast<const char8_t *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char16_t[]> output_buffer{new char16_t[size]};
+  volatile size_t sink{0};
+  auto proc = [data, size, &output_buffer, &sink]() {
+    sink = uu::UtfUtils::SseConvert(data, data + size, output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr
+        << "The output is zero which might indicate a misconfiguration.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(
+      reinterpret_cast<const char *>(data), size);
+  print_summary(result, size, char_count);
+}
+/**
+ * Bob Steagall, CppCon2018
+ * https://github.com/BobSteagall/CppCon2018/
+ *
+ * Fast Conversion From UTF-8 with C++, DFAs, and SSE Intrinsics
+ * https://www.youtube.com/watch?v=5FQ87-Ecb-A
+ */
+void Benchmark::run_convert_utf8_to_utf32_cppcon2018(size_t iterations) {
+  using char8_t = unsigned char;
+  const char8_t *data = reinterpret_cast<const char8_t *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char32_t[]> output_buffer{new char32_t[size]};
+  volatile size_t sink{0};
+  auto proc = [data, size, &output_buffer, &sink]() {
+    sink = uu::UtfUtils::SseConvert(data, data + size, output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr
+        << "The output is zero which might indicate a misconfiguration.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(
+      reinterpret_cast<const char *>(data), size);
+  print_summary(result, size, char_count);
+}
+/**
+ * Cameron, Robert D, A case study in SIMD text processing with parallel bit
+ * streams: UTF-8 to UTF-16 transcoding, Proceedings of the 13th ACM SIGPLAN
+ * Symposium on Principles and practice of parallel programming, 91--98.
+ */
+void Benchmark::run_convert_utf8_to_utf16_u8u16(size_t iterations) {
+  // u8u16 wants to take mutable chars, let us hope it does not actually mutate
+  // anything!
+  //
+  // This is currently untested. At a glance it looks fine, but
+  // it is possible that the transcoding could be wrong.
+  char *data = reinterpret_cast<char *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char16_t[]> output_buffer{new char16_t[size]};
+  volatile size_t sink{0};
+  auto proc = [data, size, &output_buffer, &sink]() {
+    char *srcbuf_ptr = data;
+    size_t inbytes_left = size;
+    char *trgtbuf_ptr = reinterpret_cast<char *>(output_buffer.get());
+    size_t outbytes_left = size * sizeof(char16_t);
+    size_t result_code =
+        u8u16(&srcbuf_ptr, &inbytes_left, &trgtbuf_ptr, &outbytes_left);
+    bool is_ok = (result_code != size_t(-1));
+    if (is_ok) {
+      sink = (reinterpret_cast<char16_t *>(trgtbuf_ptr) - output_buffer.get());
+    } else {
+      sink = 0;
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr
+        << "The output is zero which might indicate a misconfiguration.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+/**
+ * Olivier Goffart, UTF-8 processing using SIMD (SSE4), 2012.
+ * https://woboq.com/blog/utf-8-processing-using-simd.html
+ */
+void Benchmark::run_convert_utf8_to_utf16_utf8sse4(size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char16_t[]> output_buffer{new char16_t[size]};
+  volatile size_t sink{0};
+  auto proc = [data, size, &output_buffer, &sink]() {
+    const char *srcbuf_ptr = data;
+    size_t inbytes_left = size;
+    char *trgtbuf_ptr = reinterpret_cast<char *>(output_buffer.get());
+    size_t outbytes_left = size * sizeof(char16_t);
+    size_t result_code = utf8sse4::fromUtf8(&srcbuf_ptr, &inbytes_left,
+                                            &trgtbuf_ptr, &outbytes_left);
+    bool is_ok = (result_code != size_t(-1));
+    if (is_ok) {
+      sink = (reinterpret_cast<char16_t *>(trgtbuf_ptr) - output_buffer.get());
+    } else {
+      sink = 0;
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr
+        << "The output is zero which might indicate a misconfiguration.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+#endif
+
+void Benchmark::run_convert_valid_utf8_to_utf16le(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char16_t[]> output_buffer{new char16_t[size]};
+  volatile size_t sink{0};
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    sink = implementation.convert_valid_utf8_to_utf16le(data, size,
+                                                        output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr
+        << "The output is zero which might indicate a misconfiguration.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_valid_utf8_to_utf32(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char32_t[]> output_buffer{new char32_t[size]};
+  volatile size_t sink{0};
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    sink = implementation.convert_valid_utf8_to_utf32(data, size,
+                                                      output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr
+        << "The output is zero which might indicate a misconfiguration.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_utf16le_to_latin1(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char16_t *data = reinterpret_cast<const char16_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 2;
+  std::unique_ptr<char[]> output_buffer{new char[size]};
+  volatile size_t sink{0};
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    sink = implementation.convert_utf16le_to_latin1(data, size,
+                                                    output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_convert_utf16le_to_latin1_with_errors(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char16_t *data = reinterpret_cast<const char16_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 2;
+  std::unique_ptr<char[]> output_buffer{new char[size]};
+  volatile bool sink{false};
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    result res = implementation.convert_utf16le_to_latin1_with_errors(
+        data, size, output_buffer.get());
+    sink = !(res.error);
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == false) && (iterations > 0)) {
+    std::cerr << "The input was declared invalid.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_convert_valid_utf16le_to_latin1(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char16_t *data = reinterpret_cast<const char16_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 2;
+  std::unique_ptr<char[]> output_buffer{new char[size]};
+  volatile size_t sink{0};
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    sink = implementation.convert_valid_utf16le_to_latin1(data, size,
+                                                          output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_convert_utf16_to_utf8_safe(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::implementation *active_implementation =
+      simdutf::get_active_implementation();
+  simdutf::get_active_implementation() =
+      &implementation; // set the active implementation
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char16_t *data = reinterpret_cast<const char16_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 2;
+
+  size_t budget = simdutf::utf8_length_from_utf16(data, size);
+
+  std::unique_ptr<char[]> output_buffer{new char[budget]};
+
+  volatile size_t sink{0};
+
+  auto proc = [&implementation, data, size, &output_buffer, &sink, &budget]() {
+    sink = simdutf::convert_utf16_to_utf8_safe(data, size, output_buffer.get(),
+                                               budget);
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+  simdutf::get_active_implementation() =
+      active_implementation; // restore the active implementation
+}
+
+void Benchmark::run_convert_utf16le_to_utf8(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char16_t *data = reinterpret_cast<const char16_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 2;
+
+  // Note: non-surrogate code units can yield up to 3 bytes, a surrogate pair
+  // yields 4 bytes,
+  //       thus we're making safe assumption that each 16-bit word will be
+  //       expanded to four bytes.
+  std::unique_ptr<char[]> output_buffer{new char[size * 4]};
+
+  volatile size_t sink{0};
+
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    sink =
+        implementation.convert_utf16le_to_utf8(data, size, output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_convert_utf16le_to_utf8_with_errors(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char16_t *data = reinterpret_cast<const char16_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 2;
+
+  // Note: non-surrogate code units can yield up to 3 bytes, a surrogate pair
+  // yields 4 bytes,
+  //       thus we're making safe assumption that each 16-bit word will be
+  //       expanded to four bytes.
+  std::unique_ptr<char[]> output_buffer{new char[size * 4]};
+
+  volatile bool sink{false};
+
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    result res = implementation.convert_utf16le_to_utf8_with_errors(
+        data, size, output_buffer.get());
+    sink = !(res.error);
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == false) && (iterations > 0)) {
+    std::cerr << "The input was declared invalid.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_convert_utf16le_to_utf32(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char16_t *data = reinterpret_cast<const char16_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 2;
+
+  // Note: all code units yield 4 bytes. We are making a safe assumption that
+  // all code units will be non-surrogate code units so the size would get
+  // doubled (16 bits -> 32 bits).
+  std::unique_ptr<char32_t[]> output_buffer{new char32_t[size * 2]};
+
+  volatile size_t sink{0};
+
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    sink = implementation.convert_utf16le_to_utf32(data, size,
+                                                   output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_convert_utf16le_to_utf32_with_errors(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char16_t *data = reinterpret_cast<const char16_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 2;
+
+  // Note: all code units yield 4 bytes. We are making a safe assumption that
+  // all code units will be non-surrogate code units so the size would get
+  // doubled (16 bits -> 32 bits).
+  std::unique_ptr<char32_t[]> output_buffer{new char32_t[size * 2]};
+
+  volatile bool sink{false};
+
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    result res = implementation.convert_utf16le_to_utf32_with_errors(
+        data, size, output_buffer.get());
+    sink = !(res.error);
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == false) && (iterations > 0)) {
+    std::cerr << "The input was declared invalid.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_convert_utf16le_to_utf8_with_dynamic_allocation(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char16_t *data = reinterpret_cast<const char16_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 2;
+
+  // Note: non-surrogate code units can yield up to 3 bytes, a surrogate pair
+  // yields 4 bytes,
+  //       thus we're making safe assumption that each 16-bit word will be
+  //       expanded to four bytes.
+
+  volatile size_t sink{0};
+
+  auto proc = [&implementation, data, size, &sink]() {
+    auto dyn_size = implementation.utf8_length_from_utf16le(data, size);
+    std::unique_ptr<char[]> output_buffer{new char[dyn_size]};
+    sink =
+        implementation.convert_utf16le_to_utf8(data, size, output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_convert_utf16le_to_utf32_with_dynamic_allocation(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char16_t *data = reinterpret_cast<const char16_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 2;
+
+  // Note: all code units yield 4 bytes. We are making a safe assumption that
+  // all code units will be non-surrogate code units so the size would get
+  // doubled (16 bits -> 32 bits).
+
+  volatile size_t sink{0};
+
+  auto proc = [&implementation, data, size, &sink]() {
+    auto dyn_size = implementation.utf32_length_from_utf16le(data, size);
+    std::unique_ptr<char32_t[]> output_buffer{new char32_t[dyn_size]};
+    sink = implementation.convert_utf16le_to_utf32(data, size,
+                                                   output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_convert_valid_utf16le_to_utf8(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char16_t *data = reinterpret_cast<const char16_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 2;
+
+  // Note: non-surrogate code units can yield up to 3 bytes, a surrogate pair
+  // yields 4 bytes,
+  //       thus we're making safe assumption that each 16-bit word will be
+  //       expanded to four bytes.
+  std::unique_ptr<char[]> output_buffer{new char[size * 4]};
+
+  volatile size_t sink{0};
+
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    sink = implementation.convert_valid_utf16le_to_utf8(data, size,
+                                                        output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_convert_utf32_to_latin1(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char32_t *data = reinterpret_cast<const char32_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 4 != 0) {
+    printf(
+        "# The input size is not divisible by four (it is %zu + %zu for BOM)",
+        size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 4;
+
+  std::unique_ptr<char[]> output_buffer{new char[size]};
+  volatile size_t sink{0};
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    sink =
+        implementation.convert_utf32_to_latin1(data, size, output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = size;
+  print_summary(result, input_data.size(), char_count);
+}
+void Benchmark::run_convert_utf32_to_latin1_with_errors(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char32_t *data = reinterpret_cast<const char32_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 4 != 0) {
+    printf(
+        "# The input size is not divisible by four (it is %zu + %zu for BOM)",
+        size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 4;
+
+  std::unique_ptr<char[]> output_buffer{new char[size]};
+  volatile bool sink{false};
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    result res = implementation.convert_utf32_to_latin1_with_errors(
+        data, size, output_buffer.get());
+    sink = !(res.error);
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == false) && (iterations > 0)) {
+    std::cerr << "The input was declared invalid.\n";
+  }
+  size_t char_count = size;
+  print_summary(result, input_data.size(), char_count);
+}
+void Benchmark::run_convert_valid_utf32_to_latin1(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char32_t *data = reinterpret_cast<const char32_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 4 != 0) {
+    printf(
+        "# The input size is not divisible by four (it is %zu + %zu for BOM)",
+        size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 4;
+
+  std::unique_ptr<char[]> output_buffer{new char[size]};
+  volatile size_t sink{0};
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    sink = implementation.convert_valid_utf32_to_latin1(data, size,
+                                                        output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = size;
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_convert_utf32_to_utf8(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char32_t *data = reinterpret_cast<const char32_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 4 != 0) {
+    printf(
+        "# The input size is not divisible by four (it is %zu + %zu for BOM)",
+        size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 4;
+
+  // Note: In the "worst" case, a 32-bit word will yield 4 UTF-8 bytes. So, we
+  // are making a safe assumption that each word will produce 4 bytes.
+  std::unique_ptr<char[]> output_buffer{new char[size * 4]};
+
+  volatile size_t sink{0};
+
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    sink =
+        implementation.convert_utf32_to_utf8(data, size, output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = size;
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_convert_utf32_to_utf8_with_errors(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char32_t *data = reinterpret_cast<const char32_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 4 != 0) {
+    printf(
+        "# The input size is not divisible by four (it is %zu + %zu for BOM)",
+        size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 4;
+
+  // Note: In the "worst" case, a 32-bit word will yield 4 UTF-8 bytes. So, we
+  // are making a safe assumption that each word will produce 4 bytes.
+  std::unique_ptr<char[]> output_buffer{new char[size * 4]};
+
+  volatile bool sink{false};
+
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    result res = implementation.convert_utf32_to_utf8_with_errors(
+        data, size, output_buffer.get());
+    sink = !(res.error);
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == false) && (iterations > 0)) {
+    std::cerr << "The input was declared invalid.\n";
+  }
+  size_t char_count = size;
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_convert_valid_utf32_to_utf8(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char32_t *data = reinterpret_cast<const char32_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 4 != 0) {
+    printf(
+        "# The input size is not divisible by four (it is %zu + %zu for BOM)",
+        size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 4;
+
+  // Note: In the "worst" case, a 32-bit word will yield 4 UTF-8 bytes. So, we
+  // are making a safe assumption that each word will produce 4 bytes.
+  std::unique_ptr<char[]> output_buffer{new char[size * 4]};
+
+  volatile size_t sink{0};
+
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    sink = implementation.convert_valid_utf32_to_utf8(data, size,
+                                                      output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = size;
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_convert_valid_utf16le_to_utf32(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char16_t *data = reinterpret_cast<const char16_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 2;
+
+  // Note: non-surrogate code units can yield up to 3 bytes, a surrogate pair
+  // yields 4 bytes,
+  //       thus we're making safe assumption that each 16-bit word will be
+  //       expanded to four bytes.
+  std::unique_ptr<char32_t[]> output_buffer{new char32_t[size * 4]};
+
+  volatile size_t sink{0};
+
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    sink = implementation.convert_valid_utf16le_to_utf32(data, size,
+                                                         output_buffer.get());
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+}
+
+template <endianness byte_order>
+void Benchmark::run_convert_utf32_to_utf16(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char32_t *data = reinterpret_cast<const char32_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 4 != 0) {
+    printf(
+        "# The input size is not divisible by four (it is %zu + %zu for BOM)",
+        size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 4;
+
+  // Note: In the "worst" case, a 32-bit word will yield two 16-bit code units.
+  // So, we are making a safe assumption that each word will produce 2 bytes.
+  std::unique_ptr<char16_t[]> output_buffer{new char16_t[size * 2]};
+
+  volatile size_t sink{0};
+
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    if (byte_order == endianness::LITTLE) {
+      sink = implementation.convert_utf32_to_utf16le(data, size,
+                                                     output_buffer.get());
+    } else {
+      sink = implementation.convert_utf32_to_utf16be(data, size,
+                                                     output_buffer.get());
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = size;
+  print_summary(result, input_data.size(), char_count);
+}
+
+template <endianness byte_order>
+void Benchmark::run_convert_utf32_to_utf16_with_errors(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char32_t *data = reinterpret_cast<const char32_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 4 != 0) {
+    printf(
+        "# The input size is not divisible by four (it is %zu + %zu for BOM)",
+        size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 4;
+
+  // Note: In the "worst" case, a 32-bit word will yield two 16-bit code units.
+  // So, we are making a safe assumption that each word will produce 2 bytes.
+  std::unique_ptr<char16_t[]> output_buffer{new char16_t[size * 2]};
+
+  volatile bool sink{false};
+
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    if (byte_order == endianness::LITTLE) {
+      result res = implementation.convert_utf32_to_utf16le_with_errors(
+          data, size, output_buffer.get());
+      sink = !(res.error);
+    } else {
+      result res = implementation.convert_utf32_to_utf16be_with_errors(
+          data, size, output_buffer.get());
+      sink = !(res.error);
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == false) && (iterations > 0)) {
+    std::cerr << "The input was declared invalid.\n";
+  }
+  size_t char_count = size;
+  print_summary(result, input_data.size(), char_count);
+}
+
+template <endianness byte_order>
+void Benchmark::run_convert_valid_utf32_to_utf16(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char32_t *data = reinterpret_cast<const char32_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 4 != 0) {
+    printf(
+        "# The input size is not divisible by four (it is %zu + %zu for BOM)",
+        size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 4;
+
+  // Note: In the "worst" case, a 32-bit word will yield two 16-bit code units.
+  // So, we are making a safe assumption that each word will produce 2 bytes.
+  std::unique_ptr<char16_t[]> output_buffer{new char16_t[size * 2]};
+
+  volatile size_t sink{0};
+
+  auto proc = [&implementation, data, size, &output_buffer, &sink]() {
+    if (byte_order == endianness::LITTLE) {
+      sink = implementation.convert_valid_utf32_to_utf16le(data, size,
+                                                           output_buffer.get());
+    } else {
+      sink = implementation.convert_valid_utf32_to_utf16be(data, size,
+                                                           output_buffer.get());
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = size;
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_count_utf8(const simdutf::implementation &implementation,
+                               size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  volatile size_t sink{0};
+
+  auto proc = [&implementation, data, size, &sink]() {
+    sink = implementation.count_utf8(data, size);
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_count_utf16le(const simdutf::implementation &implementation,
+                                  size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char16_t *data = reinterpret_cast<const char16_t *>(input_data.data());
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+  size /= 2;
+  volatile size_t sink{0};
+  auto proc = [&implementation, data, size, &sink]() {
+    sink = implementation.count_utf16le(data, size);
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_detect_encodings(
+    const simdutf::implementation &implementation, size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char *data = reinterpret_cast<const char *>(input_data.data() +
+                                                    BOM::bom_byte_size(bom));
+  const size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  volatile size_t sink{0};
+  auto proc = [&implementation, data, size, &sink]() {
+    sink = implementation.detect_encodings(data, size);
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  size_t char_count = size;
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  } else {
+    std::cout << "Detected format: ";
+    if (sink & simdutf::encoding_type::UTF8) {
+      char_count = get_active_implementation()->count_utf8(data, size);
+      std::cout << " UTF8";
+    }
+    if (sink & simdutf::encoding_type::UTF16_LE) {
+      std::cout << " UTF16LE";
+      char_count = get_active_implementation()->count_utf16le(
+          reinterpret_cast<const char16_t *>(data), size / 2);
+    }
+    if (sink & simdutf::encoding_type::UTF32_LE) {
+      std::cout << " UTF32LE";
+      char_count = size / 4;
+    }
+    std::cout << std::endl;
+  }
+  if ((bom) && (bom & ~sink)) {
+    std::cerr << "[Error] BOM format     : ";
+    if (bom & simdutf::encoding_type::UTF8) {
+      std::cerr << " UTF8";
+    } else if (bom & simdutf::encoding_type::UTF16_LE) {
+      std::cerr << " UTF16LE";
+    } else if (bom & simdutf::encoding_type::UTF32_LE) {
+      std::cerr << " UTF32LE";
+    }
+    std::cerr << std::endl;
+  }
+  if ((sink & (sink - 1)) != 0) {
+    std::cout << "More than one format possible, character count is ambiguous."
+              << std::endl;
+  }
+  print_summary(result, size, char_count);
+}
+
+const std::set<std::string> Benchmark::all_procedures() const {
+  std::set<std::string> result;
+  for (const auto &item : benchmarks) {
+    result.insert(item.first);
+  }
+
+  return result;
+}
+
+std::set<simdutf::encoding_type>
+Benchmark::expected_encodings(const std::string &procedure) {
+  return benchmarks[procedure].second;
+}
+
+/**
+ * LLVM relies on code from the Unicode Consortium
+ * https://en.wikipedia.org/wiki/Unicode_Consortium
+ */
+void Benchmark::run_convert_utf8_to_utf16_llvm(size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char16_t[]> output_buffer{new char16_t[size]};
+  volatile size_t sink{0};
+  auto proc = [data, size, &output_buffer, &sink]() {
+    const unsigned char *sourceStart =
+        reinterpret_cast<const unsigned char *>(data);
+    const unsigned char *sourceEnd = sourceStart + size;
+    short unsigned int *targetStart =
+        reinterpret_cast<short unsigned int *>(output_buffer.get());
+    short unsigned int *targetEnd = targetStart + size;
+    bool is_ok = (llvm::conversionOK ==
+                  llvm::ConvertUTF8toUTF16(
+                      &sourceStart, sourceEnd, &targetStart, targetEnd,
+                      llvm::ConversionFlags::strictConversion));
+    if (is_ok) {
+      sink = (targetStart -
+              reinterpret_cast<short unsigned int *>(output_buffer.get()));
+    } else {
+      sink = 0;
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr
+        << "The output is zero which might indicate a misconfiguration.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_utf8_to_utf32_llvm(size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  std::unique_ptr<char32_t[]> output_buffer{new char32_t[size]};
+  volatile size_t sink{0};
+  auto proc = [data, size, &output_buffer, &sink]() {
+    const unsigned char *sourceStart =
+        reinterpret_cast<const unsigned char *>(data);
+    const unsigned char *sourceEnd = sourceStart + size;
+    unsigned int *targetStart =
+        reinterpret_cast<unsigned int *>(output_buffer.get());
+    unsigned int *targetEnd = targetStart + size;
+    bool is_ok = (llvm::conversionOK ==
+                  llvm::ConvertUTF8toUTF32(
+                      &sourceStart, sourceEnd, &targetStart, targetEnd,
+                      llvm::ConversionFlags::strictConversion));
+    if (is_ok) {
+      sink =
+          (targetStart - reinterpret_cast<unsigned int *>(output_buffer.get()));
+    } else {
+      sink = 0;
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr
+        << "The output is zero which might indicate a misconfiguration.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_utf16_to_utf8_llvm(size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char16_t *data = reinterpret_cast<const char16_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 2;
+
+  // Note: non-surrogate code units can yield up to 3 bytes, a surrogate pair
+  // yields 4 bytes,
+  //       thus we're making safe assumption that each 16-bit word will be
+  //       expanded to four bytes.
+  std::unique_ptr<char[]> output_buffer{new char[size * 4]};
+
+  volatile size_t sink{0};
+
+  auto proc = [data, size, &output_buffer, &sink]() {
+    const short unsigned int *sourceStart =
+        reinterpret_cast<const short unsigned int *>(data);
+    const short unsigned int *sourceEnd = sourceStart + size;
+    unsigned char *targetStart =
+        reinterpret_cast<unsigned char *>(output_buffer.get());
+    unsigned char *targetEnd = targetStart + size * 4;
+    bool is_ok = (llvm::conversionOK ==
+                  llvm::ConvertUTF16toUTF8(
+                      &sourceStart, sourceEnd, &targetStart, targetEnd,
+                      llvm::ConversionFlags::strictConversion));
+    if (is_ok) {
+      sink = (targetStart -
+              reinterpret_cast<unsigned char *>(output_buffer.get()));
+    } else {
+      sink = 0;
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_convert_utf32_to_utf8_llvm(size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char32_t *data = reinterpret_cast<const char32_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 4 != 0) {
+    printf(
+        "# The input size is not divisible by four (it is %zu + %zu for BOM)",
+        size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 4;
+
+  // Note: a single 32-bit word can yield up to four UTF-8 bytes. We are
+  //       making a safe assumption that each 32-bit word will yield four
+  //       UTF-8 bytes.
+  std::unique_ptr<char[]> output_buffer{new char[size * 4]};
+
+  volatile size_t sink{0};
+
+  auto proc = [data, size, &output_buffer, &sink]() {
+    const unsigned int *sourceStart =
+        reinterpret_cast<const unsigned int *>(data);
+    const unsigned int *sourceEnd = sourceStart + size;
+    unsigned char *targetStart =
+        reinterpret_cast<unsigned char *>(output_buffer.get());
+    unsigned char *targetEnd = targetStart + size * 4;
+    bool is_ok = (llvm::conversionOK ==
+                  llvm::ConvertUTF32toUTF8(
+                      &sourceStart, sourceEnd, &targetStart, targetEnd,
+                      llvm::ConversionFlags::strictConversion));
+    if (is_ok) {
+      sink = (targetStart -
+              reinterpret_cast<unsigned char *>(output_buffer.get()));
+    } else {
+      sink = 0;
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = size;
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_convert_utf16_to_utf32_llvm(size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char16_t *data = reinterpret_cast<const char16_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 2;
+
+  // Note: all code units yield four bytes. We make the safe assumption that all
+  // code units will be non surrogate code units so the size will double (16
+  // bits -> 32 bits).
+  std::unique_ptr<char32_t[]> output_buffer{new char32_t[size * 2]};
+
+  volatile size_t sink{0};
+
+  auto proc = [data, size, &output_buffer, &sink]() {
+    const short unsigned int *sourceStart =
+        reinterpret_cast<const short unsigned int *>(data);
+    const short unsigned int *sourceEnd = sourceStart + size;
+    unsigned int *targetStart =
+        reinterpret_cast<unsigned int *>(output_buffer.get());
+    unsigned int *targetEnd = targetStart + 2 * size;
+    bool is_ok = (llvm::conversionOK ==
+                  llvm::ConvertUTF16toUTF32(
+                      &sourceStart, sourceEnd, &targetStart, targetEnd,
+                      llvm::ConversionFlags::strictConversion));
+    if (is_ok) {
+      sink =
+          (targetStart - reinterpret_cast<unsigned int *>(output_buffer.get()));
+    } else {
+      sink = 0;
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_convert_utf32_to_utf16_llvm(size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char32_t *data = reinterpret_cast<const char32_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 4 != 0) {
+    printf(
+        "# The input size is not divisible by four (it is %zu + %zu for BOM)",
+        size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  size /= 4;
+
+  // Note: a single 32-bit word can produce a surrogate pair, i.e. two
+  //       16-bit code units. We are making a safe assumption that each 32-
+  //       bit word will yield two 16-bit code units.
+  std::unique_ptr<char[]> output_buffer{new char[size * 2]};
+
+  volatile size_t sink{0};
+
+  auto proc = [data, size, &output_buffer, &sink]() {
+    const unsigned int *sourceStart =
+        reinterpret_cast<const unsigned int *>(data);
+    const unsigned int *sourceEnd = sourceStart + size;
+    short unsigned int *targetStart =
+        reinterpret_cast<short unsigned int *>(output_buffer.get());
+    short unsigned int *targetEnd = targetStart + size * 2;
+    bool is_ok = (llvm::conversionOK ==
+                  llvm::ConvertUTF32toUTF16(
+                      &sourceStart, sourceEnd, &targetStart, targetEnd,
+                      llvm::ConversionFlags::strictConversion));
+    if (is_ok) {
+      sink = (targetStart -
+              reinterpret_cast<short unsigned int *>(output_buffer.get()));
+    } else {
+      sink = 0;
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = size;
+  print_summary(result, input_data.size(), char_count);
+}
+
+/**
+ * Nemanja Trifunovic, UTF8-CPP: UTF-8 with C++ in a Portable Way
+ * https://github.com/nemtrif/utfcpp/releases/tag/v3.2.2
+ */
+void Benchmark::run_convert_utf8_to_utf16_utfcpp(size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  volatile size_t sink{0};
+
+  auto proc = [data, size, &sink]() {
+    try {
+      std::vector<unsigned short> str;
+      utf8::utf8to16(data, data + size, std::back_inserter(str));
+      sink = str.size();
+    } catch (const char *msg) {
+      std::cout << msg << std::endl;
+      sink = 0;
+    } catch (...) {
+      sink = 0;
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr
+        << "The output is zero which might indicate a misconfiguration.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  // checking
+  std::unique_ptr<char16_t[]> output_buffer{new char16_t[size]};
+  size_t expected = convert_utf8_to_utf16le(data, size, output_buffer.get());
+  if (expected != sink) {
+    std::cerr << "The number of UTF-16 code units does not match.\n";
+  }
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_utf16_to_utf8_utfcpp(size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char16_t *data = reinterpret_cast<const char16_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 2 != 0) {
+    printf("# The input size is not divisible by two (it is %zu + %zu for BOM)",
+           size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  volatile size_t sink{0};
+  auto proc = [data, size, &sink]() {
+    try {
+      std::string str;
+      utf8::utf16to8(data, data + size, std::back_inserter(str));
+      sink = str.size();
+    } catch (const char *msg) {
+      std::cout << msg << std::endl;
+      sink = 0;
+    } catch (...) {
+      sink = 0;
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  size /= 2;
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+
+  size_t char_count = get_active_implementation()->count_utf16le(data, size);
+  print_summary(result, input_data.size(), char_count);
+}
+
+void Benchmark::run_convert_utf8_to_utf32_utfcpp(size_t iterations) {
+  const char *data = reinterpret_cast<const char *>(input_data.data());
+  const size_t size = input_data.size();
+  volatile size_t sink{0};
+
+  auto proc = [data, size, &sink]() {
+    try {
+      std::vector<int> str;
+      utf8::utf8to32(data, data + size, std::back_inserter(str));
+      sink = str.size();
+    } catch (const char *msg) {
+      std::cout << msg << std::endl;
+      sink = 0;
+    } catch (...) {
+      sink = 0;
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr
+        << "The output is zero which might indicate a misconfiguration.\n";
+  }
+  size_t char_count = get_active_implementation()->count_utf8(data, size);
+  print_summary(result, size, char_count);
+}
+
+void Benchmark::run_convert_utf32_to_utf8_utfcpp(size_t iterations) {
+  const simdutf::encoding_type bom =
+      BOM::check_bom(input_data.data(), input_data.size());
+  const char32_t *data = reinterpret_cast<const char32_t *>(
+      input_data.data() + BOM::bom_byte_size(bom));
+  size_t size = input_data.size() - BOM::bom_byte_size(bom);
+  if (size % 4 != 0) {
+    printf(
+        "# The input size is not divisible by four (it is %zu + %zu for BOM)",
+        size_t(input_data.size()), size_t(BOM::bom_byte_size(bom)));
+    printf(" Running function on truncated input.\n");
+  }
+
+  volatile size_t sink{0};
+
+  auto proc = [data, size, &sink]() {
+    try {
+      std::string str;
+      utf8::utf16to8(data, data + size, std::back_inserter(str));
+      sink = str.size();
+    } catch (const char *msg) {
+      std::cout << msg << std::endl;
+      sink = 0;
+    } catch (...) {
+      sink = 0;
+    }
+  };
+  count_events(proc, iterations); // warming up!
+  const auto result = count_events(proc, iterations);
+  if ((sink == 0) && (size != 0) && (iterations > 0)) {
+    std::cerr << "The output is zero which might indicate an error.\n";
+  }
+  size_t char_count = size / 4;
+  print_summary(result, input_data.size(), char_count);
+}
+
+} // namespace simdutf::benchmarks