#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
