_ZN18FuzzedDataProviderC2EPKhm:
   37|  1.35k|      : data_ptr_(data), remaining_bytes_(size) {}
_ZN18FuzzedDataProvider15ConsumeIntegralIlEET_v:
  195|  2.70k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  2.70k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  2.70k|                                std::numeric_limits<T>::max());
  198|  2.70k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIlEET_S1_S1_:
  205|  2.70k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  2.70k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  2.70k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  2.70k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 2.70k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  2.70k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  2.70k|  uint64_t result = 0;
  215|  2.70k|  size_t offset = 0;
  216|       |
  217|  21.7k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 19.4k, False: 2.32k]
  |  Branch (217:43): [True: 19.4k, False: 0]
  ------------------
  218|  21.7k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 19.0k, False: 382]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|  19.0k|    --remaining_bytes_;
  226|  19.0k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  19.0k|    offset += CHAR_BIT;
  228|  19.0k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  2.70k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 0, False: 2.70k]
  ------------------
  232|      0|    result = result % (range + 1);
  233|       |
  234|  2.70k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  2.70k|}
_ZN18FuzzedDataProvider15ConsumeIntegralImEET_v:
  195|  2.70k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  2.70k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  2.70k|                                std::numeric_limits<T>::max());
  198|  2.70k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeImEET_S1_S1_:
  205|  2.70k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  2.70k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  2.70k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  2.70k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 2.70k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  2.70k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  2.70k|  uint64_t result = 0;
  215|  2.70k|  size_t offset = 0;
  216|       |
  217|  14.9k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 13.4k, False: 1.47k]
  |  Branch (217:43): [True: 13.4k, False: 0]
  ------------------
  218|  14.9k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 12.2k, False: 1.23k]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|  12.2k|    --remaining_bytes_;
  226|  12.2k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  12.2k|    offset += CHAR_BIT;
  228|  12.2k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  2.70k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 0, False: 2.70k]
  ------------------
  232|      0|    result = result % (range + 1);
  233|       |
  234|  2.70k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  2.70k|}
_ZN18FuzzedDataProvider15ConsumeIntegralIiEET_v:
  195|  2.70k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  2.70k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  2.70k|                                std::numeric_limits<T>::max());
  198|  2.70k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIiEET_S1_S1_:
  205|  2.70k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  2.70k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  2.70k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  2.70k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 2.70k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  2.70k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  2.70k|  uint64_t result = 0;
  215|  2.70k|  size_t offset = 0;
  216|       |
  217|  7.90k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 6.63k, False: 1.27k]
  |  Branch (217:43): [True: 6.63k, False: 0]
  ------------------
  218|  7.90k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 5.20k, False: 1.43k]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|  5.20k|    --remaining_bytes_;
  226|  5.20k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  5.20k|    offset += CHAR_BIT;
  228|  5.20k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  2.70k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 2.70k, False: 0]
  ------------------
  232|  2.70k|    result = result % (range + 1);
  233|       |
  234|  2.70k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  2.70k|}
_ZN18FuzzedDataProvider15ConsumeIntegralIjEET_v:
  195|  2.70k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  2.70k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  2.70k|                                std::numeric_limits<T>::max());
  198|  2.70k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIjEET_S1_S1_:
  205|  2.70k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  2.70k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  2.70k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  2.70k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 2.70k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  2.70k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  2.70k|  uint64_t result = 0;
  215|  2.70k|  size_t offset = 0;
  216|       |
  217|  6.46k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 5.53k, False: 924]
  |  Branch (217:43): [True: 5.53k, False: 0]
  ------------------
  218|  6.46k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 3.75k, False: 1.78k]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|  3.75k|    --remaining_bytes_;
  226|  3.75k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  3.75k|    offset += CHAR_BIT;
  228|  3.75k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  2.70k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 2.70k, False: 0]
  ------------------
  232|  2.70k|    result = result % (range + 1);
  233|       |
  234|  2.70k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  2.70k|}
_ZN18FuzzedDataProvider15ConsumeIntegralIsEET_v:
  195|  2.70k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  2.70k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  2.70k|                                std::numeric_limits<T>::max());
  198|  2.70k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIsEET_S1_S1_:
  205|  2.70k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  2.70k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  2.70k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  2.70k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 2.70k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  2.70k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  2.70k|  uint64_t result = 0;
  215|  2.70k|  size_t offset = 0;
  216|       |
  217|  4.36k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 3.54k, False: 814]
  |  Branch (217:43): [True: 3.54k, False: 0]
  ------------------
  218|  4.36k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 1.65k, False: 1.89k]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|  1.65k|    --remaining_bytes_;
  226|  1.65k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  1.65k|    offset += CHAR_BIT;
  228|  1.65k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  2.70k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 2.70k, False: 0]
  ------------------
  232|  2.70k|    result = result % (range + 1);
  233|       |
  234|  2.70k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  2.70k|}
_ZN18FuzzedDataProvider15ConsumeIntegralItEET_v:
  195|  2.70k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  2.70k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  2.70k|                                std::numeric_limits<T>::max());
  198|  2.70k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeItEET_S1_S1_:
  205|  2.70k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  2.70k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  2.70k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  2.70k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 2.70k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  2.70k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  2.70k|  uint64_t result = 0;
  215|  2.70k|  size_t offset = 0;
  216|       |
  217|  3.99k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 3.35k, False: 639]
  |  Branch (217:43): [True: 3.35k, False: 0]
  ------------------
  218|  3.99k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 1.28k, False: 2.06k]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|  1.28k|    --remaining_bytes_;
  226|  1.28k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  1.28k|    offset += CHAR_BIT;
  228|  1.28k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  2.70k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 2.70k, False: 0]
  ------------------
  232|  2.70k|    result = result % (range + 1);
  233|       |
  234|  2.70k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  2.70k|}
_ZN18FuzzedDataProvider15ConsumeIntegralIcEET_v:
  195|  2.70k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  2.70k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  2.70k|                                std::numeric_limits<T>::max());
  198|  2.70k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIcEET_S1_S1_:
  205|  2.70k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  2.70k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  2.70k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  2.70k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 2.70k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  2.70k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  2.70k|  uint64_t result = 0;
  215|  2.70k|  size_t offset = 0;
  216|       |
  217|  3.30k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 2.70k, False: 596]
  |  Branch (217:43): [True: 2.70k, False: 0]
  ------------------
  218|  3.30k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 596, False: 2.11k]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|    596|    --remaining_bytes_;
  226|    596|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|    596|    offset += CHAR_BIT;
  228|    596|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  2.70k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 2.70k, False: 0]
  ------------------
  232|  2.70k|    result = result % (range + 1);
  233|       |
  234|  2.70k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  2.70k|}
_ZN18FuzzedDataProvider15ConsumeIntegralIhEET_v:
  195|  2.70k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  2.70k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  2.70k|                                std::numeric_limits<T>::max());
  198|  2.70k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIhEET_S1_S1_:
  205|  2.70k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  2.70k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  2.70k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  2.70k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 2.70k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  2.70k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  2.70k|  uint64_t result = 0;
  215|  2.70k|  size_t offset = 0;
  216|       |
  217|  3.22k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 2.70k, False: 518]
  |  Branch (217:43): [True: 2.70k, False: 0]
  ------------------
  218|  3.22k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 518, False: 2.19k]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|    518|    --remaining_bytes_;
  226|    518|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|    518|    offset += CHAR_BIT;
  228|    518|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  2.70k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 2.70k, False: 0]
  ------------------
  232|  2.70k|    result = result % (range + 1);
  233|       |
  234|  2.70k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  2.70k|}
_ZN18FuzzedDataProvider15ConsumeIntegralIaEET_v:
  195|  2.70k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  2.70k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  2.70k|                                std::numeric_limits<T>::max());
  198|  2.70k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIaEET_S1_S1_:
  205|  2.70k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  2.70k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  2.70k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  2.70k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 2.70k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  2.70k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  2.70k|  uint64_t result = 0;
  215|  2.70k|  size_t offset = 0;
  216|       |
  217|  3.18k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 2.70k, False: 472]
  |  Branch (217:43): [True: 2.70k, False: 0]
  ------------------
  218|  3.18k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 472, False: 2.23k]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|    472|    --remaining_bytes_;
  226|    472|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|    472|    offset += CHAR_BIT;
  228|    472|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  2.70k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 2.70k, False: 0]
  ------------------
  232|  2.70k|    result = result % (range + 1);
  233|       |
  234|  2.70k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  2.70k|}

_Z29addition_overflow_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE:
   46|  1.35k|{
   47|  1.35k|    FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
   48|  1.35k|    TestAdditionOverflow<int64_t>(fuzzed_data_provider);
   49|  1.35k|    TestAdditionOverflow<uint64_t>(fuzzed_data_provider);
   50|  1.35k|    TestAdditionOverflow<int32_t>(fuzzed_data_provider);
   51|  1.35k|    TestAdditionOverflow<uint32_t>(fuzzed_data_provider);
   52|  1.35k|    TestAdditionOverflow<int16_t>(fuzzed_data_provider);
   53|  1.35k|    TestAdditionOverflow<uint16_t>(fuzzed_data_provider);
   54|  1.35k|    TestAdditionOverflow<char>(fuzzed_data_provider);
   55|  1.35k|    TestAdditionOverflow<unsigned char>(fuzzed_data_provider);
   56|  1.35k|    TestAdditionOverflow<signed char>(fuzzed_data_provider);
   57|  1.35k|}
addition_overflow.cpp:_ZN12_GLOBAL__N_120TestAdditionOverflowIlEEvR18FuzzedDataProvider:
   17|  1.35k|{
   18|  1.35k|    const T i = fuzzed_data_provider.ConsumeIntegral<T>();
   19|  1.35k|    const T j = fuzzed_data_provider.ConsumeIntegral<T>();
   20|  1.35k|    const bool is_addition_overflow_custom = AdditionOverflow(i, j);
   21|  1.35k|    const auto maybe_add{CheckedAdd(i, j)};
   22|  1.35k|    const auto sat_add{SaturatingAdd(i, j)};
   23|  1.35k|    assert(is_addition_overflow_custom == !maybe_add.has_value());
   24|  1.35k|    assert(is_addition_overflow_custom == AdditionOverflow(j, i));
   25|  1.35k|    assert(maybe_add == CheckedAdd(j, i));
   26|  1.35k|    assert(sat_add == SaturatingAdd(j, i));
   27|  1.35k|#ifndef _MSC_VER
   28|  1.35k|    T result_builtin;
   29|  1.35k|    const bool is_addition_overflow_builtin = __builtin_add_overflow(i, j, &result_builtin);
   30|  1.35k|    assert(is_addition_overflow_custom == is_addition_overflow_builtin);
   31|  1.35k|    if (!is_addition_overflow_custom) {
  ------------------
  |  Branch (31:9): [True: 809, False: 545]
  ------------------
   32|    809|        assert(i + j == result_builtin);
   33|    809|    }
   34|  1.35k|#endif
   35|  1.35k|    if (is_addition_overflow_custom) {
  ------------------
  |  Branch (35:9): [True: 545, False: 809]
  ------------------
   36|    545|        assert(sat_add == std::numeric_limits<T>::min() || sat_add == std::numeric_limits<T>::max());
   37|    809|    } else {
   38|    809|        const auto add{i + j};
   39|    809|        assert(add == maybe_add.value());
   40|    809|        assert(add == sat_add);
   41|    809|    }
   42|  1.35k|}
addition_overflow.cpp:_ZN12_GLOBAL__N_120TestAdditionOverflowImEEvR18FuzzedDataProvider:
   17|  1.35k|{
   18|  1.35k|    const T i = fuzzed_data_provider.ConsumeIntegral<T>();
   19|  1.35k|    const T j = fuzzed_data_provider.ConsumeIntegral<T>();
   20|  1.35k|    const bool is_addition_overflow_custom = AdditionOverflow(i, j);
   21|  1.35k|    const auto maybe_add{CheckedAdd(i, j)};
   22|  1.35k|    const auto sat_add{SaturatingAdd(i, j)};
   23|  1.35k|    assert(is_addition_overflow_custom == !maybe_add.has_value());
   24|  1.35k|    assert(is_addition_overflow_custom == AdditionOverflow(j, i));
   25|  1.35k|    assert(maybe_add == CheckedAdd(j, i));
   26|  1.35k|    assert(sat_add == SaturatingAdd(j, i));
   27|  1.35k|#ifndef _MSC_VER
   28|  1.35k|    T result_builtin;
   29|  1.35k|    const bool is_addition_overflow_builtin = __builtin_add_overflow(i, j, &result_builtin);
   30|  1.35k|    assert(is_addition_overflow_custom == is_addition_overflow_builtin);
   31|  1.35k|    if (!is_addition_overflow_custom) {
  ------------------
  |  Branch (31:9): [True: 1.05k, False: 300]
  ------------------
   32|  1.05k|        assert(i + j == result_builtin);
   33|  1.05k|    }
   34|  1.35k|#endif
   35|  1.35k|    if (is_addition_overflow_custom) {
  ------------------
  |  Branch (35:9): [True: 300, False: 1.05k]
  ------------------
   36|    300|        assert(sat_add == std::numeric_limits<T>::min() || sat_add == std::numeric_limits<T>::max());
   37|  1.05k|    } else {
   38|  1.05k|        const auto add{i + j};
   39|  1.05k|        assert(add == maybe_add.value());
   40|  1.05k|        assert(add == sat_add);
   41|  1.05k|    }
   42|  1.35k|}
addition_overflow.cpp:_ZN12_GLOBAL__N_120TestAdditionOverflowIiEEvR18FuzzedDataProvider:
   17|  1.35k|{
   18|  1.35k|    const T i = fuzzed_data_provider.ConsumeIntegral<T>();
   19|  1.35k|    const T j = fuzzed_data_provider.ConsumeIntegral<T>();
   20|  1.35k|    const bool is_addition_overflow_custom = AdditionOverflow(i, j);
   21|  1.35k|    const auto maybe_add{CheckedAdd(i, j)};
   22|  1.35k|    const auto sat_add{SaturatingAdd(i, j)};
   23|  1.35k|    assert(is_addition_overflow_custom == !maybe_add.has_value());
   24|  1.35k|    assert(is_addition_overflow_custom == AdditionOverflow(j, i));
   25|  1.35k|    assert(maybe_add == CheckedAdd(j, i));
   26|  1.35k|    assert(sat_add == SaturatingAdd(j, i));
   27|  1.35k|#ifndef _MSC_VER
   28|  1.35k|    T result_builtin;
   29|  1.35k|    const bool is_addition_overflow_builtin = __builtin_add_overflow(i, j, &result_builtin);
   30|  1.35k|    assert(is_addition_overflow_custom == is_addition_overflow_builtin);
   31|  1.35k|    if (!is_addition_overflow_custom) {
  ------------------
  |  Branch (31:9): [True: 366, False: 988]
  ------------------
   32|    366|        assert(i + j == result_builtin);
   33|    366|    }
   34|  1.35k|#endif
   35|  1.35k|    if (is_addition_overflow_custom) {
  ------------------
  |  Branch (35:9): [True: 988, False: 366]
  ------------------
   36|    988|        assert(sat_add == std::numeric_limits<T>::min() || sat_add == std::numeric_limits<T>::max());
   37|    988|    } else {
   38|    366|        const auto add{i + j};
   39|    366|        assert(add == maybe_add.value());
   40|    366|        assert(add == sat_add);
   41|    366|    }
   42|  1.35k|}
addition_overflow.cpp:_ZN12_GLOBAL__N_120TestAdditionOverflowIjEEvR18FuzzedDataProvider:
   17|  1.35k|{
   18|  1.35k|    const T i = fuzzed_data_provider.ConsumeIntegral<T>();
   19|  1.35k|    const T j = fuzzed_data_provider.ConsumeIntegral<T>();
   20|  1.35k|    const bool is_addition_overflow_custom = AdditionOverflow(i, j);
   21|  1.35k|    const auto maybe_add{CheckedAdd(i, j)};
   22|  1.35k|    const auto sat_add{SaturatingAdd(i, j)};
   23|  1.35k|    assert(is_addition_overflow_custom == !maybe_add.has_value());
   24|  1.35k|    assert(is_addition_overflow_custom == AdditionOverflow(j, i));
   25|  1.35k|    assert(maybe_add == CheckedAdd(j, i));
   26|  1.35k|    assert(sat_add == SaturatingAdd(j, i));
   27|  1.35k|#ifndef _MSC_VER
   28|  1.35k|    T result_builtin;
   29|  1.35k|    const bool is_addition_overflow_builtin = __builtin_add_overflow(i, j, &result_builtin);
   30|  1.35k|    assert(is_addition_overflow_custom == is_addition_overflow_builtin);
   31|  1.35k|    if (!is_addition_overflow_custom) {
  ------------------
  |  Branch (31:9): [True: 1.18k, False: 165]
  ------------------
   32|  1.18k|        assert(i + j == result_builtin);
   33|  1.18k|    }
   34|  1.35k|#endif
   35|  1.35k|    if (is_addition_overflow_custom) {
  ------------------
  |  Branch (35:9): [True: 165, False: 1.18k]
  ------------------
   36|    165|        assert(sat_add == std::numeric_limits<T>::min() || sat_add == std::numeric_limits<T>::max());
   37|  1.18k|    } else {
   38|  1.18k|        const auto add{i + j};
   39|  1.18k|        assert(add == maybe_add.value());
   40|  1.18k|        assert(add == sat_add);
   41|  1.18k|    }
   42|  1.35k|}
addition_overflow.cpp:_ZN12_GLOBAL__N_120TestAdditionOverflowIsEEvR18FuzzedDataProvider:
   17|  1.35k|{
   18|  1.35k|    const T i = fuzzed_data_provider.ConsumeIntegral<T>();
   19|  1.35k|    const T j = fuzzed_data_provider.ConsumeIntegral<T>();
   20|  1.35k|    const bool is_addition_overflow_custom = AdditionOverflow(i, j);
   21|  1.35k|    const auto maybe_add{CheckedAdd(i, j)};
   22|  1.35k|    const auto sat_add{SaturatingAdd(i, j)};
   23|  1.35k|    assert(is_addition_overflow_custom == !maybe_add.has_value());
   24|  1.35k|    assert(is_addition_overflow_custom == AdditionOverflow(j, i));
   25|  1.35k|    assert(maybe_add == CheckedAdd(j, i));
   26|  1.35k|    assert(sat_add == SaturatingAdd(j, i));
   27|  1.35k|#ifndef _MSC_VER
   28|  1.35k|    T result_builtin;
   29|  1.35k|    const bool is_addition_overflow_builtin = __builtin_add_overflow(i, j, &result_builtin);
   30|  1.35k|    assert(is_addition_overflow_custom == is_addition_overflow_builtin);
   31|  1.35k|    if (!is_addition_overflow_custom) {
  ------------------
  |  Branch (31:9): [True: 221, False: 1.13k]
  ------------------
   32|    221|        assert(i + j == result_builtin);
   33|    221|    }
   34|  1.35k|#endif
   35|  1.35k|    if (is_addition_overflow_custom) {
  ------------------
  |  Branch (35:9): [True: 1.13k, False: 221]
  ------------------
   36|  1.13k|        assert(sat_add == std::numeric_limits<T>::min() || sat_add == std::numeric_limits<T>::max());
   37|  1.13k|    } else {
   38|    221|        const auto add{i + j};
   39|    221|        assert(add == maybe_add.value());
   40|    221|        assert(add == sat_add);
   41|    221|    }
   42|  1.35k|}
addition_overflow.cpp:_ZN12_GLOBAL__N_120TestAdditionOverflowItEEvR18FuzzedDataProvider:
   17|  1.35k|{
   18|  1.35k|    const T i = fuzzed_data_provider.ConsumeIntegral<T>();
   19|  1.35k|    const T j = fuzzed_data_provider.ConsumeIntegral<T>();
   20|  1.35k|    const bool is_addition_overflow_custom = AdditionOverflow(i, j);
   21|  1.35k|    const auto maybe_add{CheckedAdd(i, j)};
   22|  1.35k|    const auto sat_add{SaturatingAdd(i, j)};
   23|  1.35k|    assert(is_addition_overflow_custom == !maybe_add.has_value());
   24|  1.35k|    assert(is_addition_overflow_custom == AdditionOverflow(j, i));
   25|  1.35k|    assert(maybe_add == CheckedAdd(j, i));
   26|  1.35k|    assert(sat_add == SaturatingAdd(j, i));
   27|  1.35k|#ifndef _MSC_VER
   28|  1.35k|    T result_builtin;
   29|  1.35k|    const bool is_addition_overflow_builtin = __builtin_add_overflow(i, j, &result_builtin);
   30|  1.35k|    assert(is_addition_overflow_custom == is_addition_overflow_builtin);
   31|  1.35k|    if (!is_addition_overflow_custom) {
  ------------------
  |  Branch (31:9): [True: 1.25k, False: 96]
  ------------------
   32|  1.25k|        assert(i + j == result_builtin);
   33|  1.25k|    }
   34|  1.35k|#endif
   35|  1.35k|    if (is_addition_overflow_custom) {
  ------------------
  |  Branch (35:9): [True: 96, False: 1.25k]
  ------------------
   36|     96|        assert(sat_add == std::numeric_limits<T>::min() || sat_add == std::numeric_limits<T>::max());
   37|  1.25k|    } else {
   38|  1.25k|        const auto add{i + j};
   39|  1.25k|        assert(add == maybe_add.value());
   40|  1.25k|        assert(add == sat_add);
   41|  1.25k|    }
   42|  1.35k|}
addition_overflow.cpp:_ZN12_GLOBAL__N_120TestAdditionOverflowIcEEvR18FuzzedDataProvider:
   17|  1.35k|{
   18|  1.35k|    const T i = fuzzed_data_provider.ConsumeIntegral<T>();
   19|  1.35k|    const T j = fuzzed_data_provider.ConsumeIntegral<T>();
   20|  1.35k|    const bool is_addition_overflow_custom = AdditionOverflow(i, j);
   21|  1.35k|    const auto maybe_add{CheckedAdd(i, j)};
   22|  1.35k|    const auto sat_add{SaturatingAdd(i, j)};
   23|  1.35k|    assert(is_addition_overflow_custom == !maybe_add.has_value());
   24|  1.35k|    assert(is_addition_overflow_custom == AdditionOverflow(j, i));
   25|  1.35k|    assert(maybe_add == CheckedAdd(j, i));
   26|  1.35k|    assert(sat_add == SaturatingAdd(j, i));
   27|  1.35k|#ifndef _MSC_VER
   28|  1.35k|    T result_builtin;
   29|  1.35k|    const bool is_addition_overflow_builtin = __builtin_add_overflow(i, j, &result_builtin);
   30|  1.35k|    assert(is_addition_overflow_custom == is_addition_overflow_builtin);
   31|  1.35k|    if (!is_addition_overflow_custom) {
  ------------------
  |  Branch (31:9): [True: 136, False: 1.21k]
  ------------------
   32|    136|        assert(i + j == result_builtin);
   33|    136|    }
   34|  1.35k|#endif
   35|  1.35k|    if (is_addition_overflow_custom) {
  ------------------
  |  Branch (35:9): [True: 1.21k, False: 136]
  ------------------
   36|  1.21k|        assert(sat_add == std::numeric_limits<T>::min() || sat_add == std::numeric_limits<T>::max());
   37|  1.21k|    } else {
   38|    136|        const auto add{i + j};
   39|    136|        assert(add == maybe_add.value());
   40|    136|        assert(add == sat_add);
   41|    136|    }
   42|  1.35k|}
addition_overflow.cpp:_ZN12_GLOBAL__N_120TestAdditionOverflowIhEEvR18FuzzedDataProvider:
   17|  1.35k|{
   18|  1.35k|    const T i = fuzzed_data_provider.ConsumeIntegral<T>();
   19|  1.35k|    const T j = fuzzed_data_provider.ConsumeIntegral<T>();
   20|  1.35k|    const bool is_addition_overflow_custom = AdditionOverflow(i, j);
   21|  1.35k|    const auto maybe_add{CheckedAdd(i, j)};
   22|  1.35k|    const auto sat_add{SaturatingAdd(i, j)};
   23|  1.35k|    assert(is_addition_overflow_custom == !maybe_add.has_value());
   24|  1.35k|    assert(is_addition_overflow_custom == AdditionOverflow(j, i));
   25|  1.35k|    assert(maybe_add == CheckedAdd(j, i));
   26|  1.35k|    assert(sat_add == SaturatingAdd(j, i));
   27|  1.35k|#ifndef _MSC_VER
   28|  1.35k|    T result_builtin;
   29|  1.35k|    const bool is_addition_overflow_builtin = __builtin_add_overflow(i, j, &result_builtin);
   30|  1.35k|    assert(is_addition_overflow_custom == is_addition_overflow_builtin);
   31|  1.35k|    if (!is_addition_overflow_custom) {
  ------------------
  |  Branch (31:9): [True: 1.28k, False: 67]
  ------------------
   32|  1.28k|        assert(i + j == result_builtin);
   33|  1.28k|    }
   34|  1.35k|#endif
   35|  1.35k|    if (is_addition_overflow_custom) {
  ------------------
  |  Branch (35:9): [True: 67, False: 1.28k]
  ------------------
   36|     67|        assert(sat_add == std::numeric_limits<T>::min() || sat_add == std::numeric_limits<T>::max());
   37|  1.28k|    } else {
   38|  1.28k|        const auto add{i + j};
   39|  1.28k|        assert(add == maybe_add.value());
   40|  1.28k|        assert(add == sat_add);
   41|  1.28k|    }
   42|  1.35k|}
addition_overflow.cpp:_ZN12_GLOBAL__N_120TestAdditionOverflowIaEEvR18FuzzedDataProvider:
   17|  1.35k|{
   18|  1.35k|    const T i = fuzzed_data_provider.ConsumeIntegral<T>();
   19|  1.35k|    const T j = fuzzed_data_provider.ConsumeIntegral<T>();
   20|  1.35k|    const bool is_addition_overflow_custom = AdditionOverflow(i, j);
   21|  1.35k|    const auto maybe_add{CheckedAdd(i, j)};
   22|  1.35k|    const auto sat_add{SaturatingAdd(i, j)};
   23|  1.35k|    assert(is_addition_overflow_custom == !maybe_add.has_value());
   24|  1.35k|    assert(is_addition_overflow_custom == AdditionOverflow(j, i));
   25|  1.35k|    assert(maybe_add == CheckedAdd(j, i));
   26|  1.35k|    assert(sat_add == SaturatingAdd(j, i));
   27|  1.35k|#ifndef _MSC_VER
   28|  1.35k|    T result_builtin;
   29|  1.35k|    const bool is_addition_overflow_builtin = __builtin_add_overflow(i, j, &result_builtin);
   30|  1.35k|    assert(is_addition_overflow_custom == is_addition_overflow_builtin);
   31|  1.35k|    if (!is_addition_overflow_custom) {
  ------------------
  |  Branch (31:9): [True: 98, False: 1.25k]
  ------------------
   32|     98|        assert(i + j == result_builtin);
   33|     98|    }
   34|  1.35k|#endif
   35|  1.35k|    if (is_addition_overflow_custom) {
  ------------------
  |  Branch (35:9): [True: 1.25k, False: 98]
  ------------------
   36|  1.25k|        assert(sat_add == std::numeric_limits<T>::min() || sat_add == std::numeric_limits<T>::max());
   37|  1.25k|    } else {
   38|     98|        const auto add{i + j};
   39|     98|        assert(add == maybe_add.value());
   40|     98|        assert(add == sat_add);
   41|     98|    }
   42|  1.35k|}

LLVMFuzzerTestOneInput:
  222|  1.35k|{
  223|  1.35k|    test_one_input({data, size});
  224|  1.35k|    return 0;
  225|  1.35k|}
fuzz.cpp:_ZL14test_one_inputNSt3__14spanIKhLm18446744073709551615EEE:
   83|  1.35k|{
   84|  1.35k|    CheckGlobals check{};
   85|  1.35k|    (*Assert(g_test_one_input))(buffer);
  ------------------
  |  |   85|  1.35k|#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   86|  1.35k|}

_ZN12CheckGlobalsC2Ev:
   56|  1.35k|CheckGlobals::CheckGlobals() : m_impl(std::make_unique<CheckGlobalsImpl>()) {}
_ZN12CheckGlobalsD2Ev:
   57|  1.35k|CheckGlobals::~CheckGlobals() = default;
_ZN16CheckGlobalsImplC2Ev:
   17|  1.35k|    {
   18|  1.35k|        g_used_g_prng = false;
   19|  1.35k|        g_seeded_g_prng_zero = false;
   20|  1.35k|        g_used_system_time = false;
   21|  1.35k|        SetMockTime(0s);
   22|  1.35k|    }
_ZN16CheckGlobalsImplD2Ev:
   24|  1.35k|    {
   25|  1.35k|        if (g_used_g_prng && !g_seeded_g_prng_zero) {
  ------------------
  |  Branch (25:13): [True: 0, False: 1.35k]
  |  Branch (25:30): [True: 0, False: 0]
  ------------------
   26|      0|            std::cerr << "\n\n"
   27|      0|                         "The current fuzz target used the global random state.\n\n"
   28|       |
   29|      0|                         "This is acceptable, but requires the fuzz target to call \n"
   30|      0|                         "SeedRandomStateForTest(SeedRand::ZEROS) in the first line \n"
   31|      0|                         "of the FUZZ_TARGET function.\n\n"
   32|       |
   33|      0|                         "An alternative solution would be to avoid any use of globals.\n\n"
   34|       |
   35|      0|                         "Without a solution, fuzz instability and non-determinism can lead \n"
   36|      0|                         "to non-reproducible bugs or inefficient fuzzing.\n\n"
   37|      0|                      << std::endl;
   38|      0|            std::abort(); // Abort, because AFL may try to recover from a std::exit
   39|      0|        }
   40|       |
   41|  1.35k|        if (g_used_system_time) {
  ------------------
  |  Branch (41:13): [True: 0, False: 1.35k]
  ------------------
   42|      0|            std::cerr << "\n\n"
   43|      0|                         "The current fuzz target accessed system time.\n\n"
   44|       |
   45|      0|                         "This is acceptable, but requires the fuzz target to call \n"
   46|      0|                         "SetMockTime() at the beginning of processing the fuzz input.\n\n"
   47|       |
   48|      0|                         "Without setting mock time, time-dependent behavior can lead \n"
   49|      0|                         "to non-reproducible bugs or inefficient fuzzing.\n\n"
   50|      0|                      << std::endl;
   51|      0|            std::abort();
   52|      0|        }
   53|  1.35k|    }

_Z22inline_assertion_checkILb1EbEOT0_S1_PKciS3_S3_:
   52|  1.35k|{
   53|  1.35k|    if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING
  ------------------
  |  Branch (53:9): [Folded - Ignored]
  |  Branch (53:22): [Folded - Ignored]
  |  Branch (53:54): [Folded - Ignored]
  ------------------
   54|       |#ifdef ABORT_ON_FAILED_ASSUME
   55|       |        || true
   56|       |#endif
   57|  1.35k|    ) {
   58|  1.35k|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 1.35k]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|  1.35k|    }
   62|  1.35k|    return std::forward<T>(val);
   63|  1.35k|}
_Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_PKciSD_SD_:
   52|  1.35k|{
   53|  1.35k|    if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING
  ------------------
  |  Branch (53:9): [Folded - Ignored]
  |  Branch (53:22): [Folded - Ignored]
  |  Branch (53:54): [Folded - Ignored]
  ------------------
   54|       |#ifdef ABORT_ON_FAILED_ASSUME
   55|       |        || true
   56|       |#endif
   57|  1.35k|    ) {
   58|  1.35k|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 1.35k]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|  1.35k|    }
   62|  1.35k|    return std::forward<T>(val);
   63|  1.35k|}

_Z16AdditionOverflowIlEbT_S0_:
   16|  5.41k|{
   17|  5.41k|    static_assert(std::is_integral<T>::value, "Integral required.");
   18|  5.41k|    if constexpr (std::numeric_limits<T>::is_signed) {
   19|  5.41k|        return (i > 0 && j > std::numeric_limits<T>::max() - i) ||
  ------------------
  |  Branch (19:17): [True: 2.18k, False: 3.23k]
  |  Branch (19:26): [True: 688, False: 1.49k]
  ------------------
   20|  5.41k|               (i < 0 && j < std::numeric_limits<T>::min() - i);
  ------------------
  |  Branch (20:17): [True: 3.22k, False: 1.50k]
  |  Branch (20:26): [True: 1.49k, False: 1.72k]
  ------------------
   21|  5.41k|    }
   22|      0|    return std::numeric_limits<T>::max() - i < j;
   23|  5.41k|}
_Z10CheckedAddIlENSt3__18optionalIT_EES2_S2_:
   27|  2.70k|{
   28|  2.70k|    if (AdditionOverflow(i, j)) {
  ------------------
  |  Branch (28:9): [True: 1.09k, False: 1.61k]
  ------------------
   29|  1.09k|        return std::nullopt;
   30|  1.09k|    }
   31|  1.61k|    return i + j;
   32|  2.70k|}
_Z13SaturatingAddIlET_S0_S0_:
   36|  2.70k|{
   37|  2.70k|    if constexpr (std::numeric_limits<T>::is_signed) {
   38|  2.70k|        if (i > 0 && j > std::numeric_limits<T>::max() - i) {
  ------------------
  |  Branch (38:13): [True: 1.09k, False: 1.61k]
  |  Branch (38:22): [True: 344, False: 749]
  ------------------
   39|    344|            return std::numeric_limits<T>::max();
   40|    344|        }
   41|  2.36k|        if (i < 0 && j < std::numeric_limits<T>::min() - i) {
  ------------------
  |  Branch (41:13): [True: 1.61k, False: 754]
  |  Branch (41:22): [True: 746, False: 864]
  ------------------
   42|    746|            return std::numeric_limits<T>::min();
   43|    746|        }
   44|       |    } else {
   45|       |        if (std::numeric_limits<T>::max() - i < j) {
   46|       |            return std::numeric_limits<T>::max();
   47|       |        }
   48|       |    }
   49|  1.61k|    return i + j;
   50|  2.70k|}
_Z16AdditionOverflowImEbT_S0_:
   16|  5.41k|{
   17|  5.41k|    static_assert(std::is_integral<T>::value, "Integral required.");
   18|       |    if constexpr (std::numeric_limits<T>::is_signed) {
   19|       |        return (i > 0 && j > std::numeric_limits<T>::max() - i) ||
   20|       |               (i < 0 && j < std::numeric_limits<T>::min() - i);
   21|       |    }
   22|  5.41k|    return std::numeric_limits<T>::max() - i < j;
   23|  5.41k|}
_Z10CheckedAddImENSt3__18optionalIT_EES2_S2_:
   27|  2.70k|{
   28|  2.70k|    if (AdditionOverflow(i, j)) {
  ------------------
  |  Branch (28:9): [True: 600, False: 2.10k]
  ------------------
   29|    600|        return std::nullopt;
   30|    600|    }
   31|  2.10k|    return i + j;
   32|  2.70k|}
_Z13SaturatingAddImET_S0_S0_:
   36|  2.70k|{
   37|       |    if constexpr (std::numeric_limits<T>::is_signed) {
   38|       |        if (i > 0 && j > std::numeric_limits<T>::max() - i) {
   39|       |            return std::numeric_limits<T>::max();
   40|       |        }
   41|       |        if (i < 0 && j < std::numeric_limits<T>::min() - i) {
   42|       |            return std::numeric_limits<T>::min();
   43|       |        }
   44|  2.70k|    } else {
   45|  2.70k|        if (std::numeric_limits<T>::max() - i < j) {
  ------------------
  |  Branch (45:13): [True: 600, False: 2.10k]
  ------------------
   46|    600|            return std::numeric_limits<T>::max();
   47|    600|        }
   48|  2.70k|    }
   49|  2.10k|    return i + j;
   50|  2.70k|}
_Z16AdditionOverflowIiEbT_S0_:
   16|  5.41k|{
   17|  5.41k|    static_assert(std::is_integral<T>::value, "Integral required.");
   18|  5.41k|    if constexpr (std::numeric_limits<T>::is_signed) {
   19|  5.41k|        return (i > 0 && j > std::numeric_limits<T>::max() - i) ||
  ------------------
  |  Branch (19:17): [True: 1.14k, False: 4.26k]
  |  Branch (19:26): [True: 492, False: 656]
  ------------------
   20|  5.41k|               (i < 0 && j < std::numeric_limits<T>::min() - i);
  ------------------
  |  Branch (20:17): [True: 4.25k, False: 666]
  |  Branch (20:26): [True: 3.46k, False: 798]
  ------------------
   21|  5.41k|    }
   22|      0|    return std::numeric_limits<T>::max() - i < j;
   23|  5.41k|}
_Z10CheckedAddIiENSt3__18optionalIT_EES2_S2_:
   27|  2.70k|{
   28|  2.70k|    if (AdditionOverflow(i, j)) {
  ------------------
  |  Branch (28:9): [True: 1.97k, False: 732]
  ------------------
   29|  1.97k|        return std::nullopt;
   30|  1.97k|    }
   31|    732|    return i + j;
   32|  2.70k|}
_Z13SaturatingAddIiET_S0_S0_:
   36|  2.70k|{
   37|  2.70k|    if constexpr (std::numeric_limits<T>::is_signed) {
   38|  2.70k|        if (i > 0 && j > std::numeric_limits<T>::max() - i) {
  ------------------
  |  Branch (38:13): [True: 574, False: 2.13k]
  |  Branch (38:22): [True: 246, False: 328]
  ------------------
   39|    246|            return std::numeric_limits<T>::max();
   40|    246|        }
   41|  2.46k|        if (i < 0 && j < std::numeric_limits<T>::min() - i) {
  ------------------
  |  Branch (41:13): [True: 2.12k, False: 333]
  |  Branch (41:22): [True: 1.73k, False: 399]
  ------------------
   42|  1.73k|            return std::numeric_limits<T>::min();
   43|  1.73k|        }
   44|       |    } else {
   45|       |        if (std::numeric_limits<T>::max() - i < j) {
   46|       |            return std::numeric_limits<T>::max();
   47|       |        }
   48|       |    }
   49|    732|    return i + j;
   50|  2.70k|}
_Z16AdditionOverflowIjEbT_S0_:
   16|  5.41k|{
   17|  5.41k|    static_assert(std::is_integral<T>::value, "Integral required.");
   18|       |    if constexpr (std::numeric_limits<T>::is_signed) {
   19|       |        return (i > 0 && j > std::numeric_limits<T>::max() - i) ||
   20|       |               (i < 0 && j < std::numeric_limits<T>::min() - i);
   21|       |    }
   22|  5.41k|    return std::numeric_limits<T>::max() - i < j;
   23|  5.41k|}
_Z10CheckedAddIjENSt3__18optionalIT_EES2_S2_:
   27|  2.70k|{
   28|  2.70k|    if (AdditionOverflow(i, j)) {
  ------------------
  |  Branch (28:9): [True: 330, False: 2.37k]
  ------------------
   29|    330|        return std::nullopt;
   30|    330|    }
   31|  2.37k|    return i + j;
   32|  2.70k|}
_Z13SaturatingAddIjET_S0_S0_:
   36|  2.70k|{
   37|       |    if constexpr (std::numeric_limits<T>::is_signed) {
   38|       |        if (i > 0 && j > std::numeric_limits<T>::max() - i) {
   39|       |            return std::numeric_limits<T>::max();
   40|       |        }
   41|       |        if (i < 0 && j < std::numeric_limits<T>::min() - i) {
   42|       |            return std::numeric_limits<T>::min();
   43|       |        }
   44|  2.70k|    } else {
   45|  2.70k|        if (std::numeric_limits<T>::max() - i < j) {
  ------------------
  |  Branch (45:13): [True: 330, False: 2.37k]
  ------------------
   46|    330|            return std::numeric_limits<T>::max();
   47|    330|        }
   48|  2.70k|    }
   49|  2.37k|    return i + j;
   50|  2.70k|}
_Z16AdditionOverflowIsEbT_S0_:
   16|  5.41k|{
   17|  5.41k|    static_assert(std::is_integral<T>::value, "Integral required.");
   18|  5.41k|    if constexpr (std::numeric_limits<T>::is_signed) {
   19|  5.41k|        return (i > 0 && j > std::numeric_limits<T>::max() - i) ||
  ------------------
  |  Branch (19:17): [True: 630, False: 4.78k]
  |  Branch (19:26): [True: 208, False: 422]
  ------------------
   20|  5.41k|               (i < 0 && j < std::numeric_limits<T>::min() - i);
  ------------------
  |  Branch (20:17): [True: 4.77k, False: 430]
  |  Branch (20:26): [True: 4.32k, False: 454]
  ------------------
   21|  5.41k|    }
   22|      0|    return std::numeric_limits<T>::max() - i < j;
   23|  5.41k|}
_Z10CheckedAddIsENSt3__18optionalIT_EES2_S2_:
   27|  2.70k|{
   28|  2.70k|    if (AdditionOverflow(i, j)) {
  ------------------
  |  Branch (28:9): [True: 2.26k, False: 442]
  ------------------
   29|  2.26k|        return std::nullopt;
   30|  2.26k|    }
   31|    442|    return i + j;
   32|  2.70k|}
_Z13SaturatingAddIsET_S0_S0_:
   36|  2.70k|{
   37|  2.70k|    if constexpr (std::numeric_limits<T>::is_signed) {
   38|  2.70k|        if (i > 0 && j > std::numeric_limits<T>::max() - i) {
  ------------------
  |  Branch (38:13): [True: 315, False: 2.39k]
  |  Branch (38:22): [True: 104, False: 211]
  ------------------
   39|    104|            return std::numeric_limits<T>::max();
   40|    104|        }
   41|  2.60k|        if (i < 0 && j < std::numeric_limits<T>::min() - i) {
  ------------------
  |  Branch (41:13): [True: 2.38k, False: 215]
  |  Branch (41:22): [True: 2.16k, False: 227]
  ------------------
   42|  2.16k|            return std::numeric_limits<T>::min();
   43|  2.16k|        }
   44|       |    } else {
   45|       |        if (std::numeric_limits<T>::max() - i < j) {
   46|       |            return std::numeric_limits<T>::max();
   47|       |        }
   48|       |    }
   49|    442|    return i + j;
   50|  2.70k|}
_Z16AdditionOverflowItEbT_S0_:
   16|  5.41k|{
   17|  5.41k|    static_assert(std::is_integral<T>::value, "Integral required.");
   18|       |    if constexpr (std::numeric_limits<T>::is_signed) {
   19|       |        return (i > 0 && j > std::numeric_limits<T>::max() - i) ||
   20|       |               (i < 0 && j < std::numeric_limits<T>::min() - i);
   21|       |    }
   22|  5.41k|    return std::numeric_limits<T>::max() - i < j;
   23|  5.41k|}
_Z10CheckedAddItENSt3__18optionalIT_EES2_S2_:
   27|  2.70k|{
   28|  2.70k|    if (AdditionOverflow(i, j)) {
  ------------------
  |  Branch (28:9): [True: 192, False: 2.51k]
  ------------------
   29|    192|        return std::nullopt;
   30|    192|    }
   31|  2.51k|    return i + j;
   32|  2.70k|}
_Z13SaturatingAddItET_S0_S0_:
   36|  2.70k|{
   37|       |    if constexpr (std::numeric_limits<T>::is_signed) {
   38|       |        if (i > 0 && j > std::numeric_limits<T>::max() - i) {
   39|       |            return std::numeric_limits<T>::max();
   40|       |        }
   41|       |        if (i < 0 && j < std::numeric_limits<T>::min() - i) {
   42|       |            return std::numeric_limits<T>::min();
   43|       |        }
   44|  2.70k|    } else {
   45|  2.70k|        if (std::numeric_limits<T>::max() - i < j) {
  ------------------
  |  Branch (45:13): [True: 192, False: 2.51k]
  ------------------
   46|    192|            return std::numeric_limits<T>::max();
   47|    192|        }
   48|  2.70k|    }
   49|  2.51k|    return i + j;
   50|  2.70k|}
_Z16AdditionOverflowIcEbT_S0_:
   16|  5.41k|{
   17|  5.41k|    static_assert(std::is_integral<T>::value, "Integral required.");
   18|  5.41k|    if constexpr (std::numeric_limits<T>::is_signed) {
   19|  5.41k|        return (i > 0 && j > std::numeric_limits<T>::max() - i) ||
  ------------------
  |  Branch (19:17): [True: 366, False: 5.05k]
  |  Branch (19:26): [True: 156, False: 210]
  ------------------
   20|  5.41k|               (i < 0 && j < std::numeric_limits<T>::min() - i);
  ------------------
  |  Branch (20:17): [True: 5.02k, False: 238]
  |  Branch (20:26): [True: 4.71k, False: 306]
  ------------------
   21|  5.41k|    }
   22|      0|    return std::numeric_limits<T>::max() - i < j;
   23|  5.41k|}
_Z10CheckedAddIcENSt3__18optionalIT_EES2_S2_:
   27|  2.70k|{
   28|  2.70k|    if (AdditionOverflow(i, j)) {
  ------------------
  |  Branch (28:9): [True: 2.43k, False: 272]
  ------------------
   29|  2.43k|        return std::nullopt;
   30|  2.43k|    }
   31|    272|    return i + j;
   32|  2.70k|}
_Z13SaturatingAddIcET_S0_S0_:
   36|  2.70k|{
   37|  2.70k|    if constexpr (std::numeric_limits<T>::is_signed) {
   38|  2.70k|        if (i > 0 && j > std::numeric_limits<T>::max() - i) {
  ------------------
  |  Branch (38:13): [True: 183, False: 2.52k]
  |  Branch (38:22): [True: 78, False: 105]
  ------------------
   39|     78|            return std::numeric_limits<T>::max();
   40|     78|        }
   41|  2.63k|        if (i < 0 && j < std::numeric_limits<T>::min() - i) {
  ------------------
  |  Branch (41:13): [True: 2.51k, False: 119]
  |  Branch (41:22): [True: 2.35k, False: 153]
  ------------------
   42|  2.35k|            return std::numeric_limits<T>::min();
   43|  2.35k|        }
   44|       |    } else {
   45|       |        if (std::numeric_limits<T>::max() - i < j) {
   46|       |            return std::numeric_limits<T>::max();
   47|       |        }
   48|       |    }
   49|    272|    return i + j;
   50|  2.70k|}
_Z16AdditionOverflowIhEbT_S0_:
   16|  5.41k|{
   17|  5.41k|    static_assert(std::is_integral<T>::value, "Integral required.");
   18|       |    if constexpr (std::numeric_limits<T>::is_signed) {
   19|       |        return (i > 0 && j > std::numeric_limits<T>::max() - i) ||
   20|       |               (i < 0 && j < std::numeric_limits<T>::min() - i);
   21|       |    }
   22|  5.41k|    return std::numeric_limits<T>::max() - i < j;
   23|  5.41k|}
_Z10CheckedAddIhENSt3__18optionalIT_EES2_S2_:
   27|  2.70k|{
   28|  2.70k|    if (AdditionOverflow(i, j)) {
  ------------------
  |  Branch (28:9): [True: 134, False: 2.57k]
  ------------------
   29|    134|        return std::nullopt;
   30|    134|    }
   31|  2.57k|    return i + j;
   32|  2.70k|}
_Z13SaturatingAddIhET_S0_S0_:
   36|  2.70k|{
   37|       |    if constexpr (std::numeric_limits<T>::is_signed) {
   38|       |        if (i > 0 && j > std::numeric_limits<T>::max() - i) {
   39|       |            return std::numeric_limits<T>::max();
   40|       |        }
   41|       |        if (i < 0 && j < std::numeric_limits<T>::min() - i) {
   42|       |            return std::numeric_limits<T>::min();
   43|       |        }
   44|  2.70k|    } else {
   45|  2.70k|        if (std::numeric_limits<T>::max() - i < j) {
  ------------------
  |  Branch (45:13): [True: 134, False: 2.57k]
  ------------------
   46|    134|            return std::numeric_limits<T>::max();
   47|    134|        }
   48|  2.70k|    }
   49|  2.57k|    return i + j;
   50|  2.70k|}
_Z16AdditionOverflowIaEbT_S0_:
   16|  5.41k|{
   17|  5.41k|    static_assert(std::is_integral<T>::value, "Integral required.");
   18|  5.41k|    if constexpr (std::numeric_limits<T>::is_signed) {
   19|  5.41k|        return (i > 0 && j > std::numeric_limits<T>::max() - i) ||
  ------------------
  |  Branch (19:17): [True: 264, False: 5.15k]
  |  Branch (19:26): [True: 120, False: 144]
  ------------------
   20|  5.41k|               (i < 0 && j < std::numeric_limits<T>::min() - i);
  ------------------
  |  Branch (20:17): [True: 5.14k, False: 156]
  |  Branch (20:26): [True: 4.90k, False: 236]
  ------------------
   21|  5.41k|    }
   22|      0|    return std::numeric_limits<T>::max() - i < j;
   23|  5.41k|}
_Z10CheckedAddIaENSt3__18optionalIT_EES2_S2_:
   27|  2.70k|{
   28|  2.70k|    if (AdditionOverflow(i, j)) {
  ------------------
  |  Branch (28:9): [True: 2.51k, False: 196]
  ------------------
   29|  2.51k|        return std::nullopt;
   30|  2.51k|    }
   31|    196|    return i + j;
   32|  2.70k|}
_Z13SaturatingAddIaET_S0_S0_:
   36|  2.70k|{
   37|  2.70k|    if constexpr (std::numeric_limits<T>::is_signed) {
   38|  2.70k|        if (i > 0 && j > std::numeric_limits<T>::max() - i) {
  ------------------
  |  Branch (38:13): [True: 132, False: 2.57k]
  |  Branch (38:22): [True: 60, False: 72]
  ------------------
   39|     60|            return std::numeric_limits<T>::max();
   40|     60|        }
   41|  2.64k|        if (i < 0 && j < std::numeric_limits<T>::min() - i) {
  ------------------
  |  Branch (41:13): [True: 2.57k, False: 78]
  |  Branch (41:22): [True: 2.45k, False: 118]
  ------------------
   42|  2.45k|            return std::numeric_limits<T>::min();
   43|  2.45k|        }
   44|       |    } else {
   45|       |        if (std::numeric_limits<T>::max() - i < j) {
   46|       |            return std::numeric_limits<T>::max();
   47|       |        }
   48|       |    }
   49|    196|    return i + j;
   50|  2.70k|}

_Z11SetMockTimeNSt3__16chrono8durationIxNS_5ratioILl1ELl1EEEEE:
   42|  1.35k|{
   43|  1.35k|    Assert(mock_time_in >= 0s);
  ------------------
  |  |   85|  1.35k|#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   44|  1.35k|    g_mock_time.store(mock_time_in, std::memory_order_relaxed);
   45|  1.35k|}