_ZN4absl8bit_castIdmLi0EEET_RKT0_:
  163|  1.27k|inline constexpr Dest bit_cast(const Source& source) {
  164|  1.27k|  return __builtin_bit_cast(Dest, source);
  165|  1.27k|}
_ZN4absl8bit_castIfjLi0EEET_RKT0_:
  163|  1.27k|inline constexpr Dest bit_cast(const Source& source) {
  164|  1.27k|  return __builtin_bit_cast(Dest, source);
  165|  1.27k|}

_ZN4absl13little_endian10FromHost16Et:
  107|  10.1k|inline uint16_t FromHost16(uint16_t x) { return x; }
_ZN4absl13little_endian10FromHost32Ej:
  110|    214|inline uint32_t FromHost32(uint32_t x) { return x; }
_ZN4absl13little_endian10FromHost64Em:
  113|  2.30k|inline uint64_t FromHost64(uint64_t x) { return x; }
_ZN4absl13little_endian7Store16EPvt:
  168|  10.1k|inline void Store16(absl::Nonnull<void *> p, uint16_t v) {
  169|  10.1k|  ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
  ------------------
  |  |   81|  10.1k|  (absl::base_internal::UnalignedStore16(_p, _val))
  ------------------
  170|  10.1k|}
_ZN4absl13little_endian7Store32EPvj:
  176|    214|inline void Store32(absl::Nonnull<void *> p, uint32_t v) {
  177|    214|  ABSL_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
  ------------------
  |  |   83|    214|  (absl::base_internal::UnalignedStore32(_p, _val))
  ------------------
  178|    214|}
_ZN4absl13little_endian7Store64EPvm:
  184|  2.30k|inline void Store64(absl::Nonnull<void *> p, uint64_t v) {
  185|  2.30k|  ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
  ------------------
  |  |   85|  2.30k|  (absl::base_internal::UnalignedStore64(_p, _val))
  ------------------
  186|  2.30k|}

_ZN4absl13base_internal16UnalignedStore16EPvt:
   57|  10.1k|inline void UnalignedStore16(absl::Nonnull<void *> p, uint16_t v) {
   58|  10.1k|  memcpy(p, &v, sizeof v);
   59|  10.1k|}
_ZN4absl13base_internal16UnalignedStore32EPvj:
   61|    214|inline void UnalignedStore32(absl::Nonnull<void *> p, uint32_t v) {
   62|    214|  memcpy(p, &v, sizeof v);
   63|    214|}
_ZN4absl13base_internal16UnalignedStore64EPvm:
   65|  2.30k|inline void UnalignedStore64(absl::Nonnull<void *> p, uint64_t v) {
   66|  2.30k|  memcpy(p, &v, sizeof v);
   67|  2.30k|}

_ZN4absl11countl_zeroImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES3_:
  103|  2.54k|    countl_zero(T x) noexcept {
  104|  2.54k|  return numeric_internal::CountLeadingZeroes(x);
  105|  2.54k|}

_ZN4absl7uint128pLES0_:
  613|     83|inline uint128& uint128::operator+=(uint128 other) {
  614|     83|  *this = *this + other;
  615|     83|  return *this;
  616|     83|}
_ZN4absl12Uint128Low64ENS_7uint128E:
  638|  2.70k|constexpr uint64_t Uint128Low64(uint128 v) { return v.lo_; }
_ZN4absl13Uint128High64ENS_7uint128E:
  640|  7.89k|constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; }
_ZNK4absl7uint128cvoEv:
  771|  5.42k|constexpr uint128::operator unsigned __int128() const {
  772|  5.42k|  return (static_cast<unsigned __int128>(hi_) << 64) + lo_;
  773|  5.42k|}
_ZN4abslplENS_7uint128ES0_:
  942|     83|constexpr uint128 operator+(uint128 lhs, uint128 rhs) {
  943|     83|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  944|     83|  return static_cast<unsigned __int128>(lhs) +
  945|     83|         static_cast<unsigned __int128>(rhs);
  946|       |#else
  947|       |  return int128_internal::AddResult(
  948|       |      MakeUint128(Uint128High64(lhs) + Uint128High64(rhs),
  949|       |                  Uint128Low64(lhs) + Uint128Low64(rhs)),
  950|       |      lhs);
  951|       |#endif
  952|     83|}
_ZN4abslmlENS_7uint128ES0_:
  977|  2.63k|inline uint128 operator*(uint128 lhs, uint128 rhs) {
  978|  2.63k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  979|       |  // TODO(strel) Remove once alignment issues are resolved and unsigned __int128
  980|       |  // can be used for uint128 storage.
  981|  2.63k|  return static_cast<unsigned __int128>(lhs) *
  982|  2.63k|         static_cast<unsigned __int128>(rhs);
  983|       |#elif defined(_MSC_VER) && defined(_M_X64) && !defined(_M_ARM64EC)
  984|       |  uint64_t carry;
  985|       |  uint64_t low = _umul128(Uint128Low64(lhs), Uint128Low64(rhs), &carry);
  986|       |  return MakeUint128(Uint128Low64(lhs) * Uint128High64(rhs) +
  987|       |                         Uint128High64(lhs) * Uint128Low64(rhs) + carry,
  988|       |                     low);
  989|       |#else   // ABSL_HAVE_INTRINSIC128
  990|       |  uint64_t a32 = Uint128Low64(lhs) >> 32;
  991|       |  uint64_t a00 = Uint128Low64(lhs) & 0xffffffff;
  992|       |  uint64_t b32 = Uint128Low64(rhs) >> 32;
  993|       |  uint64_t b00 = Uint128Low64(rhs) & 0xffffffff;
  994|       |  uint128 result =
  995|       |      MakeUint128(Uint128High64(lhs) * Uint128Low64(rhs) +
  996|       |                      Uint128Low64(lhs) * Uint128High64(rhs) + a32 * b32,
  997|       |                  a00 * b00);
  998|       |  result += uint128(a32 * b00) << 32;
  999|       |  result += uint128(a00 * b32) << 32;
 1000|       |  return result;
 1001|       |#endif  // ABSL_HAVE_INTRINSIC128
 1002|  2.63k|}
_ZN4absl7uint128C2Eo:
  670|  2.71k|      hi_{static_cast<uint64_t>(v >> 64)} {}
_ZN4absl7uint128C2Em:
  660|  5.34k|constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {}

_ZN4absl16numeric_internal20CountLeadingZeroes64Em:
  180|  2.54k|CountLeadingZeroes64(uint64_t x) {
  181|  2.54k|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clzll)
  182|       |  // Use __builtin_clzll, which uses the following instructions:
  183|       |  //  x86: bsr, lzcnt
  184|       |  //  ARM64: clz
  185|       |  //  PPC: cntlzd
  186|  2.54k|  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
  187|  2.54k|                "__builtin_clzll does not take 64-bit arg");
  188|       |
  189|       |  // Handle 0 as a special case because __builtin_clzll(0) is undefined.
  190|  2.54k|  return x == 0 ? 64 : __builtin_clzll(x);
  ------------------
  |  Branch (190:10): [True: 0, False: 2.54k]
  ------------------
  191|       |#elif defined(_MSC_VER) && !defined(__clang__) && \
  192|       |    (defined(_M_X64) || defined(_M_ARM64))
  193|       |  // MSVC does not have __buitin_clzll. Use _BitScanReverse64.
  194|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  195|       |  if (_BitScanReverse64(&result, x)) {
  196|       |    return 63 - result;
  197|       |  }
  198|       |  return 64;
  199|       |#elif defined(_MSC_VER) && !defined(__clang__)
  200|       |  // MSVC does not have __buitin_clzll. Compose two calls to _BitScanReverse
  201|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  202|       |  if ((x >> 32) &&
  203|       |      _BitScanReverse(&result, static_cast<unsigned long>(x >> 32))) {
  204|       |    return 31 - result;
  205|       |  }
  206|       |  if (_BitScanReverse(&result, static_cast<unsigned long>(x))) {
  207|       |    return 63 - result;
  208|       |  }
  209|       |  return 64;
  210|       |#else
  211|       |  int zeroes = 60;
  212|       |  if (x >> 32) {
  213|       |    zeroes -= 32;
  214|       |    x >>= 32;
  215|       |  }
  216|       |  if (x >> 16) {
  217|       |    zeroes -= 16;
  218|       |    x >>= 16;
  219|       |  }
  220|       |  if (x >> 8) {
  221|       |    zeroes -= 8;
  222|       |    x >>= 8;
  223|       |  }
  224|       |  if (x >> 4) {
  225|       |    zeroes -= 4;
  226|       |    x >>= 4;
  227|       |  }
  228|       |  return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[x] + zeroes;
  229|       |#endif
  230|  2.54k|}
_ZN4absl16numeric_internal18CountLeadingZeroesImEEiT_:
  234|  2.54k|CountLeadingZeroes(T x) {
  235|  2.54k|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  236|  2.54k|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  237|  2.54k|                "T must have a power-of-2 size");
  238|  2.54k|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  239|  2.54k|  return sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (239:10): [Folded - Ignored]
  ------------------
  240|  2.54k|             ? CountLeadingZeroes16(static_cast<uint16_t>(x)) -
  241|      0|                   (std::numeric_limits<uint16_t>::digits -
  242|      0|                    std::numeric_limits<T>::digits)
  243|  2.54k|             : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (243:17): [Folded - Ignored]
  ------------------
  244|  2.54k|                    ? CountLeadingZeroes32(static_cast<uint32_t>(x)) -
  245|      0|                          (std::numeric_limits<uint32_t>::digits -
  246|      0|                           std::numeric_limits<T>::digits)
  247|  2.54k|                    : CountLeadingZeroes64(x));
  248|  2.54k|}

_ZN4absl13ascii_isspaceEh:
   97|  7.76k|inline bool ascii_isspace(unsigned char c) {
   98|  7.76k|  return (ascii_internal::kPropertyBits[c] & 0x08) != 0;
   99|  7.76k|}
_ZN4absl27StripLeadingAsciiWhitespaceENS_11string_viewE:
  200|  2.58k|    absl::string_view str) {
  201|  2.58k|  auto it = std::find_if_not(str.begin(), str.end(), absl::ascii_isspace);
  202|  2.58k|  return str.substr(static_cast<size_t>(it - str.begin()));
  203|  2.58k|}
_ZN4absl28StripTrailingAsciiWhitespaceENS_11string_viewE:
  214|  2.58k|    absl::string_view str) {
  215|  2.58k|  auto it = std::find_if_not(str.rbegin(), str.rend(), absl::ascii_isspace);
  216|  2.58k|  return str.substr(0, static_cast<size_t>(str.rend() - it));
  217|  2.58k|}
_ZN4absl20StripAsciiWhitespaceENS_11string_viewE:
  228|  2.58k|    absl::string_view str) {
  229|  2.58k|  return StripTrailingAsciiWhitespace(StripLeadingAsciiWhitespace(str));
  230|  2.58k|}

_ZN4absl10from_charsEPKcS1_RdNS_12chars_formatE:
  953|  1.29k|                             chars_format fmt) {
  954|  1.29k|  return FromCharsImpl(first, last, value, fmt);
  955|  1.29k|}
_ZN4absl10from_charsEPKcS1_RfNS_12chars_formatE:
  959|  1.29k|                             chars_format fmt) {
  960|  1.29k|  return FromCharsImpl(first, last, value, fmt);
  961|  1.29k|}
charconv.cc:_ZN4absl12_GLOBAL__N_113FromCharsImplIdEENS_17from_chars_resultEPKcS4_RT_NS_12chars_formatE:
  866|  1.29k|                                FloatType& value, chars_format fmt_flags) {
  867|  1.29k|  from_chars_result result;
  868|  1.29k|  result.ptr = first;  // overwritten on successful parse
  869|  1.29k|  result.ec = std::errc();
  870|       |
  871|  1.29k|  bool negative = false;
  872|  1.29k|  if (first != last && *first == '-') {
  ------------------
  |  Branch (872:7): [True: 1.29k, False: 0]
  |  Branch (872:24): [True: 860, False: 434]
  ------------------
  873|    860|    ++first;
  874|    860|    negative = true;
  875|    860|  }
  876|       |  // If the `hex` flag is *not* set, then we will accept a 0x prefix and try
  877|       |  // to parse a hexadecimal float.
  878|  1.29k|  if ((fmt_flags & chars_format::hex) == chars_format{} && last - first >= 2 &&
  ------------------
  |  Branch (878:7): [True: 1.29k, False: 0]
  |  Branch (878:60): [True: 1.27k, False: 16]
  ------------------
  879|  1.29k|      *first == '0' && (first[1] == 'x' || first[1] == 'X')) {
  ------------------
  |  Branch (879:7): [True: 0, False: 1.27k]
  |  Branch (879:25): [True: 0, False: 0]
  |  Branch (879:44): [True: 0, False: 0]
  ------------------
  880|      0|    const char* hex_first = first + 2;
  881|      0|    strings_internal::ParsedFloat hex_parse =
  882|      0|        strings_internal::ParseFloat<16>(hex_first, last, fmt_flags);
  883|      0|    if (hex_parse.end == nullptr ||
  ------------------
  |  Branch (883:9): [True: 0, False: 0]
  ------------------
  884|      0|        hex_parse.type != strings_internal::FloatType::kNumber) {
  ------------------
  |  Branch (884:9): [True: 0, False: 0]
  ------------------
  885|       |      // Either we failed to parse a hex float after the "0x", or we read
  886|       |      // "0xinf" or "0xnan" which we don't want to match.
  887|       |      //
  888|       |      // However, a string that begins with "0x" also begins with "0", which
  889|       |      // is normally a valid match for the number zero.  So we want these
  890|       |      // strings to match zero unless fmt_flags is `scientific`.  (This flag
  891|       |      // means an exponent is required, which the string "0" does not have.)
  892|      0|      if (fmt_flags == chars_format::scientific) {
  ------------------
  |  Branch (892:11): [True: 0, False: 0]
  ------------------
  893|      0|        result.ec = std::errc::invalid_argument;
  894|      0|      } else {
  895|      0|        result.ptr = first + 1;
  896|      0|        value = negative ? -0.0 : 0.0;
  ------------------
  |  Branch (896:17): [True: 0, False: 0]
  ------------------
  897|      0|      }
  898|      0|      return result;
  899|      0|    }
  900|       |    // We matched a value.
  901|      0|    result.ptr = hex_parse.end;
  902|      0|    if (HandleEdgeCase(hex_parse, negative, &value)) {
  ------------------
  |  Branch (902:9): [True: 0, False: 0]
  ------------------
  903|      0|      return result;
  904|      0|    }
  905|      0|    CalculatedFloat calculated =
  906|      0|        CalculateFromParsedHexadecimal<FloatType>(hex_parse);
  907|      0|    EncodeResult(calculated, negative, &result, &value);
  908|      0|    return result;
  909|      0|  }
  910|       |  // Otherwise, we choose the number base based on the flags.
  911|  1.29k|  if ((fmt_flags & chars_format::hex) == chars_format::hex) {
  ------------------
  |  Branch (911:7): [True: 0, False: 1.29k]
  ------------------
  912|      0|    strings_internal::ParsedFloat hex_parse =
  913|      0|        strings_internal::ParseFloat<16>(first, last, fmt_flags);
  914|      0|    if (hex_parse.end == nullptr) {
  ------------------
  |  Branch (914:9): [True: 0, False: 0]
  ------------------
  915|      0|      result.ec = std::errc::invalid_argument;
  916|      0|      return result;
  917|      0|    }
  918|      0|    result.ptr = hex_parse.end;
  919|      0|    if (HandleEdgeCase(hex_parse, negative, &value)) {
  ------------------
  |  Branch (919:9): [True: 0, False: 0]
  ------------------
  920|      0|      return result;
  921|      0|    }
  922|      0|    CalculatedFloat calculated =
  923|      0|        CalculateFromParsedHexadecimal<FloatType>(hex_parse);
  924|      0|    EncodeResult(calculated, negative, &result, &value);
  925|      0|    return result;
  926|  1.29k|  } else {
  927|  1.29k|    strings_internal::ParsedFloat decimal_parse =
  928|  1.29k|        strings_internal::ParseFloat<10>(first, last, fmt_flags);
  929|  1.29k|    if (decimal_parse.end == nullptr) {
  ------------------
  |  Branch (929:9): [True: 0, False: 1.29k]
  ------------------
  930|      0|      result.ec = std::errc::invalid_argument;
  931|      0|      return result;
  932|      0|    }
  933|  1.29k|    result.ptr = decimal_parse.end;
  934|  1.29k|    if (HandleEdgeCase(decimal_parse, negative, &value)) {
  ------------------
  |  Branch (934:9): [True: 16, False: 1.27k]
  ------------------
  935|     16|      return result;
  936|     16|    }
  937|       |    // A nullptr subrange_begin means that the decimal_parse.mantissa is exact
  938|       |    // (not truncated), a precondition of the Eisel-Lemire algorithm.
  939|  1.27k|    if ((decimal_parse.subrange_begin == nullptr) &&
  ------------------
  |  Branch (939:9): [True: 1.27k, False: 0]
  ------------------
  940|  1.27k|        EiselLemire<FloatType>(decimal_parse, negative, &value, &result.ec)) {
  ------------------
  |  Branch (940:9): [True: 1.27k, False: 0]
  ------------------
  941|  1.27k|      return result;
  942|  1.27k|    }
  943|      0|    CalculatedFloat calculated =
  944|      0|        CalculateFromParsedDecimal<FloatType>(decimal_parse);
  945|      0|    EncodeResult(calculated, negative, &result, &value);
  946|      0|    return result;
  947|  1.27k|  }
  948|  1.29k|}
charconv.cc:_ZN4absl12_GLOBAL__N_114HandleEdgeCaseIdEEbRKNS_16strings_internal11ParsedFloatEbPT_:
  360|  1.29k|                    absl::Nonnull<FloatType*> value) {
  361|  1.29k|  if (input.type == strings_internal::FloatType::kNan) {
  ------------------
  |  Branch (361:7): [True: 0, False: 1.29k]
  ------------------
  362|       |    // A bug in both clang < 7 and gcc would cause the compiler to optimize
  363|       |    // away the buffer we are building below.  Declaring the buffer volatile
  364|       |    // avoids the issue, and has no measurable performance impact in
  365|       |    // microbenchmarks.
  366|       |    //
  367|       |    // https://bugs.llvm.org/show_bug.cgi?id=37778
  368|       |    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86113
  369|      0|    constexpr ptrdiff_t kNanBufferSize = 128;
  370|       |#if (defined(__GNUC__) && !defined(__clang__)) || \
  371|       |    (defined(__clang__) && __clang_major__ < 7)
  372|       |    volatile char n_char_sequence[kNanBufferSize];
  373|       |#else
  374|      0|    char n_char_sequence[kNanBufferSize];
  375|      0|#endif
  376|      0|    if (input.subrange_begin == nullptr) {
  ------------------
  |  Branch (376:9): [True: 0, False: 0]
  ------------------
  377|      0|      n_char_sequence[0] = '\0';
  378|      0|    } else {
  379|      0|      ptrdiff_t nan_size = input.subrange_end - input.subrange_begin;
  380|      0|      nan_size = std::min(nan_size, kNanBufferSize - 1);
  381|      0|      std::copy_n(input.subrange_begin, nan_size, n_char_sequence);
  382|      0|      n_char_sequence[nan_size] = '\0';
  383|      0|    }
  384|      0|    char* nan_argument = const_cast<char*>(n_char_sequence);
  385|      0|    *value = negative ? -FloatTraits<FloatType>::MakeNan(nan_argument)
  ------------------
  |  Branch (385:14): [True: 0, False: 0]
  ------------------
  386|      0|                      : FloatTraits<FloatType>::MakeNan(nan_argument);
  387|      0|    return true;
  388|      0|  }
  389|  1.29k|  if (input.type == strings_internal::FloatType::kInfinity) {
  ------------------
  |  Branch (389:7): [True: 0, False: 1.29k]
  ------------------
  390|      0|    *value = negative ? -std::numeric_limits<FloatType>::infinity()
  ------------------
  |  Branch (390:14): [True: 0, False: 0]
  ------------------
  391|      0|                      : std::numeric_limits<FloatType>::infinity();
  392|      0|    return true;
  393|      0|  }
  394|  1.29k|  if (input.mantissa == 0) {
  ------------------
  |  Branch (394:7): [True: 16, False: 1.27k]
  ------------------
  395|     16|    *value = negative ? -0.0 : 0.0;
  ------------------
  |  Branch (395:14): [True: 0, False: 16]
  ------------------
  396|     16|    return true;
  397|     16|  }
  398|  1.27k|  return false;
  399|  1.29k|}
charconv.cc:_ZN4absl12_GLOBAL__N_111EiselLemireIdEEbRKNS_16strings_internal11ParsedFloatEbPT_PNSt3__14errcE:
  691|  1.27k|                 absl::Nonnull<std::errc*> ec) {
  692|  1.27k|  uint64_t man = input.mantissa;
  693|  1.27k|  int exp10 = input.exponent;
  694|  1.27k|  if (exp10 < FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10) {
  ------------------
  |  Branch (694:7): [True: 0, False: 1.27k]
  ------------------
  695|      0|    *value = negative ? -0.0 : 0.0;
  ------------------
  |  Branch (695:14): [True: 0, False: 0]
  ------------------
  696|      0|    *ec = std::errc::result_out_of_range;
  697|      0|    return true;
  698|  1.27k|  } else if (exp10 >= FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10) {
  ------------------
  |  Branch (698:14): [True: 0, False: 1.27k]
  ------------------
  699|       |    // Return max (a finite value) consistent with from_chars and DR 3081. For
  700|       |    // SimpleAtod and SimpleAtof, post-processing will return infinity.
  701|      0|    *value = negative ? -std::numeric_limits<FloatType>::max()
  ------------------
  |  Branch (701:14): [True: 0, False: 0]
  ------------------
  702|      0|                      : std::numeric_limits<FloatType>::max();
  703|      0|    *ec = std::errc::result_out_of_range;
  704|      0|    return true;
  705|      0|  }
  706|       |
  707|       |  // Assert kPower10TableMinInclusive <= exp10 < kPower10TableMaxExclusive.
  708|       |  // Equivalently, !Power10Underflow(exp10) and !Power10Overflow(exp10).
  709|  1.27k|  static_assert(
  710|  1.27k|      FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10 >=
  711|  1.27k|          kPower10TableMinInclusive,
  712|  1.27k|      "(exp10-kPower10TableMinInclusive) in kPower10MantissaHighTable bounds");
  713|  1.27k|  static_assert(
  714|  1.27k|      FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10 <=
  715|  1.27k|          kPower10TableMaxExclusive,
  716|  1.27k|      "(exp10-kPower10TableMinInclusive) in kPower10MantissaHighTable bounds");
  717|       |
  718|       |  // The terse (+) comments in this function body refer to sections of the
  719|       |  // https://nigeltao.github.io/blog/2020/eisel-lemire.html blog post.
  720|       |  //
  721|       |  // That blog post discusses double precision (11 exponent bits with a -1023
  722|       |  // bias, 52 mantissa bits), but the same approach applies to single precision
  723|       |  // (8 exponent bits with a -127 bias, 23 mantissa bits). Either way, the
  724|       |  // computation here happens with 64-bit values (e.g. man) or 128-bit values
  725|       |  // (e.g. x) before finally converting to 64- or 32-bit floating point.
  726|       |  //
  727|       |  // See also "Number Parsing at a Gigabyte per Second, Software: Practice and
  728|       |  // Experience 51 (8), 2021" (https://arxiv.org/abs/2101.11408) for detail.
  729|       |
  730|       |  // (+) Normalization.
  731|  1.27k|  int clz = countl_zero(man);
  732|  1.27k|  man <<= static_cast<unsigned int>(clz);
  733|       |  // The 217706 etc magic numbers are from the Power10Exponent function.
  734|  1.27k|  uint64_t ret_exp2 =
  735|  1.27k|      static_cast<uint64_t>((217706 * exp10 >> 16) + 64 +
  736|  1.27k|                            FloatTraits<FloatType>::kExponentBias - clz);
  737|       |
  738|       |  // (+) Multiplication.
  739|  1.27k|  uint128 x = static_cast<uint128>(man) *
  740|  1.27k|              static_cast<uint128>(
  741|  1.27k|                  kPower10MantissaHighTable[exp10 - kPower10TableMinInclusive]);
  742|       |
  743|       |  // (+) Wider Approximation.
  744|  1.27k|  static constexpr uint64_t high64_mask =
  745|  1.27k|      FloatTraits<FloatType>::kEiselLemireMask;
  746|  1.27k|  if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (746:7): [True: 89, False: 1.18k]
  ------------------
  747|  1.27k|      (man > (std::numeric_limits<uint64_t>::max() - Uint128Low64(x)))) {
  ------------------
  |  Branch (747:7): [True: 83, False: 6]
  ------------------
  748|     83|    uint128 y =
  749|     83|        static_cast<uint128>(man) *
  750|     83|        static_cast<uint128>(
  751|     83|            kPower10MantissaLowTable[exp10 - kPower10TableMinInclusive]);
  752|     83|    x += Uint128High64(y);
  753|       |    // For example, parsing "4503599627370497.5" will take the if-true
  754|       |    // branch here (for double precision), since:
  755|       |    //  - x   = 0x8000000000000BFF_FFFFFFFFFFFFFFFF
  756|       |    //  - y   = 0x8000000000000BFF_7FFFFFFFFFFFF400
  757|       |    //  - man = 0xA000000000000F00
  758|       |    // Likewise, when parsing "0.0625" for single precision:
  759|       |    //  - x   = 0x7FFFFFFFFFFFFFFF_FFFFFFFFFFFFFFFF
  760|       |    //  - y   = 0x813FFFFFFFFFFFFF_8A00000000000000
  761|       |    //  - man = 0x9C40000000000000
  762|     83|    if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (762:9): [True: 65, False: 18]
  ------------------
  763|     83|        ((Uint128Low64(x) + 1) == 0) &&
  ------------------
  |  Branch (763:9): [True: 0, False: 65]
  ------------------
  764|     83|        (man > (std::numeric_limits<uint64_t>::max() - Uint128Low64(y)))) {
  ------------------
  |  Branch (764:9): [True: 0, False: 0]
  ------------------
  765|      0|      return false;
  766|      0|    }
  767|     83|  }
  768|       |
  769|       |  // (+) Shifting to 54 Bits (or for single precision, to 25 bits).
  770|  1.27k|  uint64_t msb = Uint128High64(x) >> 63;
  771|  1.27k|  uint64_t ret_man =
  772|  1.27k|      Uint128High64(x) >> (msb + FloatTraits<FloatType>::kEiselLemireShift);
  773|  1.27k|  ret_exp2 -= 1 ^ msb;
  774|       |
  775|       |  // (+) Half-way Ambiguity.
  776|       |  //
  777|       |  // For example, parsing "1e+23" will take the if-true branch here (for double
  778|       |  // precision), since:
  779|       |  //  - x       = 0x54B40B1F852BDA00_0000000000000000
  780|       |  //  - ret_man = 0x002A5A058FC295ED
  781|       |  // Likewise, when parsing "20040229.0" for single precision:
  782|       |  //  - x       = 0x4C72894000000000_0000000000000000
  783|       |  //  - ret_man = 0x000000000131CA25
  784|  1.27k|  if ((Uint128Low64(x) == 0) && ((Uint128High64(x) & high64_mask) == 0) &&
  ------------------
  |  Branch (784:7): [True: 8, False: 1.27k]
  |  Branch (784:33): [True: 0, False: 8]
  ------------------
  785|  1.27k|      ((ret_man & 3) == 1)) {
  ------------------
  |  Branch (785:7): [True: 0, False: 0]
  ------------------
  786|      0|    return false;
  787|      0|  }
  788|       |
  789|       |  // (+) From 54 to 53 Bits (or for single precision, from 25 to 24 bits).
  790|  1.27k|  ret_man += ret_man & 1;  // Line From54a.
  791|  1.27k|  ret_man >>= 1;           // Line From54b.
  792|       |  // Incrementing ret_man (at line From54a) may have overflowed 54 bits (53
  793|       |  // bits after the right shift by 1 at line From54b), so adjust for that.
  794|       |  //
  795|       |  // For example, parsing "9223372036854775807" will take the if-true branch
  796|       |  // here (for double precision), since:
  797|       |  //  - ret_man = 0x0020000000000000 = (1 << 53)
  798|       |  // Likewise, when parsing "2147483647.0" for single precision:
  799|       |  //  - ret_man = 0x0000000001000000 = (1 << 24)
  800|  1.27k|  if ((ret_man >> FloatTraits<FloatType>::kTargetMantissaBits) > 0) {
  ------------------
  |  Branch (800:7): [True: 0, False: 1.27k]
  ------------------
  801|      0|    ret_exp2 += 1;
  802|       |    // Conceptually, we need a "ret_man >>= 1" in this if-block to balance
  803|       |    // incrementing ret_exp2 in the line immediately above. However, we only
  804|       |    // get here when line From54a overflowed (after adding a 1), so ret_man
  805|       |    // here is (1 << 53). Its low 53 bits are therefore all zeroes. The only
  806|       |    // remaining use of ret_man is to mask it with ((1 << 52) - 1), so only its
  807|       |    // low 52 bits matter. A "ret_man >>= 1" would have no effect in practice.
  808|       |    //
  809|       |    // We omit the "ret_man >>= 1", even if it is cheap (and this if-branch is
  810|       |    // rarely taken) and technically 'more correct', so that mutation tests
  811|       |    // that would otherwise modify or omit that "ret_man >>= 1" don't complain
  812|       |    // that such code mutations have no observable effect.
  813|      0|  }
  814|       |
  815|       |  // ret_exp2 is a uint64_t. Zero or underflow means that we're in subnormal
  816|       |  // space. max_exp2 (0x7FF for double precision, 0xFF for single precision) or
  817|       |  // above means that we're in Inf/NaN space.
  818|       |  //
  819|       |  // The if block is equivalent to (but has fewer branches than):
  820|       |  //   if ((ret_exp2 <= 0) || (ret_exp2 >= max_exp2)) { etc }
  821|       |  //
  822|       |  // For example, parsing "4.9406564584124654e-324" will take the if-true
  823|       |  // branch here, since ret_exp2 = -51.
  824|  1.27k|  static constexpr uint64_t max_exp2 =
  825|  1.27k|      (1 << FloatTraits<FloatType>::kTargetExponentBits) - 1;
  826|  1.27k|  if ((ret_exp2 - 1) >= (max_exp2 - 1)) {
  ------------------
  |  Branch (826:7): [True: 0, False: 1.27k]
  ------------------
  827|      0|    return false;
  828|      0|  }
  829|       |
  830|       |#ifndef ABSL_BIT_PACK_FLOATS
  831|       |  if (FloatTraits<FloatType>::kTargetBits == 64) {
  832|       |    *value = FloatTraits<FloatType>::Make(
  833|       |        (ret_man & 0x000FFFFFFFFFFFFFu) | 0x0010000000000000u,
  834|       |        static_cast<int>(ret_exp2) - 1023 - 52, negative);
  835|       |    return true;
  836|       |  } else if (FloatTraits<FloatType>::kTargetBits == 32) {
  837|       |    *value = FloatTraits<FloatType>::Make(
  838|       |        (static_cast<uint32_t>(ret_man) & 0x007FFFFFu) | 0x00800000u,
  839|       |        static_cast<int>(ret_exp2) - 127 - 23, negative);
  840|       |    return true;
  841|       |  }
  842|       |#else
  843|  1.27k|  if (FloatTraits<FloatType>::kTargetBits == 64) {
  ------------------
  |  Branch (843:7): [Folded - Ignored]
  ------------------
  844|  1.27k|    uint64_t ret_bits = (ret_exp2 << 52) | (ret_man & 0x000FFFFFFFFFFFFFu);
  845|  1.27k|    if (negative) {
  ------------------
  |  Branch (845:9): [True: 860, False: 418]
  ------------------
  846|    860|      ret_bits |= 0x8000000000000000u;
  847|    860|    }
  848|  1.27k|    *value = absl::bit_cast<double>(ret_bits);
  849|  1.27k|    return true;
  850|  1.27k|  } else if (FloatTraits<FloatType>::kTargetBits == 32) {
  ------------------
  |  Branch (850:14): [Folded - Ignored]
  ------------------
  851|      0|    uint32_t ret_bits = (static_cast<uint32_t>(ret_exp2) << 23) |
  852|      0|                        (static_cast<uint32_t>(ret_man) & 0x007FFFFFu);
  853|      0|    if (negative) {
  ------------------
  |  Branch (853:9): [True: 0, False: 0]
  ------------------
  854|      0|      ret_bits |= 0x80000000u;
  855|      0|    }
  856|      0|    *value = absl::bit_cast<float>(ret_bits);
  857|      0|    return true;
  858|      0|  }
  859|      0|#endif  // ABSL_BIT_PACK_FLOATS
  860|      0|  return false;
  861|  1.27k|}
charconv.cc:_ZN4absl12_GLOBAL__N_113FromCharsImplIfEENS_17from_chars_resultEPKcS4_RT_NS_12chars_formatE:
  866|  1.29k|                                FloatType& value, chars_format fmt_flags) {
  867|  1.29k|  from_chars_result result;
  868|  1.29k|  result.ptr = first;  // overwritten on successful parse
  869|  1.29k|  result.ec = std::errc();
  870|       |
  871|  1.29k|  bool negative = false;
  872|  1.29k|  if (first != last && *first == '-') {
  ------------------
  |  Branch (872:7): [True: 1.29k, False: 0]
  |  Branch (872:24): [True: 756, False: 538]
  ------------------
  873|    756|    ++first;
  874|    756|    negative = true;
  875|    756|  }
  876|       |  // If the `hex` flag is *not* set, then we will accept a 0x prefix and try
  877|       |  // to parse a hexadecimal float.
  878|  1.29k|  if ((fmt_flags & chars_format::hex) == chars_format{} && last - first >= 2 &&
  ------------------
  |  Branch (878:7): [True: 1.29k, False: 0]
  |  Branch (878:60): [True: 1.27k, False: 24]
  ------------------
  879|  1.29k|      *first == '0' && (first[1] == 'x' || first[1] == 'X')) {
  ------------------
  |  Branch (879:7): [True: 0, False: 1.27k]
  |  Branch (879:25): [True: 0, False: 0]
  |  Branch (879:44): [True: 0, False: 0]
  ------------------
  880|      0|    const char* hex_first = first + 2;
  881|      0|    strings_internal::ParsedFloat hex_parse =
  882|      0|        strings_internal::ParseFloat<16>(hex_first, last, fmt_flags);
  883|      0|    if (hex_parse.end == nullptr ||
  ------------------
  |  Branch (883:9): [True: 0, False: 0]
  ------------------
  884|      0|        hex_parse.type != strings_internal::FloatType::kNumber) {
  ------------------
  |  Branch (884:9): [True: 0, False: 0]
  ------------------
  885|       |      // Either we failed to parse a hex float after the "0x", or we read
  886|       |      // "0xinf" or "0xnan" which we don't want to match.
  887|       |      //
  888|       |      // However, a string that begins with "0x" also begins with "0", which
  889|       |      // is normally a valid match for the number zero.  So we want these
  890|       |      // strings to match zero unless fmt_flags is `scientific`.  (This flag
  891|       |      // means an exponent is required, which the string "0" does not have.)
  892|      0|      if (fmt_flags == chars_format::scientific) {
  ------------------
  |  Branch (892:11): [True: 0, False: 0]
  ------------------
  893|      0|        result.ec = std::errc::invalid_argument;
  894|      0|      } else {
  895|      0|        result.ptr = first + 1;
  896|      0|        value = negative ? -0.0 : 0.0;
  ------------------
  |  Branch (896:17): [True: 0, False: 0]
  ------------------
  897|      0|      }
  898|      0|      return result;
  899|      0|    }
  900|       |    // We matched a value.
  901|      0|    result.ptr = hex_parse.end;
  902|      0|    if (HandleEdgeCase(hex_parse, negative, &value)) {
  ------------------
  |  Branch (902:9): [True: 0, False: 0]
  ------------------
  903|      0|      return result;
  904|      0|    }
  905|      0|    CalculatedFloat calculated =
  906|      0|        CalculateFromParsedHexadecimal<FloatType>(hex_parse);
  907|      0|    EncodeResult(calculated, negative, &result, &value);
  908|      0|    return result;
  909|      0|  }
  910|       |  // Otherwise, we choose the number base based on the flags.
  911|  1.29k|  if ((fmt_flags & chars_format::hex) == chars_format::hex) {
  ------------------
  |  Branch (911:7): [True: 0, False: 1.29k]
  ------------------
  912|      0|    strings_internal::ParsedFloat hex_parse =
  913|      0|        strings_internal::ParseFloat<16>(first, last, fmt_flags);
  914|      0|    if (hex_parse.end == nullptr) {
  ------------------
  |  Branch (914:9): [True: 0, False: 0]
  ------------------
  915|      0|      result.ec = std::errc::invalid_argument;
  916|      0|      return result;
  917|      0|    }
  918|      0|    result.ptr = hex_parse.end;
  919|      0|    if (HandleEdgeCase(hex_parse, negative, &value)) {
  ------------------
  |  Branch (919:9): [True: 0, False: 0]
  ------------------
  920|      0|      return result;
  921|      0|    }
  922|      0|    CalculatedFloat calculated =
  923|      0|        CalculateFromParsedHexadecimal<FloatType>(hex_parse);
  924|      0|    EncodeResult(calculated, negative, &result, &value);
  925|      0|    return result;
  926|  1.29k|  } else {
  927|  1.29k|    strings_internal::ParsedFloat decimal_parse =
  928|  1.29k|        strings_internal::ParseFloat<10>(first, last, fmt_flags);
  929|  1.29k|    if (decimal_parse.end == nullptr) {
  ------------------
  |  Branch (929:9): [True: 0, False: 1.29k]
  ------------------
  930|      0|      result.ec = std::errc::invalid_argument;
  931|      0|      return result;
  932|      0|    }
  933|  1.29k|    result.ptr = decimal_parse.end;
  934|  1.29k|    if (HandleEdgeCase(decimal_parse, negative, &value)) {
  ------------------
  |  Branch (934:9): [True: 24, False: 1.27k]
  ------------------
  935|     24|      return result;
  936|     24|    }
  937|       |    // A nullptr subrange_begin means that the decimal_parse.mantissa is exact
  938|       |    // (not truncated), a precondition of the Eisel-Lemire algorithm.
  939|  1.27k|    if ((decimal_parse.subrange_begin == nullptr) &&
  ------------------
  |  Branch (939:9): [True: 1.27k, False: 0]
  ------------------
  940|  1.27k|        EiselLemire<FloatType>(decimal_parse, negative, &value, &result.ec)) {
  ------------------
  |  Branch (940:9): [True: 1.27k, False: 0]
  ------------------
  941|  1.27k|      return result;
  942|  1.27k|    }
  943|      0|    CalculatedFloat calculated =
  944|      0|        CalculateFromParsedDecimal<FloatType>(decimal_parse);
  945|      0|    EncodeResult(calculated, negative, &result, &value);
  946|      0|    return result;
  947|  1.27k|  }
  948|  1.29k|}
charconv.cc:_ZN4absl12_GLOBAL__N_114HandleEdgeCaseIfEEbRKNS_16strings_internal11ParsedFloatEbPT_:
  360|  1.29k|                    absl::Nonnull<FloatType*> value) {
  361|  1.29k|  if (input.type == strings_internal::FloatType::kNan) {
  ------------------
  |  Branch (361:7): [True: 0, False: 1.29k]
  ------------------
  362|       |    // A bug in both clang < 7 and gcc would cause the compiler to optimize
  363|       |    // away the buffer we are building below.  Declaring the buffer volatile
  364|       |    // avoids the issue, and has no measurable performance impact in
  365|       |    // microbenchmarks.
  366|       |    //
  367|       |    // https://bugs.llvm.org/show_bug.cgi?id=37778
  368|       |    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86113
  369|      0|    constexpr ptrdiff_t kNanBufferSize = 128;
  370|       |#if (defined(__GNUC__) && !defined(__clang__)) || \
  371|       |    (defined(__clang__) && __clang_major__ < 7)
  372|       |    volatile char n_char_sequence[kNanBufferSize];
  373|       |#else
  374|      0|    char n_char_sequence[kNanBufferSize];
  375|      0|#endif
  376|      0|    if (input.subrange_begin == nullptr) {
  ------------------
  |  Branch (376:9): [True: 0, False: 0]
  ------------------
  377|      0|      n_char_sequence[0] = '\0';
  378|      0|    } else {
  379|      0|      ptrdiff_t nan_size = input.subrange_end - input.subrange_begin;
  380|      0|      nan_size = std::min(nan_size, kNanBufferSize - 1);
  381|      0|      std::copy_n(input.subrange_begin, nan_size, n_char_sequence);
  382|      0|      n_char_sequence[nan_size] = '\0';
  383|      0|    }
  384|      0|    char* nan_argument = const_cast<char*>(n_char_sequence);
  385|      0|    *value = negative ? -FloatTraits<FloatType>::MakeNan(nan_argument)
  ------------------
  |  Branch (385:14): [True: 0, False: 0]
  ------------------
  386|      0|                      : FloatTraits<FloatType>::MakeNan(nan_argument);
  387|      0|    return true;
  388|      0|  }
  389|  1.29k|  if (input.type == strings_internal::FloatType::kInfinity) {
  ------------------
  |  Branch (389:7): [True: 0, False: 1.29k]
  ------------------
  390|      0|    *value = negative ? -std::numeric_limits<FloatType>::infinity()
  ------------------
  |  Branch (390:14): [True: 0, False: 0]
  ------------------
  391|      0|                      : std::numeric_limits<FloatType>::infinity();
  392|      0|    return true;
  393|      0|  }
  394|  1.29k|  if (input.mantissa == 0) {
  ------------------
  |  Branch (394:7): [True: 24, False: 1.27k]
  ------------------
  395|     24|    *value = negative ? -0.0 : 0.0;
  ------------------
  |  Branch (395:14): [True: 0, False: 24]
  ------------------
  396|     24|    return true;
  397|     24|  }
  398|  1.27k|  return false;
  399|  1.29k|}
charconv.cc:_ZN4absl12_GLOBAL__N_111EiselLemireIfEEbRKNS_16strings_internal11ParsedFloatEbPT_PNSt3__14errcE:
  691|  1.27k|                 absl::Nonnull<std::errc*> ec) {
  692|  1.27k|  uint64_t man = input.mantissa;
  693|  1.27k|  int exp10 = input.exponent;
  694|  1.27k|  if (exp10 < FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10) {
  ------------------
  |  Branch (694:7): [True: 0, False: 1.27k]
  ------------------
  695|      0|    *value = negative ? -0.0 : 0.0;
  ------------------
  |  Branch (695:14): [True: 0, False: 0]
  ------------------
  696|      0|    *ec = std::errc::result_out_of_range;
  697|      0|    return true;
  698|  1.27k|  } else if (exp10 >= FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10) {
  ------------------
  |  Branch (698:14): [True: 0, False: 1.27k]
  ------------------
  699|       |    // Return max (a finite value) consistent with from_chars and DR 3081. For
  700|       |    // SimpleAtod and SimpleAtof, post-processing will return infinity.
  701|      0|    *value = negative ? -std::numeric_limits<FloatType>::max()
  ------------------
  |  Branch (701:14): [True: 0, False: 0]
  ------------------
  702|      0|                      : std::numeric_limits<FloatType>::max();
  703|      0|    *ec = std::errc::result_out_of_range;
  704|      0|    return true;
  705|      0|  }
  706|       |
  707|       |  // Assert kPower10TableMinInclusive <= exp10 < kPower10TableMaxExclusive.
  708|       |  // Equivalently, !Power10Underflow(exp10) and !Power10Overflow(exp10).
  709|  1.27k|  static_assert(
  710|  1.27k|      FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10 >=
  711|  1.27k|          kPower10TableMinInclusive,
  712|  1.27k|      "(exp10-kPower10TableMinInclusive) in kPower10MantissaHighTable bounds");
  713|  1.27k|  static_assert(
  714|  1.27k|      FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10 <=
  715|  1.27k|          kPower10TableMaxExclusive,
  716|  1.27k|      "(exp10-kPower10TableMinInclusive) in kPower10MantissaHighTable bounds");
  717|       |
  718|       |  // The terse (+) comments in this function body refer to sections of the
  719|       |  // https://nigeltao.github.io/blog/2020/eisel-lemire.html blog post.
  720|       |  //
  721|       |  // That blog post discusses double precision (11 exponent bits with a -1023
  722|       |  // bias, 52 mantissa bits), but the same approach applies to single precision
  723|       |  // (8 exponent bits with a -127 bias, 23 mantissa bits). Either way, the
  724|       |  // computation here happens with 64-bit values (e.g. man) or 128-bit values
  725|       |  // (e.g. x) before finally converting to 64- or 32-bit floating point.
  726|       |  //
  727|       |  // See also "Number Parsing at a Gigabyte per Second, Software: Practice and
  728|       |  // Experience 51 (8), 2021" (https://arxiv.org/abs/2101.11408) for detail.
  729|       |
  730|       |  // (+) Normalization.
  731|  1.27k|  int clz = countl_zero(man);
  732|  1.27k|  man <<= static_cast<unsigned int>(clz);
  733|       |  // The 217706 etc magic numbers are from the Power10Exponent function.
  734|  1.27k|  uint64_t ret_exp2 =
  735|  1.27k|      static_cast<uint64_t>((217706 * exp10 >> 16) + 64 +
  736|  1.27k|                            FloatTraits<FloatType>::kExponentBias - clz);
  737|       |
  738|       |  // (+) Multiplication.
  739|  1.27k|  uint128 x = static_cast<uint128>(man) *
  740|  1.27k|              static_cast<uint128>(
  741|  1.27k|                  kPower10MantissaHighTable[exp10 - kPower10TableMinInclusive]);
  742|       |
  743|       |  // (+) Wider Approximation.
  744|  1.27k|  static constexpr uint64_t high64_mask =
  745|  1.27k|      FloatTraits<FloatType>::kEiselLemireMask;
  746|  1.27k|  if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (746:7): [True: 0, False: 1.27k]
  ------------------
  747|  1.27k|      (man > (std::numeric_limits<uint64_t>::max() - Uint128Low64(x)))) {
  ------------------
  |  Branch (747:7): [True: 0, False: 0]
  ------------------
  748|      0|    uint128 y =
  749|      0|        static_cast<uint128>(man) *
  750|      0|        static_cast<uint128>(
  751|      0|            kPower10MantissaLowTable[exp10 - kPower10TableMinInclusive]);
  752|      0|    x += Uint128High64(y);
  753|       |    // For example, parsing "4503599627370497.5" will take the if-true
  754|       |    // branch here (for double precision), since:
  755|       |    //  - x   = 0x8000000000000BFF_FFFFFFFFFFFFFFFF
  756|       |    //  - y   = 0x8000000000000BFF_7FFFFFFFFFFFF400
  757|       |    //  - man = 0xA000000000000F00
  758|       |    // Likewise, when parsing "0.0625" for single precision:
  759|       |    //  - x   = 0x7FFFFFFFFFFFFFFF_FFFFFFFFFFFFFFFF
  760|       |    //  - y   = 0x813FFFFFFFFFFFFF_8A00000000000000
  761|       |    //  - man = 0x9C40000000000000
  762|      0|    if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (762:9): [True: 0, False: 0]
  ------------------
  763|      0|        ((Uint128Low64(x) + 1) == 0) &&
  ------------------
  |  Branch (763:9): [True: 0, False: 0]
  ------------------
  764|      0|        (man > (std::numeric_limits<uint64_t>::max() - Uint128Low64(y)))) {
  ------------------
  |  Branch (764:9): [True: 0, False: 0]
  ------------------
  765|      0|      return false;
  766|      0|    }
  767|      0|  }
  768|       |
  769|       |  // (+) Shifting to 54 Bits (or for single precision, to 25 bits).
  770|  1.27k|  uint64_t msb = Uint128High64(x) >> 63;
  771|  1.27k|  uint64_t ret_man =
  772|  1.27k|      Uint128High64(x) >> (msb + FloatTraits<FloatType>::kEiselLemireShift);
  773|  1.27k|  ret_exp2 -= 1 ^ msb;
  774|       |
  775|       |  // (+) Half-way Ambiguity.
  776|       |  //
  777|       |  // For example, parsing "1e+23" will take the if-true branch here (for double
  778|       |  // precision), since:
  779|       |  //  - x       = 0x54B40B1F852BDA00_0000000000000000
  780|       |  //  - ret_man = 0x002A5A058FC295ED
  781|       |  // Likewise, when parsing "20040229.0" for single precision:
  782|       |  //  - x       = 0x4C72894000000000_0000000000000000
  783|       |  //  - ret_man = 0x000000000131CA25
  784|  1.27k|  if ((Uint128Low64(x) == 0) && ((Uint128High64(x) & high64_mask) == 0) &&
  ------------------
  |  Branch (784:7): [True: 75, False: 1.19k]
  |  Branch (784:33): [True: 0, False: 75]
  ------------------
  785|  1.27k|      ((ret_man & 3) == 1)) {
  ------------------
  |  Branch (785:7): [True: 0, False: 0]
  ------------------
  786|      0|    return false;
  787|      0|  }
  788|       |
  789|       |  // (+) From 54 to 53 Bits (or for single precision, from 25 to 24 bits).
  790|  1.27k|  ret_man += ret_man & 1;  // Line From54a.
  791|  1.27k|  ret_man >>= 1;           // Line From54b.
  792|       |  // Incrementing ret_man (at line From54a) may have overflowed 54 bits (53
  793|       |  // bits after the right shift by 1 at line From54b), so adjust for that.
  794|       |  //
  795|       |  // For example, parsing "9223372036854775807" will take the if-true branch
  796|       |  // here (for double precision), since:
  797|       |  //  - ret_man = 0x0020000000000000 = (1 << 53)
  798|       |  // Likewise, when parsing "2147483647.0" for single precision:
  799|       |  //  - ret_man = 0x0000000001000000 = (1 << 24)
  800|  1.27k|  if ((ret_man >> FloatTraits<FloatType>::kTargetMantissaBits) > 0) {
  ------------------
  |  Branch (800:7): [True: 0, False: 1.27k]
  ------------------
  801|      0|    ret_exp2 += 1;
  802|       |    // Conceptually, we need a "ret_man >>= 1" in this if-block to balance
  803|       |    // incrementing ret_exp2 in the line immediately above. However, we only
  804|       |    // get here when line From54a overflowed (after adding a 1), so ret_man
  805|       |    // here is (1 << 53). Its low 53 bits are therefore all zeroes. The only
  806|       |    // remaining use of ret_man is to mask it with ((1 << 52) - 1), so only its
  807|       |    // low 52 bits matter. A "ret_man >>= 1" would have no effect in practice.
  808|       |    //
  809|       |    // We omit the "ret_man >>= 1", even if it is cheap (and this if-branch is
  810|       |    // rarely taken) and technically 'more correct', so that mutation tests
  811|       |    // that would otherwise modify or omit that "ret_man >>= 1" don't complain
  812|       |    // that such code mutations have no observable effect.
  813|      0|  }
  814|       |
  815|       |  // ret_exp2 is a uint64_t. Zero or underflow means that we're in subnormal
  816|       |  // space. max_exp2 (0x7FF for double precision, 0xFF for single precision) or
  817|       |  // above means that we're in Inf/NaN space.
  818|       |  //
  819|       |  // The if block is equivalent to (but has fewer branches than):
  820|       |  //   if ((ret_exp2 <= 0) || (ret_exp2 >= max_exp2)) { etc }
  821|       |  //
  822|       |  // For example, parsing "4.9406564584124654e-324" will take the if-true
  823|       |  // branch here, since ret_exp2 = -51.
  824|  1.27k|  static constexpr uint64_t max_exp2 =
  825|  1.27k|      (1 << FloatTraits<FloatType>::kTargetExponentBits) - 1;
  826|  1.27k|  if ((ret_exp2 - 1) >= (max_exp2 - 1)) {
  ------------------
  |  Branch (826:7): [True: 0, False: 1.27k]
  ------------------
  827|      0|    return false;
  828|      0|  }
  829|       |
  830|       |#ifndef ABSL_BIT_PACK_FLOATS
  831|       |  if (FloatTraits<FloatType>::kTargetBits == 64) {
  832|       |    *value = FloatTraits<FloatType>::Make(
  833|       |        (ret_man & 0x000FFFFFFFFFFFFFu) | 0x0010000000000000u,
  834|       |        static_cast<int>(ret_exp2) - 1023 - 52, negative);
  835|       |    return true;
  836|       |  } else if (FloatTraits<FloatType>::kTargetBits == 32) {
  837|       |    *value = FloatTraits<FloatType>::Make(
  838|       |        (static_cast<uint32_t>(ret_man) & 0x007FFFFFu) | 0x00800000u,
  839|       |        static_cast<int>(ret_exp2) - 127 - 23, negative);
  840|       |    return true;
  841|       |  }
  842|       |#else
  843|  1.27k|  if (FloatTraits<FloatType>::kTargetBits == 64) {
  ------------------
  |  Branch (843:7): [Folded - Ignored]
  ------------------
  844|      0|    uint64_t ret_bits = (ret_exp2 << 52) | (ret_man & 0x000FFFFFFFFFFFFFu);
  845|      0|    if (negative) {
  ------------------
  |  Branch (845:9): [True: 0, False: 0]
  ------------------
  846|      0|      ret_bits |= 0x8000000000000000u;
  847|      0|    }
  848|      0|    *value = absl::bit_cast<double>(ret_bits);
  849|      0|    return true;
  850|  1.27k|  } else if (FloatTraits<FloatType>::kTargetBits == 32) {
  ------------------
  |  Branch (850:14): [Folded - Ignored]
  ------------------
  851|  1.27k|    uint32_t ret_bits = (static_cast<uint32_t>(ret_exp2) << 23) |
  852|  1.27k|                        (static_cast<uint32_t>(ret_man) & 0x007FFFFFu);
  853|  1.27k|    if (negative) {
  ------------------
  |  Branch (853:9): [True: 756, False: 514]
  ------------------
  854|    756|      ret_bits |= 0x80000000u;
  855|    756|    }
  856|  1.27k|    *value = absl::bit_cast<float>(ret_bits);
  857|  1.27k|    return true;
  858|  1.27k|  }
  859|      0|#endif  // ABSL_BIT_PACK_FLOATS
  860|      0|  return false;
  861|  1.27k|}

_ZN4abslanENS_12chars_formatES0_:
   92|  10.4k|inline constexpr chars_format operator&(chars_format lhs, chars_format rhs) {
   93|  10.4k|  return static_cast<chars_format>(static_cast<int>(lhs) &
   94|  10.4k|                                   static_cast<int>(rhs));
   95|  10.4k|}

_ZN4absl16strings_internal10ParseFloatILi10EEENS0_11ParsedFloatEPKcS4_NS_12chars_formatE:
  356|  2.58k|                                         chars_format format_flags) {
  357|  2.58k|  strings_internal::ParsedFloat result;
  358|       |
  359|       |  // Exit early if we're given an empty range.
  360|  2.58k|  if (begin == end) return result;
  ------------------
  |  Branch (360:7): [True: 0, False: 2.58k]
  ------------------
  361|       |
  362|       |  // Handle the infinity and NaN cases.
  363|  2.58k|  if (ParseInfinityOrNan(begin, end, &result)) {
  ------------------
  |  Branch (363:7): [True: 0, False: 2.58k]
  ------------------
  364|      0|    return result;
  365|      0|  }
  366|       |
  367|  2.58k|  const char* const mantissa_begin = begin;
  368|  2.62k|  while (begin < end && *begin == '0') {
  ------------------
  |  Branch (368:10): [True: 2.58k, False: 40]
  |  Branch (368:25): [True: 40, False: 2.54k]
  ------------------
  369|     40|    ++begin;  // skip leading zeros
  370|     40|  }
  371|  2.58k|  uint64_t mantissa = 0;
  372|       |
  373|  2.58k|  int exponent_adjustment = 0;
  374|  2.58k|  bool mantissa_is_inexact = false;
  375|  2.58k|  int pre_decimal_digits = ConsumeDigits<base>(
  376|  2.58k|      begin, end, MantissaDigitsMax<base>(), &mantissa, &mantissa_is_inexact);
  377|  2.58k|  begin += pre_decimal_digits;
  378|  2.58k|  int digits_left;
  379|  2.58k|  if (pre_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (379:7): [True: 0, False: 2.58k]
  ------------------
  380|       |    // refuse to parse pathological inputs
  381|      0|    return result;
  382|  2.58k|  } else if (pre_decimal_digits > MantissaDigitsMax<base>()) {
  ------------------
  |  Branch (382:14): [True: 0, False: 2.58k]
  ------------------
  383|       |    // We dropped some non-fraction digits on the floor.  Adjust our exponent
  384|       |    // to compensate.
  385|      0|    exponent_adjustment =
  386|      0|        static_cast<int>(pre_decimal_digits - MantissaDigitsMax<base>());
  387|      0|    digits_left = 0;
  388|  2.58k|  } else {
  389|  2.58k|    digits_left =
  390|  2.58k|        static_cast<int>(MantissaDigitsMax<base>() - pre_decimal_digits);
  391|  2.58k|  }
  392|  2.58k|  if (begin < end && *begin == '.') {
  ------------------
  |  Branch (392:7): [True: 2.54k, False: 40]
  |  Branch (392:22): [True: 2.41k, False: 135]
  ------------------
  393|  2.41k|    ++begin;
  394|  2.41k|    if (mantissa == 0) {
  ------------------
  |  Branch (394:9): [True: 0, False: 2.41k]
  ------------------
  395|       |      // If we haven't seen any nonzero digits yet, keep skipping zeros.  We
  396|       |      // have to adjust the exponent to reflect the changed place value.
  397|      0|      const char* begin_zeros = begin;
  398|      0|      while (begin < end && *begin == '0') {
  ------------------
  |  Branch (398:14): [True: 0, False: 0]
  |  Branch (398:29): [True: 0, False: 0]
  ------------------
  399|      0|        ++begin;
  400|      0|      }
  401|      0|      int zeros_skipped = static_cast<int>(begin - begin_zeros);
  402|      0|      if (zeros_skipped >= DigitLimit<base>()) {
  ------------------
  |  Branch (402:11): [True: 0, False: 0]
  ------------------
  403|       |        // refuse to parse pathological inputs
  404|      0|        return result;
  405|      0|      }
  406|      0|      exponent_adjustment -= static_cast<int>(zeros_skipped);
  407|      0|    }
  408|  2.41k|    int post_decimal_digits = ConsumeDigits<base>(
  409|  2.41k|        begin, end, digits_left, &mantissa, &mantissa_is_inexact);
  410|  2.41k|    begin += post_decimal_digits;
  411|       |
  412|       |    // Since `mantissa` is an integer, each significant digit we read after
  413|       |    // the decimal point requires an adjustment to the exponent. "1.23e0" will
  414|       |    // be stored as `mantissa` == 123 and `exponent` == -2 (that is,
  415|       |    // "123e-2").
  416|  2.41k|    if (post_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (416:9): [True: 0, False: 2.41k]
  ------------------
  417|       |      // refuse to parse pathological inputs
  418|      0|      return result;
  419|  2.41k|    } else if (post_decimal_digits > digits_left) {
  ------------------
  |  Branch (419:16): [True: 0, False: 2.41k]
  ------------------
  420|      0|      exponent_adjustment -= digits_left;
  421|  2.41k|    } else {
  422|  2.41k|      exponent_adjustment -= post_decimal_digits;
  423|  2.41k|    }
  424|  2.41k|  }
  425|       |  // If we've found no mantissa whatsoever, this isn't a number.
  426|  2.58k|  if (mantissa_begin == begin) {
  ------------------
  |  Branch (426:7): [True: 0, False: 2.58k]
  ------------------
  427|      0|    return result;
  428|      0|  }
  429|       |  // A bare "." doesn't count as a mantissa either.
  430|  2.58k|  if (begin - mantissa_begin == 1 && *mantissa_begin == '.') {
  ------------------
  |  Branch (430:7): [True: 175, False: 2.41k]
  |  Branch (430:38): [True: 0, False: 175]
  ------------------
  431|      0|    return result;
  432|      0|  }
  433|       |
  434|  2.58k|  if (mantissa_is_inexact) {
  ------------------
  |  Branch (434:7): [True: 0, False: 2.58k]
  ------------------
  435|       |    // We dropped significant digits on the floor.  Handle this appropriately.
  436|      0|    if (base == 10) {
  ------------------
  |  Branch (436:9): [Folded - Ignored]
  ------------------
  437|       |      // If we truncated significant decimal digits, store the full range of the
  438|       |      // mantissa for future big integer math for exact rounding.
  439|      0|      result.subrange_begin = mantissa_begin;
  440|      0|      result.subrange_end = begin;
  441|      0|    } else if (base == 16) {
  ------------------
  |  Branch (441:16): [Folded - Ignored]
  ------------------
  442|       |      // If we truncated hex digits, reflect this fact by setting the low
  443|       |      // ("sticky") bit.  This allows for correct rounding in all cases.
  444|      0|      mantissa |= 1;
  445|      0|    }
  446|      0|  }
  447|  2.58k|  result.mantissa = mantissa;
  448|       |
  449|  2.58k|  const char* const exponent_begin = begin;
  450|  2.58k|  result.literal_exponent = 0;
  451|  2.58k|  bool found_exponent = false;
  452|  2.58k|  if (AllowExponent(format_flags) && begin < end &&
  ------------------
  |  Branch (452:7): [True: 2.58k, False: 0]
  |  Branch (452:38): [True: 2.54k, False: 40]
  ------------------
  453|  2.58k|      IsExponentCharacter<base>(*begin)) {
  ------------------
  |  Branch (453:7): [True: 2.54k, False: 0]
  ------------------
  454|  2.54k|    bool negative_exponent = false;
  455|  2.54k|    ++begin;
  456|  2.54k|    if (begin < end && *begin == '-') {
  ------------------
  |  Branch (456:9): [True: 2.54k, False: 0]
  |  Branch (456:24): [True: 0, False: 2.54k]
  ------------------
  457|      0|      negative_exponent = true;
  458|      0|      ++begin;
  459|  2.54k|    } else if (begin < end && *begin == '+') {
  ------------------
  |  Branch (459:16): [True: 2.54k, False: 0]
  |  Branch (459:31): [True: 2.54k, False: 0]
  ------------------
  460|  2.54k|      ++begin;
  461|  2.54k|    }
  462|  2.54k|    const char* const exponent_digits_begin = begin;
  463|       |    // Exponent is always expressed in decimal, even for hexadecimal floats.
  464|  2.54k|    begin += ConsumeDigits<10>(begin, end, kDecimalExponentDigitsMax,
  465|  2.54k|                               &result.literal_exponent, nullptr);
  466|  2.54k|    if (begin == exponent_digits_begin) {
  ------------------
  |  Branch (466:9): [True: 0, False: 2.54k]
  ------------------
  467|       |      // there were no digits where we expected an exponent.  We failed to read
  468|       |      // an exponent and should not consume the 'e' after all.  Rewind 'begin'.
  469|      0|      found_exponent = false;
  470|      0|      begin = exponent_begin;
  471|  2.54k|    } else {
  472|  2.54k|      found_exponent = true;
  473|  2.54k|      if (negative_exponent) {
  ------------------
  |  Branch (473:11): [True: 0, False: 2.54k]
  ------------------
  474|      0|        result.literal_exponent = -result.literal_exponent;
  475|      0|      }
  476|  2.54k|    }
  477|  2.54k|  }
  478|       |
  479|  2.58k|  if (!found_exponent && RequireExponent(format_flags)) {
  ------------------
  |  Branch (479:7): [True: 40, False: 2.54k]
  |  Branch (479:26): [True: 0, False: 40]
  ------------------
  480|       |    // Provided flags required an exponent, but none was found.  This results
  481|       |    // in a failure to scan.
  482|      0|    return result;
  483|      0|  }
  484|       |
  485|       |  // Success!
  486|  2.58k|  result.type = strings_internal::FloatType::kNumber;
  487|  2.58k|  if (result.mantissa > 0) {
  ------------------
  |  Branch (487:7): [True: 2.54k, False: 40]
  ------------------
  488|  2.54k|    result.exponent = result.literal_exponent +
  489|  2.54k|                      (DigitMagnitude<base>() * exponent_adjustment);
  490|  2.54k|  } else {
  491|     40|    result.exponent = 0;
  492|     40|  }
  493|  2.58k|  result.end = begin;
  494|  2.58k|  return result;
  495|  2.58k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_113AllowExponentENS_12chars_formatE:
  122|  2.58k|bool AllowExponent(chars_format flags) {
  123|  2.58k|  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
  124|  2.58k|  bool scientific =
  125|  2.58k|      (flags & chars_format::scientific) == chars_format::scientific;
  126|  2.58k|  return scientific || !fixed;
  ------------------
  |  Branch (126:10): [True: 2.58k, False: 0]
  |  Branch (126:24): [True: 0, False: 0]
  ------------------
  127|  2.58k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_115RequireExponentENS_12chars_formatE:
  130|     40|bool RequireExponent(chars_format flags) {
  131|     40|  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
  132|     40|  bool scientific =
  133|     40|      (flags & chars_format::scientific) == chars_format::scientific;
  134|     40|  return scientific && !fixed;
  ------------------
  |  Branch (134:10): [True: 40, False: 0]
  |  Branch (134:24): [True: 0, False: 40]
  ------------------
  135|     40|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_119IsExponentCharacterILi10EEEbc:
  201|  2.54k|bool IsExponentCharacter<10>(char ch) {
  202|  2.54k|  return ch == 'e' || ch == 'E';
  ------------------
  |  Branch (202:10): [True: 2.54k, False: 0]
  |  Branch (202:23): [True: 0, False: 0]
  ------------------
  203|  2.54k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_117MantissaDigitsMaxILi10EEEiv:
  211|  7.76k|constexpr int MantissaDigitsMax<10>() {
  212|  7.76k|  return kDecimalMantissaDigitsMax;
  213|  7.76k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_110DigitLimitILi10EEEiv:
  220|  5.00k|constexpr int DigitLimit<10>() {
  221|  5.00k|  return kDecimalDigitLimit;
  222|  5.00k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_114DigitMagnitudeILi10EEEiv:
  229|  2.54k|constexpr int DigitMagnitude<10>() {
  230|  2.54k|  return 1;
  231|  2.54k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_118ParseInfinityOrNanEPKcS2_PNS_16strings_internal11ParsedFloatE:
  298|  2.58k|                        strings_internal::ParsedFloat* out) {
  299|  2.58k|  if (end - begin < 3) {
  ------------------
  |  Branch (299:7): [True: 40, False: 2.54k]
  ------------------
  300|     40|    return false;
  301|     40|  }
  302|  2.54k|  switch (*begin) {
  303|      0|    case 'i':
  ------------------
  |  Branch (303:5): [True: 0, False: 2.54k]
  ------------------
  304|      0|    case 'I': {
  ------------------
  |  Branch (304:5): [True: 0, False: 2.54k]
  ------------------
  305|       |      // An infinity string consists of the characters "inf" or "infinity",
  306|       |      // case insensitive.
  307|      0|      if (strings_internal::memcasecmp(begin + 1, "nf", 2) != 0) {
  ------------------
  |  Branch (307:11): [True: 0, False: 0]
  ------------------
  308|      0|        return false;
  309|      0|      }
  310|      0|      out->type = strings_internal::FloatType::kInfinity;
  311|      0|      if (end - begin >= 8 &&
  ------------------
  |  Branch (311:11): [True: 0, False: 0]
  ------------------
  312|      0|          strings_internal::memcasecmp(begin + 3, "inity", 5) == 0) {
  ------------------
  |  Branch (312:11): [True: 0, False: 0]
  ------------------
  313|      0|        out->end = begin + 8;
  314|      0|      } else {
  315|      0|        out->end = begin + 3;
  316|      0|      }
  317|      0|      return true;
  318|      0|    }
  319|      0|    case 'n':
  ------------------
  |  Branch (319:5): [True: 0, False: 2.54k]
  ------------------
  320|      0|    case 'N': {
  ------------------
  |  Branch (320:5): [True: 0, False: 2.54k]
  ------------------
  321|       |      // A NaN consists of the characters "nan", case insensitive, optionally
  322|       |      // followed by a parenthesized sequence of zero or more alphanumeric
  323|       |      // characters and/or underscores.
  324|      0|      if (strings_internal::memcasecmp(begin + 1, "an", 2) != 0) {
  ------------------
  |  Branch (324:11): [True: 0, False: 0]
  ------------------
  325|      0|        return false;
  326|      0|      }
  327|      0|      out->type = strings_internal::FloatType::kNan;
  328|      0|      out->end = begin + 3;
  329|       |      // NaN is allowed to be followed by a parenthesized string, consisting of
  330|       |      // only the characters [a-zA-Z0-9_].  Match that if it's present.
  331|      0|      begin += 3;
  332|      0|      if (begin < end && *begin == '(') {
  ------------------
  |  Branch (332:11): [True: 0, False: 0]
  |  Branch (332:26): [True: 0, False: 0]
  ------------------
  333|      0|        const char* nan_begin = begin + 1;
  334|      0|        while (nan_begin < end && IsNanChar(*nan_begin)) {
  ------------------
  |  Branch (334:16): [True: 0, False: 0]
  |  Branch (334:35): [True: 0, False: 0]
  ------------------
  335|      0|          ++nan_begin;
  336|      0|        }
  337|      0|        if (nan_begin < end && *nan_begin == ')') {
  ------------------
  |  Branch (337:13): [True: 0, False: 0]
  |  Branch (337:32): [True: 0, False: 0]
  ------------------
  338|       |          // We found an extra NaN specifier range
  339|      0|          out->subrange_begin = begin + 1;
  340|      0|          out->subrange_end = nan_begin;
  341|      0|          out->end = nan_begin + 1;
  342|      0|        }
  343|      0|      }
  344|      0|      return true;
  345|      0|    }
  346|  2.54k|    default:
  ------------------
  |  Branch (346:5): [True: 2.54k, False: 0]
  ------------------
  347|  2.54k|      return false;
  348|  2.54k|  }
  349|  2.54k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_113ConsumeDigitsILi10EmEEiPKcS3_iPT0_Pb:
  250|  5.00k|                  bool* dropped_nonzero_digit) {
  251|  5.00k|  if (base == 10) {
  ------------------
  |  Branch (251:7): [Folded - Ignored]
  ------------------
  252|  5.00k|    assert(max_digits <= std::numeric_limits<T>::digits10);
  253|  5.00k|  } else if (base == 16) {
  ------------------
  |  Branch (253:14): [Folded - Ignored]
  ------------------
  254|      0|    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
  255|      0|  }
  256|  5.00k|  const char* const original_begin = begin;
  257|       |
  258|       |  // Skip leading zeros, but only if *out is zero.
  259|       |  // They don't cause an overflow so we don't have to count them for
  260|       |  // `max_digits`.
  261|  5.00k|  while (!*out && end != begin && *begin == '0') ++begin;
  ------------------
  |  Branch (261:10): [True: 2.58k, False: 2.41k]
  |  Branch (261:19): [True: 2.54k, False: 40]
  |  Branch (261:35): [True: 0, False: 2.54k]
  ------------------
  262|       |
  263|  5.00k|  T accumulator = *out;
  264|  5.00k|  const char* significant_digits_end =
  265|  5.00k|      (end - begin > max_digits) ? begin + max_digits : end;
  ------------------
  |  Branch (265:7): [True: 0, False: 5.00k]
  ------------------
  266|  19.2k|  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (266:10): [True: 19.2k, False: 40]
  |  Branch (266:44): [True: 14.2k, False: 4.96k]
  ------------------
  267|       |    // Do not guard against *out overflow; max_digits was chosen to avoid this.
  268|       |    // Do assert against it, to detect problems in debug builds.
  269|  14.2k|    auto digit = static_cast<T>(ToDigit<base>(*begin));
  270|  14.2k|    assert(accumulator * base >= accumulator);
  271|  14.2k|    accumulator *= base;
  272|  14.2k|    assert(accumulator + digit >= accumulator);
  273|  14.2k|    accumulator += digit;
  274|  14.2k|    ++begin;
  275|  14.2k|  }
  276|  5.00k|  bool dropped_nonzero = false;
  277|  5.00k|  while (begin < end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (277:10): [True: 4.96k, False: 40]
  |  Branch (277:25): [True: 0, False: 4.96k]
  ------------------
  278|      0|    dropped_nonzero = dropped_nonzero || (*begin != '0');
  ------------------
  |  Branch (278:23): [True: 0, False: 0]
  |  Branch (278:42): [True: 0, False: 0]
  ------------------
  279|      0|    ++begin;
  280|      0|  }
  281|  5.00k|  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
  ------------------
  |  Branch (281:7): [True: 0, False: 5.00k]
  |  Branch (281:26): [True: 0, False: 0]
  ------------------
  282|      0|    *dropped_nonzero_digit = true;
  283|      0|  }
  284|  5.00k|  *out = accumulator;
  285|  5.00k|  return static_cast<int>(begin - original_begin);
  286|  5.00k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_17IsDigitILi10EEEbc:
  183|  30.5k|bool IsDigit<10>(char ch) {
  184|  30.5k|  return ch >= '0' && ch <= '9';
  ------------------
  |  Branch (184:10): [True: 25.7k, False: 4.82k]
  |  Branch (184:23): [True: 20.6k, False: 5.09k]
  ------------------
  185|  30.5k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_17ToDigitILi10EEEjc:
  192|  20.6k|unsigned ToDigit<10>(char ch) {
  193|  20.6k|  return static_cast<unsigned>(ch - '0');
  194|  20.6k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_113ConsumeDigitsILi10EiEEiPKcS3_iPT0_Pb:
  250|  2.54k|                  bool* dropped_nonzero_digit) {
  251|  2.54k|  if (base == 10) {
  ------------------
  |  Branch (251:7): [Folded - Ignored]
  ------------------
  252|  2.54k|    assert(max_digits <= std::numeric_limits<T>::digits10);
  253|  2.54k|  } else if (base == 16) {
  ------------------
  |  Branch (253:14): [Folded - Ignored]
  ------------------
  254|      0|    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
  255|      0|  }
  256|  2.54k|  const char* const original_begin = begin;
  257|       |
  258|       |  // Skip leading zeros, but only if *out is zero.
  259|       |  // They don't cause an overflow so we don't have to count them for
  260|       |  // `max_digits`.
  261|  2.54k|  while (!*out && end != begin && *begin == '0') ++begin;
  ------------------
  |  Branch (261:10): [True: 2.54k, False: 0]
  |  Branch (261:19): [True: 2.54k, False: 0]
  |  Branch (261:35): [True: 0, False: 2.54k]
  ------------------
  262|       |
  263|  2.54k|  T accumulator = *out;
  264|  2.54k|  const char* significant_digits_end =
  265|  2.54k|      (end - begin > max_digits) ? begin + max_digits : end;
  ------------------
  |  Branch (265:7): [True: 0, False: 2.54k]
  ------------------
  266|  8.92k|  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (266:10): [True: 6.37k, False: 2.54k]
  |  Branch (266:44): [True: 6.37k, False: 0]
  ------------------
  267|       |    // Do not guard against *out overflow; max_digits was chosen to avoid this.
  268|       |    // Do assert against it, to detect problems in debug builds.
  269|  6.37k|    auto digit = static_cast<T>(ToDigit<base>(*begin));
  270|  6.37k|    assert(accumulator * base >= accumulator);
  271|  6.37k|    accumulator *= base;
  272|  6.37k|    assert(accumulator + digit >= accumulator);
  273|  6.37k|    accumulator += digit;
  274|  6.37k|    ++begin;
  275|  6.37k|  }
  276|  2.54k|  bool dropped_nonzero = false;
  277|  2.54k|  while (begin < end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (277:10): [True: 0, False: 2.54k]
  |  Branch (277:25): [True: 0, False: 0]
  ------------------
  278|      0|    dropped_nonzero = dropped_nonzero || (*begin != '0');
  ------------------
  |  Branch (278:23): [True: 0, False: 0]
  |  Branch (278:42): [True: 0, False: 0]
  ------------------
  279|      0|    ++begin;
  280|      0|  }
  281|  2.54k|  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
  ------------------
  |  Branch (281:7): [True: 0, False: 2.54k]
  |  Branch (281:26): [True: 0, False: 0]
  ------------------
  282|      0|    *dropped_nonzero_digit = true;
  283|      0|  }
  284|  2.54k|  *out = accumulator;
  285|  2.54k|  return static_cast<int>(begin - original_begin);
  286|  2.54k|}

_ZN4absl16strings_internal10memcasecmpEPKcS2_m:
   25|  7.22k|int memcasecmp(const char* s1, const char* s2, size_t len) {
   26|  7.22k|  const unsigned char* us1 = reinterpret_cast<const unsigned char*>(s1);
   27|  7.22k|  const unsigned char* us2 = reinterpret_cast<const unsigned char*>(s2);
   28|       |
   29|  8.51k|  for (size_t i = 0; i < len; i++) {
  ------------------
  |  Branch (29:22): [True: 7.22k, False: 1.29k]
  ------------------
   30|  7.22k|    unsigned char c1 = us1[i];
   31|  7.22k|    unsigned char c2 = us2[i];
   32|       |    // If bytes are the same, they will be the same when converted to lower.
   33|       |    // So we only need to convert if bytes are not equal.
   34|       |    // NOTE(b/308193381): We do not use `absl::ascii_tolower` here in order
   35|       |    // to avoid its lookup table and improve performance.
   36|  7.22k|    if (c1 != c2) {
  ------------------
  |  Branch (36:9): [True: 5.93k, False: 1.29k]
  ------------------
   37|  5.93k|      c1 = c1 >= 'A' && c1 <= 'Z' ? c1 - 'A' + 'a' : c1;
  ------------------
  |  Branch (37:12): [True: 0, False: 5.93k]
  |  Branch (37:25): [True: 0, False: 0]
  ------------------
   38|  5.93k|      c2 = c2 >= 'A' && c2 <= 'Z' ? c2 - 'A' + 'a' : c2;
  ------------------
  |  Branch (38:12): [True: 4.81k, False: 1.11k]
  |  Branch (38:25): [True: 0, False: 4.81k]
  ------------------
   39|  5.93k|      const int diff = int{c1} - int{c2};
   40|  5.93k|      if (diff != 0) return diff;
  ------------------
  |  Branch (40:11): [True: 5.93k, False: 0]
  ------------------
   41|  5.93k|    }
   42|  7.22k|  }
   43|  1.29k|  return 0;
   44|  7.22k|}

_ZN4absl16strings_internal28STLStringResizeUninitializedINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEvEEvPT_m:
   67|  2.58k|inline void STLStringResizeUninitialized(string_type* s, size_t new_size) {
   68|  2.58k|  ResizeUninitializedTraits<string_type>::Resize(s, new_size);
   69|  2.58k|}
_ZN4absl16strings_internal25ResizeUninitializedTraitsINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEvE6ResizeEPS8_m:
   47|  2.58k|  static void Resize(string_type* s, size_t new_size) {
   48|  2.58k|    s->__resize_default_init(new_size);
   49|  2.58k|  }
_ZN4absl16strings_internal25AppendUninitializedTraitsINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEvE6AppendEPS8_m:
   96|  1.29k|  static void Append(string_type* s, size_t n) {
   97|  1.29k|    s->__append_default_init(n);
   98|  1.29k|  }

_ZN4absl19str_format_internal13ConvertIntArgIiEEbT_NS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  403|  2.58k|bool ConvertIntArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
  404|  2.58k|  using U = typename MakeUnsigned<T>::type;
  405|  2.58k|  IntDigits as_digits;
  406|       |
  407|       |  // This odd casting is due to a bug in -Wswitch behavior in gcc49 which causes
  408|       |  // it to complain about a switch/case type mismatch, even though both are
  409|       |  // FormatConversionChar.  Likely this is because at this point
  410|       |  // FormatConversionChar is declared, but not defined.
  411|  2.58k|  switch (static_cast<uint8_t>(conv.conversion_char())) {
  412|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::c):
  ------------------
  |  Branch (412:5): [True: 0, False: 2.58k]
  ------------------
  413|      0|      return (std::is_same<T, wchar_t>::value ||
  ------------------
  |  Branch (413:15): [Folded - Ignored]
  ------------------
  414|      0|              (conv.length_mod() == LengthMod::l))
  ------------------
  |  Branch (414:15): [True: 0, False: 0]
  ------------------
  415|      0|                 ? ConvertWCharTImpl(static_cast<wchar_t>(v), conv, sink)
  416|      0|                 : ConvertCharImpl(static_cast<char>(v), conv, sink);
  417|       |
  418|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::o):
  ------------------
  |  Branch (418:5): [True: 0, False: 2.58k]
  ------------------
  419|      0|      as_digits.PrintAsOct(static_cast<U>(v));
  420|      0|      break;
  421|       |
  422|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::x):
  ------------------
  |  Branch (422:5): [True: 0, False: 2.58k]
  ------------------
  423|      0|      as_digits.PrintAsHexLower(static_cast<U>(v));
  424|      0|      break;
  425|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::X):
  ------------------
  |  Branch (425:5): [True: 0, False: 2.58k]
  ------------------
  426|      0|      as_digits.PrintAsHexUpper(static_cast<U>(v));
  427|      0|      break;
  428|       |
  429|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::u):
  ------------------
  |  Branch (429:5): [True: 0, False: 2.58k]
  ------------------
  430|      0|      as_digits.PrintAsDec(static_cast<U>(v));
  431|      0|      break;
  432|       |
  433|  2.58k|    case static_cast<uint8_t>(FormatConversionCharInternal::d):
  ------------------
  |  Branch (433:5): [True: 2.58k, False: 0]
  ------------------
  434|  2.58k|    case static_cast<uint8_t>(FormatConversionCharInternal::i):
  ------------------
  |  Branch (434:5): [True: 0, False: 2.58k]
  ------------------
  435|  2.58k|    case static_cast<uint8_t>(FormatConversionCharInternal::v):
  ------------------
  |  Branch (435:5): [True: 0, False: 2.58k]
  ------------------
  436|  2.58k|      as_digits.PrintAsDec(v);
  437|  2.58k|      break;
  438|       |
  439|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::a):
  ------------------
  |  Branch (439:5): [True: 0, False: 2.58k]
  ------------------
  440|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::e):
  ------------------
  |  Branch (440:5): [True: 0, False: 2.58k]
  ------------------
  441|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::f):
  ------------------
  |  Branch (441:5): [True: 0, False: 2.58k]
  ------------------
  442|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::g):
  ------------------
  |  Branch (442:5): [True: 0, False: 2.58k]
  ------------------
  443|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::A):
  ------------------
  |  Branch (443:5): [True: 0, False: 2.58k]
  ------------------
  444|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::E):
  ------------------
  |  Branch (444:5): [True: 0, False: 2.58k]
  ------------------
  445|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::F):
  ------------------
  |  Branch (445:5): [True: 0, False: 2.58k]
  ------------------
  446|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::G):
  ------------------
  |  Branch (446:5): [True: 0, False: 2.58k]
  ------------------
  447|      0|      return ConvertFloatImpl(static_cast<double>(v), conv, sink);
  448|       |
  449|      0|    default:
  ------------------
  |  Branch (449:5): [True: 0, False: 2.58k]
  ------------------
  450|      0|      ABSL_ASSUME(false);
  ------------------
  |  |  259|      0|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  451|  2.58k|  }
  452|       |
  453|  2.58k|  if (conv.is_basic()) {
  ------------------
  |  Branch (453:7): [True: 2.58k, False: 0]
  ------------------
  454|  2.58k|    sink->Append(as_digits.with_neg_and_zero());
  455|  2.58k|    return true;
  456|  2.58k|  }
  457|      0|  return ConvertIntImplInnerSlow(as_digits, conv, sink);
  458|  2.58k|}
_ZN4absl19str_format_internal17FormatConvertImplEfNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  577|  1.29k|                                        FormatSinkImpl *sink) {
  578|  1.29k|  return {ConvertFloatArg(v, conv, sink)};
  579|  1.29k|}
_ZN4absl19str_format_internal17FormatConvertImplEdNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  582|  1.29k|                                        FormatSinkImpl *sink) {
  583|  1.29k|  return {ConvertFloatArg(v, conv, sink)};
  584|  1.29k|}
_ZN4absl19str_format_internal17FormatConvertImplEiNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  625|  2.58k|                                        FormatSinkImpl *sink) {
  626|  2.58k|  return {ConvertIntArg(v, conv, sink)};
  627|  2.58k|}
arg.cc:_ZNK4absl19str_format_internal12_GLOBAL__N_19IntDigits17with_neg_and_zeroEv:
  176|  2.58k|  string_view with_neg_and_zero() const { return {start_, size_}; }
arg.cc:_ZN4absl19str_format_internal12_GLOBAL__N_19IntDigits10PrintAsDecIiEEvT_:
   99|  2.58k|  void PrintAsDec(T v) {
  100|  2.58k|    static_assert(std::is_integral<T>::value, "");
  101|  2.58k|    start_ = storage_;
  102|  2.58k|    size_ = static_cast<size_t>(numbers_internal::FastIntToBuffer(v, storage_) -
  103|  2.58k|                                storage_);
  104|  2.58k|  }
arg.cc:_ZN4absl19str_format_internal12_GLOBAL__N_115ConvertFloatArgIfEEbT_NS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  295|  1.29k|bool ConvertFloatArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
  296|  1.29k|  if (conv.conversion_char() == FormatConversionCharInternal::v) {
  ------------------
  |  Branch (296:7): [True: 0, False: 1.29k]
  ------------------
  297|      0|    conv.set_conversion_char(FormatConversionCharInternal::g);
  298|      0|  }
  299|       |
  300|  1.29k|  return FormatConversionCharIsFloat(conv.conversion_char()) &&
  ------------------
  |  Branch (300:10): [True: 1.29k, False: 0]
  ------------------
  301|  1.29k|         ConvertFloatImpl(v, conv, sink);
  ------------------
  |  Branch (301:10): [True: 1.29k, False: 0]
  ------------------
  302|  1.29k|}
arg.cc:_ZN4absl19str_format_internal12_GLOBAL__N_115ConvertFloatArgIdEEbT_NS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  295|  1.29k|bool ConvertFloatArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
  296|  1.29k|  if (conv.conversion_char() == FormatConversionCharInternal::v) {
  ------------------
  |  Branch (296:7): [True: 0, False: 1.29k]
  ------------------
  297|      0|    conv.set_conversion_char(FormatConversionCharInternal::g);
  298|      0|  }
  299|       |
  300|  1.29k|  return FormatConversionCharIsFloat(conv.conversion_char()) &&
  ------------------
  |  Branch (300:10): [True: 1.29k, False: 0]
  ------------------
  301|  1.29k|         ConvertFloatImpl(v, conv, sink);
  ------------------
  |  Branch (301:10): [True: 1.29k, False: 0]
  ------------------
  302|  1.29k|}

_ZN4absl19str_format_internal13FormatArgImplC2IfEERKT_:
  505|  1.29k|  explicit FormatArgImpl(const T& value) {
  506|  1.29k|    using D = typename DecayType<T>::type;
  507|  1.29k|    static_assert(
  508|  1.29k|        std::is_same<D, const T&>::value || storage_policy<D>::value == ByValue,
  509|  1.29k|        "Decayed types must be stored by value");
  510|  1.29k|    Init(static_cast<D>(value));
  511|  1.29k|  }
_ZN4absl19str_format_internal13FormatArgImpl4InitIfEEvRKT_:
  558|  1.29k|  void Init(const T& value) {
  559|  1.29k|    data_ = Manager<T>::SetValue(value);
  560|  1.29k|    dispatcher_ = &Dispatch<T>;
  561|  1.29k|  }
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIfLNS1_13StoragePolicyE2EE8SetValueERKf:
  544|  1.29k|    static Data SetValue(const T& value) {
  545|  1.29k|      Data data;
  546|  1.29k|      memcpy(data.buf, &value, sizeof(value));
  547|  1.29k|      return data;
  548|  1.29k|    }
_ZN4absl19str_format_internal13FormatArgImpl8DispatchIfEEbNS1_4DataENS0_24FormatConversionSpecImplEPv:
  599|  1.29k|  static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) {
  600|       |    // A `none` conv indicates that we want the `int` conversion.
  601|  1.29k|    if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
  ------------------
  |  |  178|  1.29k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 1.29k]
  |  |  |  Branch (178:49): [Folded - Ignored]
  |  |  |  Branch (178:58): [True: 0, False: 1.29k]
  |  |  ------------------
  ------------------
  602|  1.29k|                           FormatConversionCharInternal::kNone)) {
  603|      0|      return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
  604|      0|                      std::is_enum<T>());
  605|      0|    }
  606|  1.29k|    if (ABSL_PREDICT_FALSE(!Contains(ArgumentToConv<T>(),
  ------------------
  |  |  178|  1.29k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 1.29k]
  |  |  |  Branch (178:49): [Folded - Ignored]
  |  |  |  Branch (178:58): [True: 0, False: 1.29k]
  |  |  ------------------
  ------------------
  607|  1.29k|                                     spec.conversion_char()))) {
  608|      0|      return false;
  609|      0|    }
  610|  1.29k|    return str_format_internal::FormatConvertImpl(
  611|  1.29k|               Manager<T>::Value(arg), spec,
  612|  1.29k|               static_cast<FormatSinkImpl*>(out))
  613|  1.29k|        .value;
  614|  1.29k|  }
_ZN4absl19str_format_internal14ArgumentToConvIfEENS_23FormatConversionCharSetEv:
  430|  1.29k|constexpr FormatConversionCharSet ArgumentToConv() {
  431|  1.29k|  using ConvResult = decltype(str_format_internal::FormatConvertImpl(
  432|  1.29k|      std::declval<const Arg&>(),
  433|  1.29k|      std::declval<const FormatConversionSpecImpl&>(),
  434|  1.29k|      std::declval<FormatSinkImpl*>()));
  435|  1.29k|  return absl::str_format_internal::ExtractCharSet(ConvResult{});
  436|  1.29k|}
_ZN4absl19str_format_internal14ExtractCharSetILNS_23FormatConversionCharSetE654848EEES2_NS0_16ArgConvertResultIXT_EEE:
  211|  2.58k|constexpr FormatConversionCharSet ExtractCharSet(ArgConvertResult<C>) {
  212|  2.58k|  return C;
  213|  2.58k|}
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIfLNS1_13StoragePolicyE2EE5ValueENS1_4DataE:
  550|  1.29k|    static T Value(Data arg) {
  551|  1.29k|      T value;
  552|  1.29k|      memcpy(&value, arg.buf, sizeof(T));
  553|  1.29k|      return value;
  554|  1.29k|    }
_ZN4absl19str_format_internal13FormatArgImplC2IdEERKT_:
  505|  1.29k|  explicit FormatArgImpl(const T& value) {
  506|  1.29k|    using D = typename DecayType<T>::type;
  507|  1.29k|    static_assert(
  508|  1.29k|        std::is_same<D, const T&>::value || storage_policy<D>::value == ByValue,
  509|  1.29k|        "Decayed types must be stored by value");
  510|  1.29k|    Init(static_cast<D>(value));
  511|  1.29k|  }
_ZN4absl19str_format_internal13FormatArgImpl4InitIdEEvRKT_:
  558|  1.29k|  void Init(const T& value) {
  559|  1.29k|    data_ = Manager<T>::SetValue(value);
  560|  1.29k|    dispatcher_ = &Dispatch<T>;
  561|  1.29k|  }
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIdLNS1_13StoragePolicyE2EE8SetValueERKd:
  544|  1.29k|    static Data SetValue(const T& value) {
  545|  1.29k|      Data data;
  546|  1.29k|      memcpy(data.buf, &value, sizeof(value));
  547|  1.29k|      return data;
  548|  1.29k|    }
_ZN4absl19str_format_internal13FormatArgImpl8DispatchIdEEbNS1_4DataENS0_24FormatConversionSpecImplEPv:
  599|  1.29k|  static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) {
  600|       |    // A `none` conv indicates that we want the `int` conversion.
  601|  1.29k|    if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
  ------------------
  |  |  178|  1.29k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 1.29k]
  |  |  |  Branch (178:49): [Folded - Ignored]
  |  |  |  Branch (178:58): [True: 0, False: 1.29k]
  |  |  ------------------
  ------------------
  602|  1.29k|                           FormatConversionCharInternal::kNone)) {
  603|      0|      return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
  604|      0|                      std::is_enum<T>());
  605|      0|    }
  606|  1.29k|    if (ABSL_PREDICT_FALSE(!Contains(ArgumentToConv<T>(),
  ------------------
  |  |  178|  1.29k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 1.29k]
  |  |  |  Branch (178:49): [Folded - Ignored]
  |  |  |  Branch (178:58): [True: 0, False: 1.29k]
  |  |  ------------------
  ------------------
  607|  1.29k|                                     spec.conversion_char()))) {
  608|      0|      return false;
  609|      0|    }
  610|  1.29k|    return str_format_internal::FormatConvertImpl(
  611|  1.29k|               Manager<T>::Value(arg), spec,
  612|  1.29k|               static_cast<FormatSinkImpl*>(out))
  613|  1.29k|        .value;
  614|  1.29k|  }
_ZN4absl19str_format_internal14ArgumentToConvIdEENS_23FormatConversionCharSetEv:
  430|  1.29k|constexpr FormatConversionCharSet ArgumentToConv() {
  431|  1.29k|  using ConvResult = decltype(str_format_internal::FormatConvertImpl(
  432|  1.29k|      std::declval<const Arg&>(),
  433|  1.29k|      std::declval<const FormatConversionSpecImpl&>(),
  434|  1.29k|      std::declval<FormatSinkImpl*>()));
  435|  1.29k|  return absl::str_format_internal::ExtractCharSet(ConvResult{});
  436|  1.29k|}
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIdLNS1_13StoragePolicyE2EE5ValueENS1_4DataE:
  550|  1.29k|    static T Value(Data arg) {
  551|  1.29k|      T value;
  552|  1.29k|      memcpy(&value, arg.buf, sizeof(T));
  553|  1.29k|      return value;
  554|  1.29k|    }
_ZN4absl19str_format_internal13FormatArgImplC2IiEERKT_:
  505|  1.29k|  explicit FormatArgImpl(const T& value) {
  506|  1.29k|    using D = typename DecayType<T>::type;
  507|  1.29k|    static_assert(
  508|  1.29k|        std::is_same<D, const T&>::value || storage_policy<D>::value == ByValue,
  509|  1.29k|        "Decayed types must be stored by value");
  510|  1.29k|    Init(static_cast<D>(value));
  511|  1.29k|  }
_ZN4absl19str_format_internal13FormatArgImpl4InitIiEEvRKT_:
  558|  1.29k|  void Init(const T& value) {
  559|  1.29k|    data_ = Manager<T>::SetValue(value);
  560|  1.29k|    dispatcher_ = &Dispatch<T>;
  561|  1.29k|  }
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIiLNS1_13StoragePolicyE2EE8SetValueERKi:
  544|  1.29k|    static Data SetValue(const T& value) {
  545|  1.29k|      Data data;
  546|  1.29k|      memcpy(data.buf, &value, sizeof(value));
  547|  1.29k|      return data;
  548|  1.29k|    }
_ZN4absl19str_format_internal13FormatArgImpl8DispatchIiEEbNS1_4DataENS0_24FormatConversionSpecImplEPv:
  599|  1.29k|  static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) {
  600|       |    // A `none` conv indicates that we want the `int` conversion.
  601|  1.29k|    if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
  ------------------
  |  |  178|  1.29k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 1.29k]
  |  |  |  Branch (178:49): [Folded - Ignored]
  |  |  |  Branch (178:58): [True: 0, False: 1.29k]
  |  |  ------------------
  ------------------
  602|  1.29k|                           FormatConversionCharInternal::kNone)) {
  603|      0|      return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
  604|      0|                      std::is_enum<T>());
  605|      0|    }
  606|  1.29k|    if (ABSL_PREDICT_FALSE(!Contains(ArgumentToConv<T>(),
  ------------------
  |  |  178|  1.29k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 1.29k]
  |  |  |  Branch (178:49): [Folded - Ignored]
  |  |  |  Branch (178:58): [True: 0, False: 1.29k]
  |  |  ------------------
  ------------------
  607|  1.29k|                                     spec.conversion_char()))) {
  608|      0|      return false;
  609|      0|    }
  610|  1.29k|    return str_format_internal::FormatConvertImpl(
  611|  1.29k|               Manager<T>::Value(arg), spec,
  612|  1.29k|               static_cast<FormatSinkImpl*>(out))
  613|  1.29k|        .value;
  614|  1.29k|  }
_ZN4absl19str_format_internal14ArgumentToConvIiEENS_23FormatConversionCharSetEv:
  430|  1.29k|constexpr FormatConversionCharSet ArgumentToConv() {
  431|  1.29k|  using ConvResult = decltype(str_format_internal::FormatConvertImpl(
  432|  1.29k|      std::declval<const Arg&>(),
  433|  1.29k|      std::declval<const FormatConversionSpecImpl&>(),
  434|  1.29k|      std::declval<FormatSinkImpl*>()));
  435|  1.29k|  return absl::str_format_internal::ExtractCharSet(ConvResult{});
  436|  1.29k|}
_ZN4absl19str_format_internal14ExtractCharSetILNS_23FormatConversionCharSetE655355EEES2_NS0_16ArgConvertResultIXT_EEE:
  211|  2.58k|constexpr FormatConversionCharSet ExtractCharSet(ArgConvertResult<C>) {
  212|  2.58k|  return C;
  213|  2.58k|}
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIiLNS1_13StoragePolicyE2EE5ValueENS1_4DataE:
  550|  1.29k|    static T Value(Data arg) {
  551|  1.29k|      T value;
  552|  1.29k|      memcpy(&value, arg.buf, sizeof(T));
  553|  1.29k|      return value;
  554|  1.29k|    }
_ZN4absl19str_format_internal13FormatArgImplC2IbEERKT_:
  505|  1.29k|  explicit FormatArgImpl(const T& value) {
  506|  1.29k|    using D = typename DecayType<T>::type;
  507|  1.29k|    static_assert(
  508|  1.29k|        std::is_same<D, const T&>::value || storage_policy<D>::value == ByValue,
  509|  1.29k|        "Decayed types must be stored by value");
  510|  1.29k|    Init(static_cast<D>(value));
  511|  1.29k|  }
_ZN4absl19str_format_internal13FormatArgImpl4InitIbEEvRKT_:
  558|  1.29k|  void Init(const T& value) {
  559|  1.29k|    data_ = Manager<T>::SetValue(value);
  560|  1.29k|    dispatcher_ = &Dispatch<T>;
  561|  1.29k|  }
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIbLNS1_13StoragePolicyE2EE8SetValueERKb:
  544|  1.29k|    static Data SetValue(const T& value) {
  545|  1.29k|      Data data;
  546|  1.29k|      memcpy(data.buf, &value, sizeof(value));
  547|  1.29k|      return data;
  548|  1.29k|    }
_ZN4absl19str_format_internal13FormatArgImpl8DispatchIbEEbNS1_4DataENS0_24FormatConversionSpecImplEPv:
  599|  1.29k|  static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) {
  600|       |    // A `none` conv indicates that we want the `int` conversion.
  601|  1.29k|    if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
  ------------------
  |  |  178|  1.29k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 1.29k]
  |  |  |  Branch (178:49): [Folded - Ignored]
  |  |  |  Branch (178:58): [True: 0, False: 1.29k]
  |  |  ------------------
  ------------------
  602|  1.29k|                           FormatConversionCharInternal::kNone)) {
  603|      0|      return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
  604|      0|                      std::is_enum<T>());
  605|      0|    }
  606|  1.29k|    if (ABSL_PREDICT_FALSE(!Contains(ArgumentToConv<T>(),
  ------------------
  |  |  178|  1.29k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 1.29k]
  |  |  |  Branch (178:49): [Folded - Ignored]
  |  |  |  Branch (178:58): [True: 0, False: 1.29k]
  |  |  ------------------
  ------------------
  607|  1.29k|                                     spec.conversion_char()))) {
  608|      0|      return false;
  609|      0|    }
  610|  1.29k|    return str_format_internal::FormatConvertImpl(
  611|  1.29k|               Manager<T>::Value(arg), spec,
  612|  1.29k|               static_cast<FormatSinkImpl*>(out))
  613|  1.29k|        .value;
  614|  1.29k|  }
_ZN4absl19str_format_internal14ArgumentToConvIbEENS_23FormatConversionCharSetEv:
  430|  1.29k|constexpr FormatConversionCharSet ArgumentToConv() {
  431|  1.29k|  using ConvResult = decltype(str_format_internal::FormatConvertImpl(
  432|  1.29k|      std::declval<const Arg&>(),
  433|  1.29k|      std::declval<const FormatConversionSpecImpl&>(),
  434|  1.29k|      std::declval<FormatSinkImpl*>()));
  435|  1.29k|  return absl::str_format_internal::ExtractCharSet(ConvResult{});
  436|  1.29k|}
_ZN4absl19str_format_internal17FormatConvertImplIbLi0EEENS0_16ArgConvertResultILNS_23FormatConversionCharSetE655355EEET_NS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  355|  1.29k|                                        FormatSinkImpl* sink) {
  356|  1.29k|  if (conv.conversion_char() == FormatConversionCharInternal::v) {
  ------------------
  |  Branch (356:7): [True: 0, False: 1.29k]
  ------------------
  357|      0|    return {ConvertBoolArg(v, sink)};
  358|      0|  }
  359|       |
  360|  1.29k|  return FormatConvertImpl(static_cast<int>(v), conv, sink);
  361|  1.29k|}
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIbLNS1_13StoragePolicyE2EE5ValueENS1_4DataE:
  550|  1.29k|    static T Value(Data arg) {
  551|  1.29k|      T value;
  552|  1.29k|      memcpy(&value, arg.buf, sizeof(T));
  553|  1.29k|      return value;
  554|  1.29k|    }
_ZN4absl19str_format_internal19FormatArgImplFriend7ConvertINS0_13FormatArgImplEEEbT_NS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  419|  5.17k|                      FormatSinkImpl* out) {
  420|  5.17k|    return arg.dispatcher_(arg.data_, conv, out);
  421|  5.17k|  }

_ZN4absl19str_format_internal13FormatUntypedENS0_17FormatRawSinkImplENS0_21UntypedFormatSpecImplENS_4SpanIKNS0_13FormatArgImplEEE:
  214|  5.17k|                   absl::Span<const FormatArgImpl> args) {
  215|  5.17k|  FormatSinkImpl sink(raw_sink);
  216|  5.17k|  using Converter = DefaultConverter;
  217|  5.17k|  return ConvertAll(format, args, Converter(&sink));
  218|  5.17k|}
_ZN4absl19str_format_internal10FormatPackENS0_21UntypedFormatSpecImplENS_4SpanIKNS0_13FormatArgImplEEE:
  235|  5.17k|                       absl::Span<const FormatArgImpl> args) {
  236|  5.17k|  std::string out;
  237|  5.17k|  if (ABSL_PREDICT_FALSE(!FormatUntyped(&out, format, args))) {
  ------------------
  |  |  178|  5.17k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 5.17k]
  |  |  |  Branch (178:49): [Folded - Ignored]
  |  |  |  Branch (178:58): [True: 0, False: 5.17k]
  |  |  ------------------
  ------------------
  238|      0|    out.clear();
  239|      0|  }
  240|  5.17k|  return out;
  241|  5.17k|}
bind.cc:_ZN4absl19str_format_internal12_GLOBAL__N_110ArgContextC2ENS_4SpanIKNS0_13FormatArgImplEEE:
   55|  5.17k|  explicit ArgContext(absl::Span<const FormatArgImpl> pack) : pack_(pack) {}
bind.cc:_ZN4absl19str_format_internal12_GLOBAL__N_110ArgContext4BindEPKNS0_17UnboundConversionEPNS0_15BoundConversionE:
   70|  5.17k|                             BoundConversion* bound) {
   71|  5.17k|  const FormatArgImpl* arg = nullptr;
   72|  5.17k|  int arg_position = unbound->arg_position;
   73|  5.17k|  if (static_cast<size_t>(arg_position - 1) >= pack_.size()) return false;
  ------------------
  |  Branch (73:7): [True: 0, False: 5.17k]
  ------------------
   74|  5.17k|  arg = &pack_[static_cast<size_t>(arg_position - 1)];  // 1-based
   75|       |
   76|  5.17k|  if (unbound->flags != Flags::kBasic) {
  ------------------
  |  Branch (76:7): [True: 0, False: 5.17k]
  ------------------
   77|      0|    int width = unbound->width.value();
   78|      0|    bool force_left = false;
   79|      0|    if (unbound->width.is_from_arg()) {
  ------------------
  |  Branch (79:9): [True: 0, False: 0]
  ------------------
   80|      0|      if (!BindFromPosition(unbound->width.get_from_arg(), &width, pack_))
  ------------------
  |  Branch (80:11): [True: 0, False: 0]
  ------------------
   81|      0|        return false;
   82|      0|      if (width < 0) {
  ------------------
  |  Branch (82:11): [True: 0, False: 0]
  ------------------
   83|       |        // "A negative field width is taken as a '-' flag followed by a
   84|       |        // positive field width."
   85|      0|        force_left = true;
   86|       |        // Make sure we don't overflow the width when negating it.
   87|      0|        width = -std::max(width, -std::numeric_limits<int>::max());
   88|      0|      }
   89|      0|    }
   90|       |
   91|      0|    int precision = unbound->precision.value();
   92|      0|    if (unbound->precision.is_from_arg()) {
  ------------------
  |  Branch (92:9): [True: 0, False: 0]
  ------------------
   93|      0|      if (!BindFromPosition(unbound->precision.get_from_arg(), &precision,
  ------------------
  |  Branch (93:11): [True: 0, False: 0]
  ------------------
   94|      0|                            pack_))
   95|      0|        return false;
   96|      0|    }
   97|       |
   98|      0|    FormatConversionSpecImplFriend::SetWidth(width, bound);
   99|      0|    FormatConversionSpecImplFriend::SetPrecision(precision, bound);
  100|       |
  101|      0|    if (force_left) {
  ------------------
  |  Branch (101:9): [True: 0, False: 0]
  ------------------
  102|      0|      FormatConversionSpecImplFriend::SetFlags(unbound->flags | Flags::kLeft,
  103|      0|                                               bound);
  104|      0|    } else {
  105|      0|      FormatConversionSpecImplFriend::SetFlags(unbound->flags, bound);
  106|      0|    }
  107|       |
  108|      0|    FormatConversionSpecImplFriend::SetLengthMod(unbound->length_mod, bound);
  109|  5.17k|  } else {
  110|  5.17k|    FormatConversionSpecImplFriend::SetFlags(unbound->flags, bound);
  111|  5.17k|    FormatConversionSpecImplFriend::SetWidth(-1, bound);
  112|  5.17k|    FormatConversionSpecImplFriend::SetPrecision(-1, bound);
  113|  5.17k|  }
  114|  5.17k|  FormatConversionSpecImplFriend::SetConversionChar(unbound->conv, bound);
  115|  5.17k|  bound->set_arg(arg);
  116|  5.17k|  return true;
  117|  5.17k|}
bind.cc:_ZN4absl19str_format_internal12_GLOBAL__N_116DefaultConverterC2EPNS0_14FormatSinkImplE:
  154|  5.17k|  explicit DefaultConverter(FormatSinkImpl* sink) : sink_(sink) {}
bind.cc:_ZN4absl19str_format_internal12_GLOBAL__N_110ConvertAllINS1_16DefaultConverterEEEbNS0_21UntypedFormatSpecImplENS_4SpanIKNS0_13FormatArgImplEEET_:
  142|  5.17k|                absl::Span<const FormatArgImpl> args, Converter converter) {
  143|  5.17k|  if (format.has_parsed_conversion()) {
  ------------------
  |  Branch (143:7): [True: 0, False: 5.17k]
  ------------------
  144|      0|    return format.parsed_conversion()->ProcessFormat(
  145|      0|        ConverterConsumer<Converter>(converter, args));
  146|  5.17k|  } else {
  147|  5.17k|    return ParseFormatString(format.str(),
  148|  5.17k|                             ConverterConsumer<Converter>(converter, args));
  149|  5.17k|  }
  150|  5.17k|}
bind.cc:_ZN4absl19str_format_internal12_GLOBAL__N_117ConverterConsumerINS1_16DefaultConverterEE10ConvertOneERKNS0_17UnboundConversionENS_11string_viewE:
  129|  5.17k|  bool ConvertOne(const UnboundConversion& conv, string_view conv_string) {
  130|  5.17k|    BoundConversion bound;
  131|  5.17k|    if (!arg_context_.Bind(&conv, &bound)) return false;
  ------------------
  |  Branch (131:9): [True: 0, False: 5.17k]
  ------------------
  132|  5.17k|    return converter_.ConvertOne(bound, conv_string);
  133|  5.17k|  }
bind.cc:_ZNK4absl19str_format_internal12_GLOBAL__N_116DefaultConverter10ConvertOneERKNS0_15BoundConversionENS_11string_viewE:
  158|  5.17k|  bool ConvertOne(const BoundConversion& bound, string_view /*conv*/) const {
  159|  5.17k|    return FormatArgImplFriend::Convert(*bound.arg(), bound, sink_);
  160|  5.17k|  }
bind.cc:_ZN4absl19str_format_internal12_GLOBAL__N_117ConverterConsumerINS1_16DefaultConverterEE6AppendENS_11string_viewE:
  125|  5.17k|  bool Append(string_view s) {
  126|  5.17k|    converter_.Append(s);
  127|  5.17k|    return true;
  128|  5.17k|  }
bind.cc:_ZNK4absl19str_format_internal12_GLOBAL__N_116DefaultConverter6AppendENS_11string_viewE:
  156|  5.17k|  void Append(string_view s) const { sink_->Append(s); }
bind.cc:_ZN4absl19str_format_internal12_GLOBAL__N_117ConverterConsumerINS1_16DefaultConverterEEC2ES3_NS_4SpanIKNS0_13FormatArgImplEEE:
  123|  5.17k|      : converter_(converter), arg_context_(pack) {}

_ZN4absl19str_format_internal21UntypedFormatSpecImpl7ExtractINS0_18FormatSpecTemplateIJLNS_23FormatConversionCharSetE654848EEEEEERKS1_RKT_:
   73|  2.58k|  static const UntypedFormatSpecImpl& Extract(const T& s) {
   74|  2.58k|    return s.spec_;
   75|  2.58k|  }
_ZN4absl19str_format_internal18FormatSpecTemplateIJLNS_23FormatConversionCharSetE654848EEEC2EUa9enable_ifIXclL_ZNS0_15ValidFormatImplIJLS2_654848EEEEbNS_11string_viewEEfL0p_EEEPKc:
  159|  2.58k|      : Base(s) {}
_ZN4absl19str_format_internal21UntypedFormatSpecImplC2ENS_11string_viewE:
   56|  5.17k|      : data_(s.data()), size_(s.size()) {}
_ZN4absl19str_format_internal21UntypedFormatSpecImpl7ExtractINS0_18FormatSpecTemplateIJLNS_23FormatConversionCharSetE655355EEEEEERKS1_RKT_:
   73|  2.58k|  static const UntypedFormatSpecImpl& Extract(const T& s) {
   74|  2.58k|    return s.spec_;
   75|  2.58k|  }
_ZN4absl19str_format_internal18FormatSpecTemplateIJLNS_23FormatConversionCharSetE655355EEEC2EUa9enable_ifIXclL_ZNS0_15ValidFormatImplIJLS2_655355EEEEbNS_11string_viewEEfL0p_EEEPKc:
  159|  2.58k|      : Base(s) {}
_ZNK4absl19str_format_internal15BoundConversion3argEv:
   43|  5.17k|  const FormatArgImpl* arg() const { return arg_; }
_ZN4absl19str_format_internal15BoundConversion7set_argEPKNS0_13FormatArgImplE:
   44|  5.17k|  void set_arg(const FormatArgImpl* a) { arg_ = a; }
_ZNK4absl19str_format_internal21UntypedFormatSpecImpl21has_parsed_conversionEv:
   61|  5.17k|  bool has_parsed_conversion() const { return size_ == ~size_t{}; }
_ZNK4absl19str_format_internal21UntypedFormatSpecImpl3strEv:
   63|  5.17k|  string_view str() const {
   64|  5.17k|    assert(!has_parsed_conversion());
   65|  5.17k|    return string_view(static_cast<const char*>(data_), size_);
   66|  5.17k|  }

_ZN4absl19str_format_internal17UnboundConversionC2Ev:
   36|  5.17k|  UnboundConversion() {}  // NOLINT
_ZNK4absl19str_format_internal7ConvTag7is_convEv:
   94|  5.17k|  constexpr bool is_conv() const { return (tag_ & 0x80) == 0; }
_ZNK4absl19str_format_internal7ConvTag7as_convEv:
   98|  5.17k|  constexpr FormatConversionChar as_conv() const {
   99|  5.17k|    assert(is_conv());
  100|  5.17k|    assert(!is_length());
  101|  5.17k|    assert(!is_flags());
  102|  5.17k|    return static_cast<FormatConversionChar>(tag_);
  103|  5.17k|  }
_ZN4absl19str_format_internal13GetTagForCharEc:
  169|  5.17k|constexpr ConvTag GetTagForChar(char c) {
  170|  5.17k|  return ConvTagHolder::value[static_cast<unsigned char>(c)];
  171|  5.17k|}

_ZN4absl19str_format_internal13FlagsToStringENS0_5FlagsE:
   26|  1.27k|std::string FlagsToString(Flags v) {
   27|  1.27k|  std::string s;
   28|  1.27k|  s.append(FlagsContains(v, Flags::kLeft) ? "-" : "");
  ------------------
  |  Branch (28:12): [True: 0, False: 1.27k]
  ------------------
   29|  1.27k|  s.append(FlagsContains(v, Flags::kShowPos) ? "+" : "");
  ------------------
  |  Branch (29:12): [True: 0, False: 1.27k]
  ------------------
   30|  1.27k|  s.append(FlagsContains(v, Flags::kSignCol) ? " " : "");
  ------------------
  |  Branch (30:12): [True: 0, False: 1.27k]
  ------------------
   31|  1.27k|  s.append(FlagsContains(v, Flags::kAlt) ? "#" : "");
  ------------------
  |  Branch (31:12): [True: 0, False: 1.27k]
  ------------------
   32|  1.27k|  s.append(FlagsContains(v, Flags::kZero) ? "0" : "");
  ------------------
  |  Branch (32:12): [True: 0, False: 1.27k]
  ------------------
   33|  1.27k|  return s;
   34|  1.27k|}

_ZNK4absl19str_format_internal24FormatConversionSpecImpl15conversion_charEv:
  290|  24.5k|  FormatConversionChar conversion_char() const {
  291|       |    // Keep this field first in the struct . It generates better code when
  292|       |    // accessing it when ConversionSpec is passed by value in registers.
  293|  24.5k|    static_assert(offsetof(FormatConversionSpecImpl, conv_) == 0, "");
  294|  24.5k|    return conv_;
  295|  24.5k|  }
_ZN4absl19str_format_internal8ContainsENS_23FormatConversionCharSetENS_20FormatConversionCharE:
  442|  5.17k|constexpr bool Contains(FormatConversionCharSet set, FormatConversionChar c) {
  443|  5.17k|  return (static_cast<uint64_t>(set) & FormatConversionCharToConvInt(c)) != 0;
  444|  5.17k|}
_ZN4absl19str_format_internal29FormatConversionCharToConvIntENS_20FormatConversionCharE:
  360|  5.17k|constexpr uint64_t FormatConversionCharToConvInt(FormatConversionChar c) {
  361|  5.17k|  return uint64_t{1} << (1 + static_cast<uint8_t>(c));
  362|  5.17k|}
_ZN4absl19str_format_internal17FormatRawSinkImpl5WriteENS_11string_viewE:
   48|  5.17k|  void Write(string_view s) { write_(sink_, s); }
_ZN4absl19str_format_internal14FormatSinkImplC2ENS0_17FormatRawSinkImplE:
   68|  5.17k|  explicit FormatSinkImpl(FormatRawSinkImpl raw) : raw_(raw) {}
_ZN4absl19str_format_internal14FormatSinkImplD2Ev:
   70|  5.17k|  ~FormatSinkImpl() { Flush(); }
_ZN4absl19str_format_internal14FormatSinkImpl5FlushEv:
   72|  5.17k|  void Flush() {
   73|  5.17k|    raw_.Write(string_view(buf_, static_cast<size_t>(pos_ - buf_)));
   74|  5.17k|    pos_ = buf_;
   75|  5.17k|  }
_ZN4absl19str_format_internal14FormatSinkImpl6AppendEmc:
   77|  4.68k|  void Append(size_t n, char c) {
   78|  4.68k|    if (n == 0) return;
  ------------------
  |  Branch (78:9): [True: 3.93k, False: 756]
  ------------------
   79|    756|    size_ += n;
   80|    756|    auto raw_append = [&](size_t count) {
   81|    756|      memset(pos_, c, count);
   82|    756|      pos_ += count;
   83|    756|    };
   84|    756|    while (n > Avail()) {
  ------------------
  |  Branch (84:12): [True: 0, False: 756]
  ------------------
   85|      0|      n -= Avail();
   86|      0|      if (Avail() > 0) {
  ------------------
  |  Branch (86:11): [True: 0, False: 0]
  ------------------
   87|      0|        raw_append(Avail());
   88|      0|      }
   89|      0|      Flush();
   90|      0|    }
   91|    756|    raw_append(n);
   92|    756|  }
_ZN4absl19str_format_internal14FormatSinkImpl6AppendENS_11string_viewE:
   94|  10.3k|  void Append(string_view v) {
   95|  10.3k|    size_t n = v.size();
   96|  10.3k|    if (n == 0) return;
  ------------------
  |  Branch (96:9): [True: 5.17k, False: 5.17k]
  ------------------
   97|  5.17k|    size_ += n;
   98|  5.17k|    if (n >= Avail()) {
  ------------------
  |  Branch (98:9): [True: 0, False: 5.17k]
  ------------------
   99|      0|      Flush();
  100|      0|      raw_.Write(v);
  101|      0|      return;
  102|      0|    }
  103|  5.17k|    memcpy(pos_, v.data(), n);
  104|  5.17k|    pos_ += n;
  105|  5.17k|  }
_ZNK4absl19str_format_internal14FormatSinkImpl5AvailEv:
  123|  5.93k|  size_t Avail() const {
  124|  5.93k|    return static_cast<size_t>(buf_ + sizeof(buf_) - pos_);
  125|  5.93k|  }
_ZNK4absl19str_format_internal24FormatConversionSpecImpl8is_basicEv:
  277|  2.58k|  bool is_basic() const { return flags_ == Flags::kBasic; }
_ZNK4absl19str_format_internal24FormatConversionSpecImpl13has_left_flagEv:
  278|  1.31k|  bool has_left_flag() const { return FlagsContains(flags_, Flags::kLeft); }
_ZNK4absl19str_format_internal24FormatConversionSpecImpl17has_show_pos_flagEv:
  279|    972|  bool has_show_pos_flag() const {
  280|    972|    return FlagsContains(flags_, Flags::kShowPos);
  281|    972|  }
_ZNK4absl19str_format_internal24FormatConversionSpecImpl17has_sign_col_flagEv:
  282|    972|  bool has_sign_col_flag() const {
  283|    972|    return FlagsContains(flags_, Flags::kSignCol);
  284|    972|  }
_ZNK4absl19str_format_internal24FormatConversionSpecImpl12has_alt_flagEv:
  285|  1.31k|  bool has_alt_flag() const { return FlagsContains(flags_, Flags::kAlt); }
_ZNK4absl19str_format_internal24FormatConversionSpecImpl13has_zero_flagEv:
  286|  1.31k|  bool has_zero_flag() const { return FlagsContains(flags_, Flags::kZero); }
_ZNK4absl19str_format_internal24FormatConversionSpecImpl5widthEv:
  301|  2.58k|  int width() const { return width_; }
_ZNK4absl19str_format_internal24FormatConversionSpecImpl9precisionEv:
  304|  3.86k|  int precision() const { return precision_; }
_ZN4absl19str_format_internal30FormatConversionSpecImplFriend8SetFlagsENS0_5FlagsEPNS0_24FormatConversionSpecImplE:
  321|  5.17k|  static void SetFlags(Flags f, FormatConversionSpecImpl* conv) {
  322|  5.17k|    conv->flags_ = f;
  323|  5.17k|  }
_ZN4absl19str_format_internal30FormatConversionSpecImplFriend17SetConversionCharENS_20FormatConversionCharEPNS0_24FormatConversionSpecImplE:
  328|  5.17k|                                FormatConversionSpecImpl* conv) {
  329|  5.17k|    conv->conv_ = c;
  330|  5.17k|  }
_ZN4absl19str_format_internal30FormatConversionSpecImplFriend8SetWidthEiPNS0_24FormatConversionSpecImplE:
  331|  5.17k|  static void SetWidth(int w, FormatConversionSpecImpl* conv) {
  332|  5.17k|    conv->width_ = w;
  333|  5.17k|  }
_ZN4absl19str_format_internal30FormatConversionSpecImplFriend12SetPrecisionEiPNS0_24FormatConversionSpecImplE:
  334|  5.17k|  static void SetPrecision(int p, FormatConversionSpecImpl* conv) {
  335|  5.17k|    conv->precision_ = p;
  336|  5.17k|  }
_ZN4absl19str_format_internal30FormatConversionSpecImplFriend13FlagsToStringERKNS0_24FormatConversionSpecImplE:
  337|  1.27k|  static std::string FlagsToString(const FormatConversionSpecImpl& spec) {
  338|  1.27k|    return str_format_internal::FlagsToString(spec.flags_);
  339|  1.27k|  }
_ZN4absl19str_format_internal13FlagsContainsENS0_5FlagsES1_:
  150|  12.2k|constexpr bool FlagsContains(Flags haystack, Flags needle) {
  151|  12.2k|  return (static_cast<uint8_t>(haystack) & static_cast<uint8_t>(needle)) ==
  152|  12.2k|         static_cast<uint8_t>(needle);
  153|  12.2k|}
_ZN4absl19str_format_internal27FormatConversionCharIsUpperENS_20FormatConversionCharE:
  220|  1.27k|inline bool FormatConversionCharIsUpper(FormatConversionChar c) {
  221|  1.27k|  if (c == FormatConversionCharInternal::X ||
  ------------------
  |  Branch (221:7): [True: 0, False: 1.27k]
  ------------------
  222|  1.27k|      c == FormatConversionCharInternal::F ||
  ------------------
  |  Branch (222:7): [True: 0, False: 1.27k]
  ------------------
  223|  1.27k|      c == FormatConversionCharInternal::E ||
  ------------------
  |  Branch (223:7): [True: 0, False: 1.27k]
  ------------------
  224|  1.27k|      c == FormatConversionCharInternal::G ||
  ------------------
  |  Branch (224:7): [True: 0, False: 1.27k]
  ------------------
  225|  1.27k|      c == FormatConversionCharInternal::A) {
  ------------------
  |  Branch (225:7): [True: 0, False: 1.27k]
  ------------------
  226|      0|    return true;
  227|  1.27k|  } else {
  228|  1.27k|    return false;
  229|  1.27k|  }
  230|  1.27k|}
_ZN4absl19str_format_internal27FormatConversionCharIsFloatENS_20FormatConversionCharE:
  232|  2.58k|inline bool FormatConversionCharIsFloat(FormatConversionChar c) {
  233|  2.58k|  if (c == FormatConversionCharInternal::a ||
  ------------------
  |  Branch (233:7): [True: 0, False: 2.58k]
  ------------------
  234|  2.58k|      c == FormatConversionCharInternal::e ||
  ------------------
  |  Branch (234:7): [True: 0, False: 2.58k]
  ------------------
  235|  2.58k|      c == FormatConversionCharInternal::f ||
  ------------------
  |  Branch (235:7): [True: 0, False: 2.58k]
  ------------------
  236|  2.58k|      c == FormatConversionCharInternal::g ||
  ------------------
  |  Branch (236:7): [True: 2.58k, False: 0]
  ------------------
  237|  2.58k|      c == FormatConversionCharInternal::A ||
  ------------------
  |  Branch (237:7): [True: 0, False: 0]
  ------------------
  238|  2.58k|      c == FormatConversionCharInternal::E ||
  ------------------
  |  Branch (238:7): [True: 0, False: 0]
  ------------------
  239|  2.58k|      c == FormatConversionCharInternal::F ||
  ------------------
  |  Branch (239:7): [True: 0, False: 0]
  ------------------
  240|  2.58k|      c == FormatConversionCharInternal::G) {
  ------------------
  |  Branch (240:7): [True: 0, False: 0]
  ------------------
  241|  2.58k|    return true;
  242|  2.58k|  } else {
  243|      0|    return false;
  244|      0|  }
  245|  2.58k|}
_ZN4absl19str_format_internal26FormatConversionCharToCharENS_20FormatConversionCharE:
  247|  1.27k|inline char FormatConversionCharToChar(FormatConversionChar c) {
  248|  1.27k|  if (c == FormatConversionCharInternal::kNone) {
  ------------------
  |  Branch (248:7): [True: 0, False: 1.27k]
  ------------------
  249|      0|    return '\0';
  250|       |
  251|      0|#define ABSL_INTERNAL_X_VAL(e)                       \
  252|      0|  } else if (c == FormatConversionCharInternal::e) { \
  253|      0|    return #e[0];
  254|      0|#define ABSL_INTERNAL_X_SEP
  255|  1.27k|  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
  ------------------
  |  |  164|      0|  X_VAL(c) X_SEP X_VAL(s) X_SEP \
  |  |  ------------------
  |  |  |  |  255|      0|  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
  |  |  |  |  ------------------
  |  |  |  |  |  |  252|  1.27k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.27k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  253|      0|    return #e[0];
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 X_VAL(c) X_SEP X_VAL(s) X_SEP \
  |  |  ------------------
  |  |  |  |  255|      0|  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
  |  |  |  |  ------------------
  |  |  |  |  |  |  252|  1.27k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.27k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  253|      0|    return #e[0];
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  165|      0|  /* ints */ \
  |  |  166|      0|  X_VAL(d) X_SEP X_VAL(i) X_SEP X_VAL(o) X_SEP \
  |  |  ------------------
  |  |  |  |  255|      0|  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
  |  |  |  |  ------------------
  |  |  |  |  |  |  252|  1.27k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.27k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  253|      0|    return #e[0];
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 X_VAL(d) X_SEP X_VAL(i) X_SEP X_VAL(o) X_SEP \
  |  |  ------------------
  |  |  |  |  255|      0|  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
  |  |  |  |  ------------------
  |  |  |  |  |  |  252|  1.27k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.27k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  253|      0|    return #e[0];
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 X_VAL(d) X_SEP X_VAL(i) X_SEP X_VAL(o) X_SEP \
  |  |  ------------------
  |  |  |  |  255|      0|  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
  |  |  |  |  ------------------
  |  |  |  |  |  |  252|  1.27k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.27k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  253|      0|    return #e[0];
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  167|      0|  X_VAL(u) X_SEP X_VAL(x) X_SEP X_VAL(X) X_SEP \
  |  |  ------------------
  |  |  |  |  255|      0|  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
  |  |  |  |  ------------------
  |  |  |  |  |  |  252|  1.27k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.27k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  253|      0|    return #e[0];
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 X_VAL(u) X_SEP X_VAL(x) X_SEP X_VAL(X) X_SEP \
  |  |  ------------------
  |  |  |  |  255|      0|  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
  |  |  |  |  ------------------
  |  |  |  |  |  |  252|  1.27k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.27k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  253|      0|    return #e[0];
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 X_VAL(u) X_SEP X_VAL(x) X_SEP X_VAL(X) X_SEP \
  |  |  ------------------
  |  |  |  |  255|      0|  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
  |  |  |  |  ------------------
  |  |  |  |  |  |  252|  1.27k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.27k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  253|      0|    return #e[0];
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  168|      0|  /* floats */ \
  |  |  169|      0|  X_VAL(f) X_SEP X_VAL(F) X_SEP X_VAL(e) X_SEP X_VAL(E) X_SEP \
  |  |  ------------------
  |  |  |  |  255|      0|  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
  |  |  |  |  ------------------
  |  |  |  |  |  |  252|  1.27k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.27k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  253|      0|    return #e[0];
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 X_VAL(f) X_SEP X_VAL(F) X_SEP X_VAL(e) X_SEP X_VAL(E) X_SEP \
  |  |  ------------------
  |  |  |  |  255|      0|  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
  |  |  |  |  ------------------
  |  |  |  |  |  |  252|  1.27k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.27k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  253|      0|    return #e[0];
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 X_VAL(f) X_SEP X_VAL(F) X_SEP X_VAL(e) X_SEP X_VAL(E) X_SEP \
  |  |  ------------------
  |  |  |  |  255|      0|  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
  |  |  |  |  ------------------
  |  |  |  |  |  |  252|  1.27k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.27k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  253|      0|    return #e[0];
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 X_VAL(f) X_SEP X_VAL(F) X_SEP X_VAL(e) X_SEP X_VAL(E) X_SEP \
  |  |  ------------------
  |  |  |  |  255|      0|  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
  |  |  |  |  ------------------
  |  |  |  |  |  |  252|  1.27k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.27k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  253|      0|    return #e[0];
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  170|  1.27k|  X_VAL(g) X_SEP X_VAL(G) X_SEP X_VAL(a) X_SEP X_VAL(A) X_SEP \
  |  |  ------------------
  |  |  |  |  255|      0|  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
  |  |  |  |  ------------------
  |  |  |  |  |  |  252|  1.27k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 1.27k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  253|  1.27k|    return #e[0];
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 X_VAL(g) X_SEP X_VAL(G) X_SEP X_VAL(a) X_SEP X_VAL(A) X_SEP \
  |  |  ------------------
  |  |  |  |  255|  1.27k|  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
  |  |  |  |  ------------------
  |  |  |  |  |  |  252|  1.27k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  253|      0|    return #e[0];
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 X_VAL(g) X_SEP X_VAL(G) X_SEP X_VAL(a) X_SEP X_VAL(A) X_SEP \
  |  |  ------------------
  |  |  |  |  255|      0|  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
  |  |  |  |  ------------------
  |  |  |  |  |  |  252|      0|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  253|      0|    return #e[0];
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 X_VAL(g) X_SEP X_VAL(G) X_SEP X_VAL(a) X_SEP X_VAL(A) X_SEP \
  |  |  ------------------
  |  |  |  |  255|      0|  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
  |  |  |  |  ------------------
  |  |  |  |  |  |  252|      0|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  253|      0|    return #e[0];
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  171|      0|  /* misc */ \
  |  |  172|      0|  X_VAL(n) X_SEP X_VAL(p) X_SEP X_VAL(v)
  |  |  ------------------
  |  |  |  |  255|      0|  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
  |  |  |  |  ------------------
  |  |  |  |  |  |  252|      0|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  253|      0|    return #e[0];
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 X_VAL(n) X_SEP X_VAL(p) X_SEP X_VAL(v)
  |  |  ------------------
  |  |  |  |  255|      0|  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
  |  |  |  |  ------------------
  |  |  |  |  |  |  252|      0|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  253|      0|    return #e[0];
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 X_VAL(n) X_SEP X_VAL(p) X_SEP X_VAL(v)
  |  |  ------------------
  |  |  |  |  255|      0|  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
  |  |  |  |  ------------------
  |  |  |  |  |  |  252|      0|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  253|      0|    return #e[0];
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  256|      0|                                         ABSL_INTERNAL_X_SEP)
  257|      0|  } else {
  258|      0|    return '\0';
  259|      0|  }
  260|       |
  261|  1.27k|#undef ABSL_INTERNAL_X_VAL
  262|  1.27k|#undef ABSL_INTERNAL_X_SEP
  263|  1.27k|}
_ZZN4absl19str_format_internal14FormatSinkImpl6AppendEmcENKUlmE_clEm:
   80|    756|    auto raw_append = [&](size_t count) {
   81|    756|      memset(pos_, c, count);
   82|    756|      pos_ += count;
   83|    756|    };
_ZN4absl19str_format_internal17FormatRawSinkImplC2INSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEELPv0EEEPT_:
   46|  5.17k|      : sink_(raw), write_(&FormatRawSinkImpl::Flush<T>) {}
_ZN4absl19str_format_internal17FormatRawSinkImpl5FlushINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvPvNS_11string_viewE:
   57|  5.17k|  static void Flush(void* r, string_view s) {
   58|  5.17k|    str_format_internal::InvokeFlush(static_cast<T*>(r), s);
   59|  5.17k|  }

_ZN4absl19str_format_internal16ConvertFloatImplEfRKNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
 1446|  1.29k|                      FormatSinkImpl *sink) {
 1447|  1.29k|  return FloatToSink(static_cast<double>(v), conv, sink);
 1448|  1.29k|}
_ZN4absl19str_format_internal16ConvertFloatImplEdRKNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
 1451|  1.29k|                      FormatSinkImpl *sink) {
 1452|  1.29k|  return FloatToSink(v, conv, sink);
 1453|  1.29k|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_119PrintIntegralDigitsILNS1_11FormatStyleE1EmEEmT0_PNS1_6BufferE:
 1140|     40|size_t PrintIntegralDigits(Int digits, Buffer* out) {
 1141|     40|  size_t printed = 0;
 1142|     40|  if (digits) {
  ------------------
  |  Branch (1142:7): [True: 0, False: 40]
  ------------------
 1143|      0|    for (; digits; digits /= 10) out->push_front(digits % 10 + '0');
  ------------------
  |  Branch (1143:12): [True: 0, False: 0]
  ------------------
 1144|      0|    printed = out->size();
 1145|      0|    if (mode == FormatStyle::Precision) {
  ------------------
  |  Branch (1145:9): [Folded - Ignored]
  ------------------
 1146|      0|      out->push_front(*out->begin);
 1147|      0|      out->begin[1] = '.';
 1148|      0|    } else {
 1149|      0|      out->push_back('.');
 1150|      0|    }
 1151|     40|  } else if (mode == FormatStyle::Fixed) {
  ------------------
  |  Branch (1151:14): [Folded - Ignored]
  ------------------
 1152|      0|    out->push_front('0');
 1153|      0|    out->push_back('.');
 1154|      0|    printed = 1;
 1155|      0|  }
 1156|     40|  return printed;
 1157|     40|}
float_conversion.cc:_ZNK4absl19str_format_internal12_GLOBAL__N_16Buffer4sizeEv:
 1025|  1.27k|  size_t size() const { return static_cast<size_t>(end - begin); }
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_120RemoveExtraPrecisionEmbPNS1_6BufferEPi:
 1163|  1.27k|                          int* exp_out) {
 1164|       |  // Back out the extra digits
 1165|  1.27k|  out->end -= extra_digits;
 1166|       |
 1167|  1.27k|  bool needs_to_round_up = [&] {
 1168|       |    // We look at the digit just past the end.
 1169|       |    // There must be 'extra_digits' extra valid digits after end.
 1170|  1.27k|    if (*out->end > '5') return true;
 1171|  1.27k|    if (*out->end < '5') return false;
 1172|  1.27k|    if (has_leftover_value || std::any_of(out->end + 1, out->end + extra_digits,
 1173|  1.27k|                                          [](char c) { return c != '0'; }))
 1174|  1.27k|      return true;
 1175|       |
 1176|       |    // Ends in ...50*, round to even.
 1177|  1.27k|    return out->last_digit() % 2 == 1;
 1178|  1.27k|  }();
 1179|       |
 1180|  1.27k|  if (needs_to_round_up) {
  ------------------
  |  Branch (1180:7): [True: 562, False: 708]
  ------------------
 1181|    562|    RoundUp<FormatStyle::Precision>(out, exp_out);
 1182|    562|  }
 1183|  1.27k|}
float_conversion.cc:_ZZN4absl19str_format_internal12_GLOBAL__N_120RemoveExtraPrecisionEmbPNS1_6BufferEPiENK3$_2clEv:
 1167|  1.27k|  bool needs_to_round_up = [&] {
 1168|       |    // We look at the digit just past the end.
 1169|       |    // There must be 'extra_digits' extra valid digits after end.
 1170|  1.27k|    if (*out->end > '5') return true;
  ------------------
  |  Branch (1170:9): [True: 431, False: 839]
  ------------------
 1171|    839|    if (*out->end < '5') return false;
  ------------------
  |  Branch (1171:9): [True: 708, False: 131]
  ------------------
 1172|    131|    if (has_leftover_value || std::any_of(out->end + 1, out->end + extra_digits,
  ------------------
  |  Branch (1172:9): [True: 0, False: 131]
  |  Branch (1172:9): [True: 131, False: 0]
  |  Branch (1172:31): [True: 131, False: 0]
  ------------------
 1173|    131|                                          [](char c) { return c != '0'; }))
 1174|    131|      return true;
 1175|       |
 1176|       |    // Ends in ...50*, round to even.
 1177|      0|    return out->last_digit() % 2 == 1;
 1178|    131|  }();
float_conversion.cc:_ZZZN4absl19str_format_internal12_GLOBAL__N_120RemoveExtraPrecisionEmbPNS1_6BufferEPiENK3$_2clEvENKUlcE_clEc:
 1173|    181|                                          [](char c) { return c != '0'; }))
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_16Buffer9push_backEc:
 1009|  5.32k|  void push_back(char c) {
 1010|  5.32k|    assert(end < data + sizeof(data));
 1011|  5.32k|    *end++ = c;
 1012|  5.32k|  }
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_16Buffer10push_frontEc:
 1005|  49.3k|  void push_front(char c) {
 1006|  49.3k|    assert(begin > data);
 1007|  49.3k|    *--begin = c;
 1008|  49.3k|  }
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_17RoundUpILNS1_11FormatStyleE1EEEvPNS1_6BufferEPi:
 1063|    562|void RoundUp(Buffer *buffer, int *exp) {
 1064|    562|  char *p = &buffer->back();
 1065|  1.07k|  while (p >= buffer->begin && (*p == '9' || *p == '.')) {
  ------------------
  |  Branch (1065:10): [True: 1.03k, False: 39]
  |  Branch (1065:33): [True: 454, False: 584]
  |  Branch (1065:46): [True: 61, False: 523]
  ------------------
 1066|    515|    if (*p == '9') *p = '0';
  ------------------
  |  Branch (1066:9): [True: 454, False: 61]
  ------------------
 1067|    515|    --p;
 1068|    515|  }
 1069|       |
 1070|    562|  if (p < buffer->begin) {
  ------------------
  |  Branch (1070:7): [True: 39, False: 523]
  ------------------
 1071|     39|    *p = '1';
 1072|     39|    buffer->begin = p;
 1073|     39|    if (mode == FormatStyle::Precision) {
  ------------------
  |  Branch (1073:9): [Folded - Ignored]
  ------------------
 1074|     39|      std::swap(p[1], p[2]);  // move the .
 1075|     39|      ++*exp;
 1076|     39|      buffer->pop_back();
 1077|     39|    }
 1078|    523|  } else {
 1079|    523|    ++*p;
 1080|    523|  }
 1081|    562|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_119PrintIntegralDigitsILNS1_11FormatStyleE1EoEEmT0_PNS1_6BufferE:
 1140|  1.27k|size_t PrintIntegralDigits(Int digits, Buffer* out) {
 1141|  1.27k|  size_t printed = 0;
 1142|  1.27k|  if (digits) {
  ------------------
  |  Branch (1142:7): [True: 1.27k, False: 0]
  ------------------
 1143|  49.2k|    for (; digits; digits /= 10) out->push_front(digits % 10 + '0');
  ------------------
  |  Branch (1143:12): [True: 48.0k, False: 1.27k]
  ------------------
 1144|  1.27k|    printed = out->size();
 1145|  1.27k|    if (mode == FormatStyle::Precision) {
  ------------------
  |  Branch (1145:9): [Folded - Ignored]
  ------------------
 1146|  1.27k|      out->push_front(*out->begin);
 1147|  1.27k|      out->begin[1] = '.';
 1148|  1.27k|    } else {
 1149|      0|      out->push_back('.');
 1150|      0|    }
 1151|  1.27k|  } else if (mode == FormatStyle::Fixed) {
  ------------------
  |  Branch (1151:14): [Folded - Ignored]
  ------------------
 1152|      0|    out->push_front('0');
 1153|      0|    out->push_back('.');
 1154|      0|    printed = 1;
 1155|      0|  }
 1156|  1.27k|  return printed;
 1157|  1.27k|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_112CopyStringToENS_11string_viewEPc:
  956|  2.55k|char *CopyStringTo(absl::string_view v, char *out) {
  957|  2.55k|  std::memcpy(out, v.data(), v.size());
  958|  2.55k|  return out + v.size();
  959|  2.55k|}
float_conversion.cc:_ZNK4absl19str_format_internal12_GLOBAL__N_16Buffer4backEv:
 1018|  3.86k|  char &back() const {
 1019|  3.86k|    assert(begin < end);
 1020|  3.86k|    return end[-1];
 1021|  3.86k|  }
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_16Buffer8pop_backEv:
 1013|    826|  void pop_back() {
 1014|    826|    assert(begin < end);
 1015|    826|    --end;
 1016|    826|  }
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_113PrintExponentEicPNS1_6BufferE:
 1083|  1.27k|void PrintExponent(int exp, char e, Buffer *out) {
 1084|  1.27k|  out->push_back(e);
 1085|  1.27k|  if (exp < 0) {
  ------------------
  |  Branch (1085:7): [True: 0, False: 1.27k]
  ------------------
 1086|      0|    out->push_back('-');
 1087|      0|    exp = -exp;
 1088|  1.27k|  } else {
 1089|  1.27k|    out->push_back('+');
 1090|  1.27k|  }
 1091|       |  // Exponent digits.
 1092|  1.27k|  if (exp > 99) {
  ------------------
  |  Branch (1092:7): [True: 0, False: 1.27k]
  ------------------
 1093|      0|    out->push_back(static_cast<char>(exp / 100 + '0'));
 1094|      0|    out->push_back(static_cast<char>(exp / 10 % 10 + '0'));
 1095|      0|    out->push_back(static_cast<char>(exp % 10 + '0'));
 1096|  1.27k|  } else {
 1097|  1.27k|    out->push_back(static_cast<char>(exp / 10 + '0'));
 1098|  1.27k|    out->push_back(static_cast<char>(exp % 10 + '0'));
 1099|  1.27k|  }
 1100|  1.27k|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_117WriteBufferToSinkEcNS_11string_viewERKNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
 1310|  1.31k|                       FormatSinkImpl *sink) {
 1311|  1.31k|  size_t left_spaces = 0, zeros = 0, right_spaces = 0;
 1312|  1.31k|  size_t missing_chars = 0;
 1313|  1.31k|  if (conv.width() >= 0) {
  ------------------
  |  Branch (1313:7): [True: 0, False: 1.31k]
  ------------------
 1314|      0|    const size_t conv_width_size_t = static_cast<size_t>(conv.width());
 1315|      0|    const size_t existing_chars =
 1316|      0|        str.size() + static_cast<size_t>(sign_char != 0);
 1317|      0|    if (conv_width_size_t > existing_chars)
  ------------------
  |  Branch (1317:9): [True: 0, False: 0]
  ------------------
 1318|      0|      missing_chars = conv_width_size_t - existing_chars;
 1319|      0|  }
 1320|  1.31k|  if (conv.has_left_flag()) {
  ------------------
  |  Branch (1320:7): [True: 0, False: 1.31k]
  ------------------
 1321|      0|    right_spaces = missing_chars;
 1322|  1.31k|  } else if (conv.has_zero_flag()) {
  ------------------
  |  Branch (1322:14): [True: 0, False: 1.31k]
  ------------------
 1323|      0|    zeros = missing_chars;
 1324|  1.31k|  } else {
 1325|  1.31k|    left_spaces = missing_chars;
 1326|  1.31k|  }
 1327|       |
 1328|  1.31k|  sink->Append(left_spaces, ' ');
 1329|  1.31k|  if (sign_char != '\0') sink->Append(1, sign_char);
  ------------------
  |  Branch (1329:7): [True: 756, False: 554]
  ------------------
 1330|  1.31k|  sink->Append(zeros, '0');
 1331|  1.31k|  sink->Append(str);
 1332|  1.31k|  sink->Append(right_spaces, ' ');
 1333|  1.31k|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_111FloatToSinkIdEEbT_RKNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
 1337|  2.58k|                 FormatSinkImpl *sink) {
 1338|       |  // Print the sign or the sign column.
 1339|  2.58k|  Float abs_v = v;
 1340|  2.58k|  char sign_char = 0;
 1341|  2.58k|  if (std::signbit(abs_v)) {
  ------------------
  |  Branch (1341:7): [True: 1.61k, False: 972]
  ------------------
 1342|  1.61k|    sign_char = '-';
 1343|  1.61k|    abs_v = -abs_v;
 1344|  1.61k|  } else if (conv.has_show_pos_flag()) {
  ------------------
  |  Branch (1344:14): [True: 0, False: 972]
  ------------------
 1345|      0|    sign_char = '+';
 1346|    972|  } else if (conv.has_sign_col_flag()) {
  ------------------
  |  Branch (1346:14): [True: 0, False: 972]
  ------------------
 1347|      0|    sign_char = ' ';
 1348|      0|  }
 1349|       |
 1350|       |  // Print nan/inf.
 1351|  2.58k|  if (ConvertNonNumericFloats(sign_char, abs_v, conv, sink)) {
  ------------------
  |  Branch (1351:7): [True: 0, False: 2.58k]
  ------------------
 1352|      0|    return true;
 1353|      0|  }
 1354|       |
 1355|  2.58k|  size_t precision =
 1356|  2.58k|      conv.precision() < 0 ? 6 : static_cast<size_t>(conv.precision());
  ------------------
  |  Branch (1356:7): [True: 2.58k, False: 0]
  ------------------
 1357|       |
 1358|  2.58k|  int exp = 0;
 1359|       |
 1360|  2.58k|  auto decomposed = Decompose(abs_v);
 1361|       |
 1362|  2.58k|  Buffer buffer;
 1363|       |
 1364|  2.58k|  FormatConversionChar c = conv.conversion_char();
 1365|       |
 1366|  2.58k|  if (c == FormatConversionCharInternal::f ||
  ------------------
  |  Branch (1366:7): [True: 0, False: 2.58k]
  ------------------
 1367|  2.58k|      c == FormatConversionCharInternal::F) {
  ------------------
  |  Branch (1367:7): [True: 0, False: 2.58k]
  ------------------
 1368|      0|    FormatF(decomposed.mantissa, decomposed.exponent,
 1369|      0|            {sign_char, precision, conv, sink});
 1370|      0|    return true;
 1371|  2.58k|  } else if (c == FormatConversionCharInternal::e ||
  ------------------
  |  Branch (1371:14): [True: 0, False: 2.58k]
  ------------------
 1372|  2.58k|             c == FormatConversionCharInternal::E) {
  ------------------
  |  Branch (1372:14): [True: 0, False: 2.58k]
  ------------------
 1373|      0|    if (!FloatToBuffer<FormatStyle::Precision>(decomposed, precision, &buffer,
  ------------------
  |  Branch (1373:9): [True: 0, False: 0]
  ------------------
 1374|      0|                                               &exp)) {
 1375|      0|      return FallbackToSnprintf(v, conv, sink);
 1376|      0|    }
 1377|      0|    if (!conv.has_alt_flag() && buffer.back() == '.') buffer.pop_back();
  ------------------
  |  Branch (1377:9): [True: 0, False: 0]
  |  Branch (1377:33): [True: 0, False: 0]
  ------------------
 1378|      0|    PrintExponent(
 1379|      0|        exp, FormatConversionCharIsUpper(conv.conversion_char()) ? 'E' : 'e',
  ------------------
  |  Branch (1379:14): [True: 0, False: 0]
  ------------------
 1380|      0|        &buffer);
 1381|  2.58k|  } else if (c == FormatConversionCharInternal::g ||
  ------------------
  |  Branch (1381:14): [True: 2.58k, False: 0]
  ------------------
 1382|  2.58k|             c == FormatConversionCharInternal::G) {
  ------------------
  |  Branch (1382:14): [True: 0, False: 0]
  ------------------
 1383|  2.58k|    precision = std::max(precision, size_t{1}) - 1;
 1384|  2.58k|    if (!FloatToBuffer<FormatStyle::Precision>(decomposed, precision, &buffer,
  ------------------
  |  Branch (1384:9): [True: 1.27k, False: 1.31k]
  ------------------
 1385|  2.58k|                                               &exp)) {
 1386|  1.27k|      return FallbackToSnprintf(v, conv, sink);
 1387|  1.27k|    }
 1388|  1.31k|    if ((exp < 0 || precision + 1 > static_cast<size_t>(exp)) && exp >= -4) {
  ------------------
  |  Branch (1388:10): [True: 0, False: 1.31k]
  |  Branch (1388:21): [True: 40, False: 1.27k]
  |  Branch (1388:66): [True: 40, False: 0]
  ------------------
 1389|     40|      if (exp < 0) {
  ------------------
  |  Branch (1389:11): [True: 0, False: 40]
  ------------------
 1390|       |        // Have 1.23456, needs 0.00123456
 1391|       |        // Move the first digit
 1392|      0|        buffer.begin[1] = *buffer.begin;
 1393|       |        // Add some zeros
 1394|      0|        for (; exp < -1; ++exp) *buffer.begin-- = '0';
  ------------------
  |  Branch (1394:16): [True: 0, False: 0]
  ------------------
 1395|      0|        *buffer.begin-- = '.';
 1396|      0|        *buffer.begin = '0';
 1397|     40|      } else if (exp > 0) {
  ------------------
  |  Branch (1397:18): [True: 0, False: 40]
  ------------------
 1398|       |        // Have 1.23456, needs 1234.56
 1399|       |        // Move the '.' exp positions to the right.
 1400|      0|        std::rotate(buffer.begin + 1, buffer.begin + 2, buffer.begin + exp + 2);
 1401|      0|      }
 1402|     40|      exp = 0;
 1403|     40|    }
 1404|  1.31k|    if (!conv.has_alt_flag()) {
  ------------------
  |  Branch (1404:9): [True: 1.31k, False: 0]
  ------------------
 1405|  1.99k|      while (buffer.back() == '0') buffer.pop_back();
  ------------------
  |  Branch (1405:14): [True: 684, False: 1.31k]
  ------------------
 1406|  1.31k|      if (buffer.back() == '.') buffer.pop_back();
  ------------------
  |  Branch (1406:11): [True: 103, False: 1.20k]
  ------------------
 1407|  1.31k|    }
 1408|  1.31k|    if (exp) {
  ------------------
  |  Branch (1408:9): [True: 1.27k, False: 40]
  ------------------
 1409|  1.27k|      PrintExponent(
 1410|  1.27k|          exp, FormatConversionCharIsUpper(conv.conversion_char()) ? 'E' : 'e',
  ------------------
  |  Branch (1410:16): [True: 0, False: 1.27k]
  ------------------
 1411|  1.27k|          &buffer);
 1412|  1.27k|    }
 1413|  1.31k|  } else if (c == FormatConversionCharInternal::a ||
  ------------------
  |  Branch (1413:14): [True: 0, False: 0]
  ------------------
 1414|      0|             c == FormatConversionCharInternal::A) {
  ------------------
  |  Branch (1414:14): [True: 0, False: 0]
  ------------------
 1415|      0|    bool uppercase = (c == FormatConversionCharInternal::A);
 1416|      0|    FormatA(HexFloatTypeParams(Float{}), decomposed.mantissa,
 1417|      0|            decomposed.exponent, uppercase, {sign_char, precision, conv, sink});
 1418|      0|    return true;
 1419|      0|  } else {
 1420|      0|    return false;
 1421|      0|  }
 1422|       |
 1423|  1.31k|  WriteBufferToSink(
 1424|  1.31k|      sign_char,
 1425|  1.31k|      absl::string_view(buffer.begin,
 1426|  1.31k|                        static_cast<size_t>(buffer.end - buffer.begin)),
 1427|  1.31k|      conv, sink);
 1428|       |
 1429|  1.31k|  return true;
 1430|  2.58k|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_123ConvertNonNumericFloatsIdEEbcT_RKNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
 1039|  2.58k|                             FormatSinkImpl *sink) {
 1040|  2.58k|  char text[4], *ptr = text;
 1041|  2.58k|  if (sign_char != '\0') *ptr++ = sign_char;
  ------------------
  |  Branch (1041:7): [True: 1.61k, False: 972]
  ------------------
 1042|  2.58k|  if (std::isnan(v)) {
  ------------------
  |  Branch (1042:7): [True: 0, False: 2.58k]
  ------------------
 1043|      0|    ptr = std::copy_n(
 1044|      0|        FormatConversionCharIsUpper(conv.conversion_char()) ? "NAN" : "nan", 3,
  ------------------
  |  Branch (1044:9): [True: 0, False: 0]
  ------------------
 1045|      0|        ptr);
 1046|  2.58k|  } else if (std::isinf(v)) {
  ------------------
  |  Branch (1046:14): [True: 0, False: 2.58k]
  ------------------
 1047|      0|    ptr = std::copy_n(
 1048|      0|        FormatConversionCharIsUpper(conv.conversion_char()) ? "INF" : "inf", 3,
  ------------------
  |  Branch (1048:9): [True: 0, False: 0]
  ------------------
 1049|      0|        ptr);
 1050|  2.58k|  } else {
 1051|  2.58k|    return false;
 1052|  2.58k|  }
 1053|       |
 1054|      0|  return sink->PutPaddedString(
 1055|      0|      string_view(text, static_cast<size_t>(ptr - text)), conv.width(), -1,
 1056|      0|      conv.has_left_flag());
 1057|  2.58k|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_19DecomposeIdEENS1_10DecomposedIT_EES4_:
 1127|  2.58k|Decomposed<Float> Decompose(Float v) {
 1128|  2.58k|  int exp;
 1129|  2.58k|  Float m = std::frexp(v, &exp);
 1130|  2.58k|  m = std::ldexp(m, std::numeric_limits<Float>::digits);
 1131|  2.58k|  exp -= std::numeric_limits<Float>::digits;
 1132|       |
 1133|  2.58k|  return {static_cast<typename Decomposed<Float>::MantissaType>(m), exp};
 1134|  2.58k|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_113FloatToBufferILNS1_11FormatStyleE1EdEEbNS1_10DecomposedIT0_EEmPNS1_6BufferEPi:
 1288|  2.58k|                   int* exp) {
 1289|  2.58k|  if (precision > kMaxFixedPrecision) return false;
  ------------------
  |  Branch (1289:7): [True: 0, False: 2.58k]
  ------------------
 1290|       |
 1291|       |  // Try with uint64_t.
 1292|  2.58k|  if (CanFitMantissa<Float, std::uint64_t>() &&
  ------------------
  |  Branch (1292:7): [Folded - Ignored]
  ------------------
 1293|  2.58k|      FloatToBufferImpl<std::uint64_t, Float, mode>(
  ------------------
  |  Branch (1293:7): [True: 40, False: 2.54k]
  ------------------
 1294|  2.58k|          static_cast<std::uint64_t>(decomposed.mantissa), decomposed.exponent,
 1295|  2.58k|          precision, out, exp))
 1296|     40|    return true;
 1297|       |
 1298|  2.54k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
 1299|       |  // If that is not enough, try with __uint128_t.
 1300|  2.54k|  return CanFitMantissa<Float, __uint128_t>() &&
  ------------------
  |  Branch (1300:10): [Folded - Ignored]
  ------------------
 1301|  2.54k|         FloatToBufferImpl<__uint128_t, Float, mode>(
  ------------------
  |  Branch (1301:10): [True: 1.27k, False: 1.27k]
  ------------------
 1302|  2.54k|             static_cast<__uint128_t>(decomposed.mantissa), decomposed.exponent,
 1303|  2.54k|             precision, out, exp);
 1304|      0|#endif
 1305|      0|  return false;
 1306|  2.58k|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_117FloatToBufferImplImdLNS1_11FormatStyleE1EEEbT_imPNS1_6BufferEPi:
 1193|  2.58k|                       int* exp_out) {
 1194|  2.58k|  assert((CanFitMantissa<Float, Int>()));
 1195|       |
 1196|  2.58k|  const int int_bits = std::numeric_limits<Int>::digits;
 1197|       |
 1198|       |  // In precision mode, we start printing one char to the right because it will
 1199|       |  // also include the '.'
 1200|       |  // In fixed mode we put the dot afterwards on the right.
 1201|  2.58k|  out->begin = out->end =
 1202|  2.58k|      out->data + 1 + kMaxFixedPrecision + (mode == FormatStyle::Precision);
 1203|       |
 1204|  2.58k|  if (exp >= 0) {
  ------------------
  |  Branch (1204:7): [True: 2.54k, False: 40]
  ------------------
 1205|  2.54k|    if (std::numeric_limits<Float>::digits + exp > int_bits) {
  ------------------
  |  Branch (1205:9): [True: 2.54k, False: 0]
  ------------------
 1206|       |      // The value will overflow the Int
 1207|  2.54k|      return false;
 1208|  2.54k|    }
 1209|      0|    size_t digits_printed = PrintIntegralDigits<mode>(int_mantissa << exp, out);
 1210|      0|    size_t digits_to_zero_pad = precision;
 1211|      0|    if (mode == FormatStyle::Precision) {
  ------------------
  |  Branch (1211:9): [Folded - Ignored]
  ------------------
 1212|      0|      *exp_out = static_cast<int>(digits_printed - 1);
 1213|      0|      if (digits_to_zero_pad < digits_printed - 1) {
  ------------------
  |  Branch (1213:11): [True: 0, False: 0]
  ------------------
 1214|      0|        RemoveExtraPrecision(digits_printed - 1 - digits_to_zero_pad, false,
 1215|      0|                             out, exp_out);
 1216|      0|        return true;
 1217|      0|      }
 1218|      0|      digits_to_zero_pad -= digits_printed - 1;
 1219|      0|    }
 1220|      0|    for (; digits_to_zero_pad-- > 0;) out->push_back('0');
  ------------------
  |  Branch (1220:12): [True: 0, False: 0]
  ------------------
 1221|      0|    return true;
 1222|      0|  }
 1223|       |
 1224|     40|  exp = -exp;
 1225|       |  // We need at least 4 empty bits for the next decimal digit.
 1226|       |  // We will multiply by 10.
 1227|     40|  if (exp > int_bits - 4) return false;
  ------------------
  |  Branch (1227:7): [True: 0, False: 40]
  ------------------
 1228|       |
 1229|     40|  const Int mask = (Int{1} << exp) - 1;
 1230|       |
 1231|       |  // Print the integral part first.
 1232|     40|  size_t digits_printed = PrintIntegralDigits<mode>(int_mantissa >> exp, out);
 1233|     40|  int_mantissa &= mask;
 1234|       |
 1235|     40|  size_t fractional_count = precision;
 1236|     40|  if (mode == FormatStyle::Precision) {
  ------------------
  |  Branch (1236:7): [Folded - Ignored]
  ------------------
 1237|     40|    if (digits_printed == 0) {
  ------------------
  |  Branch (1237:9): [True: 40, False: 0]
  ------------------
 1238|       |      // Find the first non-zero digit, when in Precision mode.
 1239|     40|      *exp_out = 0;
 1240|     40|      if (int_mantissa) {
  ------------------
  |  Branch (1240:11): [True: 0, False: 40]
  ------------------
 1241|      0|        while (int_mantissa <= mask) {
  ------------------
  |  Branch (1241:16): [True: 0, False: 0]
  ------------------
 1242|      0|          int_mantissa *= 10;
 1243|      0|          --*exp_out;
 1244|      0|        }
 1245|      0|      }
 1246|     40|      out->push_front(static_cast<char>(int_mantissa >> exp) + '0');
 1247|     40|      out->push_back('.');
 1248|     40|      int_mantissa &= mask;
 1249|     40|    } else {
 1250|       |      // We already have a digit, and a '.'
 1251|      0|      *exp_out = static_cast<int>(digits_printed - 1);
 1252|      0|      if (fractional_count < digits_printed - 1) {
  ------------------
  |  Branch (1252:11): [True: 0, False: 0]
  ------------------
 1253|       |        // If we had enough digits, return right away.
 1254|       |        // The code below will try to round again otherwise.
 1255|      0|        RemoveExtraPrecision(digits_printed - 1 - fractional_count,
 1256|      0|                             int_mantissa != 0, out, exp_out);
 1257|      0|        return true;
 1258|      0|      }
 1259|      0|      fractional_count -= digits_printed - 1;
 1260|      0|    }
 1261|     40|  }
 1262|       |
 1263|     40|  auto get_next_digit = [&] {
 1264|     40|    int_mantissa *= 10;
 1265|     40|    char digit = static_cast<char>(int_mantissa >> exp);
 1266|     40|    int_mantissa &= mask;
 1267|     40|    return digit;
 1268|     40|  };
 1269|       |
 1270|       |  // Print fractional_count more digits, if available.
 1271|    240|  for (; fractional_count > 0; --fractional_count) {
  ------------------
  |  Branch (1271:10): [True: 200, False: 40]
  ------------------
 1272|    200|    out->push_back(get_next_digit() + '0');
 1273|    200|  }
 1274|       |
 1275|     40|  char next_digit = get_next_digit();
 1276|     40|  if (next_digit > 5 ||
  ------------------
  |  Branch (1276:7): [True: 0, False: 40]
  ------------------
 1277|     40|      (next_digit == 5 && (int_mantissa || out->last_digit() % 2 == 1))) {
  ------------------
  |  Branch (1277:8): [True: 0, False: 40]
  |  Branch (1277:28): [True: 0, False: 0]
  |  Branch (1277:44): [True: 0, False: 0]
  ------------------
 1278|      0|    RoundUp<mode>(out, exp_out);
 1279|      0|  }
 1280|       |
 1281|     40|  return true;
 1282|     40|}
float_conversion.cc:_ZZN4absl19str_format_internal12_GLOBAL__N_117FloatToBufferImplImdLNS1_11FormatStyleE1EEEbT_imPNS1_6BufferEPiENKUlvE_clEv:
 1263|    240|  auto get_next_digit = [&] {
 1264|    240|    int_mantissa *= 10;
 1265|    240|    char digit = static_cast<char>(int_mantissa >> exp);
 1266|    240|    int_mantissa &= mask;
 1267|    240|    return digit;
 1268|    240|  };
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_117FloatToBufferImplIodLNS1_11FormatStyleE1EEEbT_imPNS1_6BufferEPi:
 1193|  2.54k|                       int* exp_out) {
 1194|  2.54k|  assert((CanFitMantissa<Float, Int>()));
 1195|       |
 1196|  2.54k|  const int int_bits = std::numeric_limits<Int>::digits;
 1197|       |
 1198|       |  // In precision mode, we start printing one char to the right because it will
 1199|       |  // also include the '.'
 1200|       |  // In fixed mode we put the dot afterwards on the right.
 1201|  2.54k|  out->begin = out->end =
 1202|  2.54k|      out->data + 1 + kMaxFixedPrecision + (mode == FormatStyle::Precision);
 1203|       |
 1204|  2.54k|  if (exp >= 0) {
  ------------------
  |  Branch (1204:7): [True: 2.54k, False: 0]
  ------------------
 1205|  2.54k|    if (std::numeric_limits<Float>::digits + exp > int_bits) {
  ------------------
  |  Branch (1205:9): [True: 1.27k, False: 1.27k]
  ------------------
 1206|       |      // The value will overflow the Int
 1207|  1.27k|      return false;
 1208|  1.27k|    }
 1209|  1.27k|    size_t digits_printed = PrintIntegralDigits<mode>(int_mantissa << exp, out);
 1210|  1.27k|    size_t digits_to_zero_pad = precision;
 1211|  1.27k|    if (mode == FormatStyle::Precision) {
  ------------------
  |  Branch (1211:9): [Folded - Ignored]
  ------------------
 1212|  1.27k|      *exp_out = static_cast<int>(digits_printed - 1);
 1213|  1.27k|      if (digits_to_zero_pad < digits_printed - 1) {
  ------------------
  |  Branch (1213:11): [True: 1.27k, False: 0]
  ------------------
 1214|  1.27k|        RemoveExtraPrecision(digits_printed - 1 - digits_to_zero_pad, false,
 1215|  1.27k|                             out, exp_out);
 1216|  1.27k|        return true;
 1217|  1.27k|      }
 1218|      0|      digits_to_zero_pad -= digits_printed - 1;
 1219|      0|    }
 1220|      0|    for (; digits_to_zero_pad-- > 0;) out->push_back('0');
  ------------------
  |  Branch (1220:12): [True: 0, False: 0]
  ------------------
 1221|      0|    return true;
 1222|  1.27k|  }
 1223|       |
 1224|      0|  exp = -exp;
 1225|       |  // We need at least 4 empty bits for the next decimal digit.
 1226|       |  // We will multiply by 10.
 1227|      0|  if (exp > int_bits - 4) return false;
  ------------------
  |  Branch (1227:7): [True: 0, False: 0]
  ------------------
 1228|       |
 1229|      0|  const Int mask = (Int{1} << exp) - 1;
 1230|       |
 1231|       |  // Print the integral part first.
 1232|      0|  size_t digits_printed = PrintIntegralDigits<mode>(int_mantissa >> exp, out);
 1233|      0|  int_mantissa &= mask;
 1234|       |
 1235|      0|  size_t fractional_count = precision;
 1236|      0|  if (mode == FormatStyle::Precision) {
  ------------------
  |  Branch (1236:7): [Folded - Ignored]
  ------------------
 1237|      0|    if (digits_printed == 0) {
  ------------------
  |  Branch (1237:9): [True: 0, False: 0]
  ------------------
 1238|       |      // Find the first non-zero digit, when in Precision mode.
 1239|      0|      *exp_out = 0;
 1240|      0|      if (int_mantissa) {
  ------------------
  |  Branch (1240:11): [True: 0, False: 0]
  ------------------
 1241|      0|        while (int_mantissa <= mask) {
  ------------------
  |  Branch (1241:16): [True: 0, False: 0]
  ------------------
 1242|      0|          int_mantissa *= 10;
 1243|      0|          --*exp_out;
 1244|      0|        }
 1245|      0|      }
 1246|      0|      out->push_front(static_cast<char>(int_mantissa >> exp) + '0');
 1247|      0|      out->push_back('.');
 1248|      0|      int_mantissa &= mask;
 1249|      0|    } else {
 1250|       |      // We already have a digit, and a '.'
 1251|      0|      *exp_out = static_cast<int>(digits_printed - 1);
 1252|      0|      if (fractional_count < digits_printed - 1) {
  ------------------
  |  Branch (1252:11): [True: 0, False: 0]
  ------------------
 1253|       |        // If we had enough digits, return right away.
 1254|       |        // The code below will try to round again otherwise.
 1255|      0|        RemoveExtraPrecision(digits_printed - 1 - fractional_count,
 1256|      0|                             int_mantissa != 0, out, exp_out);
 1257|      0|        return true;
 1258|      0|      }
 1259|      0|      fractional_count -= digits_printed - 1;
 1260|      0|    }
 1261|      0|  }
 1262|       |
 1263|      0|  auto get_next_digit = [&] {
 1264|      0|    int_mantissa *= 10;
 1265|      0|    char digit = static_cast<char>(int_mantissa >> exp);
 1266|      0|    int_mantissa &= mask;
 1267|      0|    return digit;
 1268|      0|  };
 1269|       |
 1270|       |  // Print fractional_count more digits, if available.
 1271|      0|  for (; fractional_count > 0; --fractional_count) {
  ------------------
  |  Branch (1271:10): [True: 0, False: 0]
  ------------------
 1272|      0|    out->push_back(get_next_digit() + '0');
 1273|      0|  }
 1274|       |
 1275|      0|  char next_digit = get_next_digit();
 1276|      0|  if (next_digit > 5 ||
  ------------------
  |  Branch (1276:7): [True: 0, False: 0]
  ------------------
 1277|      0|      (next_digit == 5 && (int_mantissa || out->last_digit() % 2 == 1))) {
  ------------------
  |  Branch (1277:8): [True: 0, False: 0]
  |  Branch (1277:28): [True: 0, False: 0]
  |  Branch (1277:44): [True: 0, False: 0]
  ------------------
 1278|      0|    RoundUp<mode>(out, exp_out);
 1279|      0|  }
 1280|       |
 1281|      0|  return true;
 1282|      0|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_118FallbackToSnprintfIdEEbT_RKNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  963|  1.27k|                        FormatSinkImpl *sink) {
  964|  1.27k|  int w = conv.width() >= 0 ? conv.width() : 0;
  ------------------
  |  Branch (964:11): [True: 0, False: 1.27k]
  ------------------
  965|  1.27k|  int p = conv.precision() >= 0 ? conv.precision() : -1;
  ------------------
  |  Branch (965:11): [True: 0, False: 1.27k]
  ------------------
  966|  1.27k|  char fmt[32];
  967|  1.27k|  {
  968|  1.27k|    char *fp = fmt;
  969|  1.27k|    *fp++ = '%';
  970|  1.27k|    fp = CopyStringTo(FormatConversionSpecImplFriend::FlagsToString(conv), fp);
  971|  1.27k|    fp = CopyStringTo("*.*", fp);
  972|  1.27k|    if (std::is_same<long double, Float>()) {
  ------------------
  |  Branch (972:9): [Folded - Ignored]
  ------------------
  973|      0|      *fp++ = 'L';
  974|      0|    }
  975|  1.27k|    *fp++ = FormatConversionCharToChar(conv.conversion_char());
  976|  1.27k|    *fp = 0;
  977|  1.27k|    assert(fp < fmt + sizeof(fmt));
  978|  1.27k|  }
  979|  1.27k|  std::string space(512, '\0');
  980|  1.27k|  absl::string_view result;
  981|  1.27k|  while (true) {
  ------------------
  |  Branch (981:10): [Folded - Ignored]
  ------------------
  982|  1.27k|    int n = snprintf(&space[0], space.size(), fmt, w, p, v);
  983|  1.27k|    if (n < 0) return false;
  ------------------
  |  Branch (983:9): [True: 0, False: 1.27k]
  ------------------
  984|  1.27k|    if (static_cast<size_t>(n) < space.size()) {
  ------------------
  |  Branch (984:9): [True: 1.27k, False: 0]
  ------------------
  985|  1.27k|      result = absl::string_view(space.data(), static_cast<size_t>(n));
  986|  1.27k|      break;
  987|  1.27k|    }
  988|      0|    space.resize(static_cast<size_t>(n) + 1);
  989|      0|  }
  990|  1.27k|  sink->Append(result);
  991|  1.27k|  return true;
  992|  1.27k|}

_ZN4absl19str_format_internal15AbslFormatFlushEPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11string_viewE:
   71|  5.17k|inline void AbslFormatFlush(std::string* out, string_view s) {
   72|  5.17k|  out->append(s.data(), s.size());
   73|  5.17k|}
_ZN4absl19str_format_internal11InvokeFlushINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEDTcl15AbslFormatFlushfp_fp0_EEPT_NS_11string_viewE:
   89|  5.17k|auto InvokeFlush(T* out, string_view s) -> decltype(AbslFormatFlush(out, s)) {
   90|  5.17k|  AbslFormatFlush(out, s);
   91|  5.17k|}

bind.cc:_ZN4absl19str_format_internal17ParseFormatStringINS0_12_GLOBAL__N_117ConverterConsumerINS2_16DefaultConverterEEEEEbNS_11string_viewET_:
   57|  5.17k|bool ParseFormatString(string_view src, Consumer consumer) {
   58|  5.17k|  int next_arg = 0;
   59|  5.17k|  const char* p = src.data();
   60|  5.17k|  const char* const end = p + src.size();
   61|  10.3k|  while (p != end) {
  ------------------
  |  Branch (61:10): [True: 5.17k, False: 5.17k]
  ------------------
   62|  5.17k|    const char* percent =
   63|  5.17k|        static_cast<const char*>(memchr(p, '%', static_cast<size_t>(end - p)));
   64|  5.17k|    if (!percent) {
  ------------------
  |  Branch (64:9): [True: 0, False: 5.17k]
  ------------------
   65|       |      // We found the last substring.
   66|      0|      return consumer.Append(string_view(p, static_cast<size_t>(end - p)));
   67|      0|    }
   68|       |    // We found a percent, so push the text run then process the percent.
   69|  5.17k|    if (ABSL_PREDICT_FALSE(!consumer.Append(
  ------------------
  |  |  178|  5.17k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 5.17k]
  |  |  |  Branch (178:49): [Folded - Ignored]
  |  |  |  Branch (178:58): [True: 0, False: 5.17k]
  |  |  ------------------
  ------------------
   70|  5.17k|            string_view(p, static_cast<size_t>(percent - p))))) {
   71|      0|      return false;
   72|      0|    }
   73|  5.17k|    if (ABSL_PREDICT_FALSE(percent + 1 >= end)) return false;
  ------------------
  |  |  178|  5.17k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 5.17k]
  |  |  |  Branch (178:49): [Folded - Ignored]
  |  |  |  Branch (178:58): [True: 0, False: 5.17k]
  |  |  ------------------
  ------------------
   74|       |
   75|  5.17k|    auto tag = GetTagForChar(percent[1]);
   76|  5.17k|    if (tag.is_conv()) {
  ------------------
  |  Branch (76:9): [True: 5.17k, False: 0]
  ------------------
   77|  5.17k|      if (ABSL_PREDICT_FALSE(next_arg < 0)) {
  ------------------
  |  |  178|  5.17k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 5.17k]
  |  |  |  Branch (178:49): [Folded - Ignored]
  |  |  |  Branch (178:58): [True: 0, False: 5.17k]
  |  |  ------------------
  ------------------
   78|       |        // This indicates an error in the format string.
   79|       |        // The only way to get `next_arg < 0` here is to have a positional
   80|       |        // argument first which sets next_arg to -1 and then a non-positional
   81|       |        // argument.
   82|      0|        return false;
   83|      0|      }
   84|  5.17k|      p = percent + 2;
   85|       |
   86|       |      // Keep this case separate from the one below.
   87|       |      // ConvertOne is more efficient when the compiler can see that the `basic`
   88|       |      // flag is set.
   89|  5.17k|      UnboundConversion conv;
   90|  5.17k|      conv.conv = tag.as_conv();
   91|  5.17k|      conv.arg_position = ++next_arg;
   92|  5.17k|      if (ABSL_PREDICT_FALSE(
  ------------------
  |  |  178|  5.17k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 5.17k]
  |  |  |  Branch (178:49): [Folded - Ignored]
  |  |  |  Branch (178:58): [True: 0, False: 5.17k]
  |  |  ------------------
  ------------------
   93|  5.17k|              !consumer.ConvertOne(conv, string_view(percent + 1, 1)))) {
   94|      0|        return false;
   95|      0|      }
   96|  5.17k|    } else if (percent[1] != '%') {
  ------------------
  |  Branch (96:16): [True: 0, False: 0]
  ------------------
   97|      0|      UnboundConversion conv;
   98|      0|      p = ConsumeUnboundConversionNoInline(percent + 1, end, &conv, &next_arg);
   99|      0|      if (ABSL_PREDICT_FALSE(p == nullptr)) return false;
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded - Ignored]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  100|      0|      if (ABSL_PREDICT_FALSE(!consumer.ConvertOne(
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded - Ignored]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  101|      0|              conv, string_view(percent + 1,
  102|      0|                                static_cast<size_t>(p - (percent + 1)))))) {
  103|      0|        return false;
  104|      0|      }
  105|      0|    } else {
  106|      0|      if (ABSL_PREDICT_FALSE(!consumer.Append("%"))) return false;
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded - Ignored]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  107|      0|      p = percent + 2;
  108|      0|      continue;
  109|      0|    }
  110|  5.17k|  }
  111|  5.17k|  return true;
  112|  5.17k|}

_ZN4absl16strings_internal9JoinRangeINSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEEEES9_RKT_NS_11string_viewE:
  307|  1.29k|std::string JoinRange(const Range& range, absl::string_view separator) {
  308|  1.29k|  using std::begin;
  309|  1.29k|  using std::end;
  310|  1.29k|  return JoinRange(begin(range), end(range), separator);
  311|  1.29k|}
_ZN4absl16strings_internal9JoinRangeINSt3__111__wrap_iterIPKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEES9_T_SD_NS_11string_viewE:
  291|  1.29k|                      absl::string_view separator) {
  292|       |  // No formatter was explicitly given, so a default must be chosen.
  293|  1.29k|  typedef typename std::iterator_traits<Iterator>::value_type ValueType;
  294|  1.29k|  typedef typename DefaultFormatter<ValueType>::Type Formatter;
  295|  1.29k|  return JoinAlgorithm(first, last, separator, Formatter());
  296|  1.29k|}
_ZN4absl16strings_internal13JoinAlgorithmINSt3__111__wrap_iterIPKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEvEES9_T_SD_NS_11string_viewENS0_11NoFormatterE:
  228|  1.29k|                          NoFormatter) {
  229|  1.29k|  std::string result;
  230|  1.29k|  if (start != end) {
  ------------------
  |  Branch (230:7): [True: 1.29k, False: 0]
  ------------------
  231|       |    // Sums size
  232|  1.29k|    auto&& start_value = *start;
  233|  1.29k|    size_t result_size = start_value.size();
  234|  6.97M|    for (Iterator it = start; ++it != end;) {
  ------------------
  |  Branch (234:31): [True: 6.96M, False: 1.29k]
  ------------------
  235|  6.96M|      result_size += s.size();
  236|  6.96M|      result_size += (*it).size();
  237|  6.96M|    }
  238|       |
  239|  1.29k|    if (result_size > 0) {
  ------------------
  |  Branch (239:9): [True: 1.29k, False: 0]
  ------------------
  240|  1.29k|      STLStringResizeUninitialized(&result, result_size);
  241|       |
  242|       |      // Joins strings
  243|  1.29k|      char* result_buf = &*result.begin();
  244|       |
  245|  1.29k|      memcpy(result_buf, start_value.data(), start_value.size());
  246|  1.29k|      result_buf += start_value.size();
  247|  6.97M|      for (Iterator it = start; ++it != end;) {
  ------------------
  |  Branch (247:33): [True: 6.96M, False: 1.29k]
  ------------------
  248|  6.96M|        memcpy(result_buf, s.data(), s.size());
  249|  6.96M|        result_buf += s.size();
  250|  6.96M|        auto&& value = *it;
  251|  6.96M|        memcpy(result_buf, value.data(), value.size());
  252|  6.96M|        result_buf += value.size();
  253|  6.96M|      }
  254|  1.29k|    }
  255|  1.29k|  }
  256|       |
  257|  1.29k|  return result;
  258|  1.29k|}

_ZN4absl16strings_internal23ConvertibleToStringViewC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
   65|  1.29k|      : value_(s) {}
_ZNK4absl16strings_internal23ConvertibleToStringView5valueEv:
   71|  1.29k|  absl::string_view value() const { return value_; }
_ZN4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEEC2ES4_S2_S3_:
  288|  1.29k|        predicate_(std::move(p)) {}
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEEcvT_INSt3__16vectorINS8_12basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEENSD_ISF_EEEELDn0EEEv:
  319|  1.29k|  operator Container() const {
  320|  1.29k|    return ConvertToContainer<Container, typename Container::value_type,
  321|  1.29k|                              HasMappedType<Container>::value>()(*this);
  322|  1.29k|  }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEE18ConvertToContainerINSt3__16vectorINS7_12basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEENSC_ISE_EEEESE_Lb0EEclERKS5_:
  419|  1.29k|    std::vector<std::string, A> operator()(const Splitter& splitter) const {
  420|  1.29k|      const std::vector<absl::string_view> v = splitter;
  421|  1.29k|      return std::vector<std::string, A>(v.begin(), v.end());
  422|  1.29k|    }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEEcvT_INSt3__16vectorIS4_NS8_9allocatorIS4_EEEELDn0EEEv:
  319|  1.29k|  operator Container() const {
  320|  1.29k|    return ConvertToContainer<Container, typename Container::value_type,
  321|  1.29k|                              HasMappedType<Container>::value>()(*this);
  322|  1.29k|  }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEE18ConvertToContainerINSt3__16vectorIS4_NS7_9allocatorIS4_EEEES4_Lb0EEclERKS5_:
  388|  1.29k|        const Splitter& splitter) const {
  389|  1.29k|      struct raw_view {
  390|  1.29k|        const char* data;
  391|  1.29k|        size_t size;
  392|  1.29k|        operator absl::string_view() const {  // NOLINT(runtime/explicit)
  393|  1.29k|          return {data, size};
  394|  1.29k|        }
  395|  1.29k|      };
  396|  1.29k|      std::vector<absl::string_view, A> v;
  397|  1.29k|      std::array<raw_view, 16> ar;
  398|   437k|      for (auto it = splitter.begin(); !it.at_end();) {
  ------------------
  |  Branch (398:40): [True: 436k, False: 1.29k]
  ------------------
  399|   436k|        size_t index = 0;
  400|  6.97M|        do {
  401|  6.97M|          ar[index].data = it->data();
  402|  6.97M|          ar[index].size = it->size();
  403|  6.97M|          ++it;
  404|  6.97M|        } while (++index != ar.size() && !it.at_end());
  ------------------
  |  Branch (404:18): [True: 6.53M, False: 435k]
  |  Branch (404:42): [True: 6.53M, False: 1.26k]
  ------------------
  405|   436k|        v.insert(v.end(), ar.begin(), ar.begin() + index);
  406|   436k|      }
  407|  1.29k|      return v;
  408|  1.29k|    }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEE5beginEv:
  297|  1.29k|  const_iterator begin() const { return {const_iterator::kInitState, this}; }
_ZN4absl16strings_internal13SplitIteratorINS0_8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEEEEC2ENS7_5StateEPKS6_:
   98|  1.29k|        predicate_(splitter->predicate()) {
   99|       |    // Hack to maintain backward compatibility. This one block makes it so an
  100|       |    // empty absl::string_view whose .data() happens to be nullptr behaves
  101|       |    // *differently* from an otherwise empty absl::string_view whose .data() is
  102|       |    // not nullptr. This is an undesirable difference in general, but this
  103|       |    // behavior is maintained to avoid breaking existing code that happens to
  104|       |    // depend on this old behavior/bug. Perhaps it will be fixed one day. The
  105|       |    // difference in behavior is as follows:
  106|       |    //   Split(absl::string_view(""), '-');  // {""}
  107|       |    //   Split(absl::string_view(), '-');    // {}
  108|  1.29k|    if (splitter_->text().data() == nullptr) {
  ------------------
  |  Branch (108:9): [True: 0, False: 1.29k]
  ------------------
  109|      0|      state_ = kEndState;
  110|      0|      pos_ = splitter_->text().size();
  111|      0|      return;
  112|      0|    }
  113|       |
  114|  1.29k|    if (state_ == kEndState) {
  ------------------
  |  Branch (114:9): [True: 0, False: 1.29k]
  ------------------
  115|      0|      pos_ = splitter_->text().size();
  116|  1.29k|    } else {
  117|  1.29k|      ++(*this);
  118|  1.29k|    }
  119|  1.29k|  }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEE9delimiterEv:
  291|  1.29k|  const Delimiter& delimiter() const { return delimiter_; }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEE9predicateEv:
  292|  1.29k|  const Predicate& predicate() const { return predicate_; }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEE4textEv:
  290|  6.97M|  absl::string_view text() const { return text_; }
_ZNK4absl16strings_internal13SplitIteratorINS0_8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEEEE6at_endEv:
  121|  6.97M|  bool at_end() const { return state_ == kEndState; }
_ZNK4absl16strings_internal13SplitIteratorINS0_8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEEEEptEv:
  124|  13.9M|  pointer operator->() const { return &curr_; }
_ZN4absl16strings_internal13SplitIteratorINS0_8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEEEEppEv:
  126|  6.97M|  SplitIterator& operator++() {
  127|  6.97M|    do {
  128|  6.97M|      if (state_ == kLastState) {
  ------------------
  |  Branch (128:11): [True: 1.29k, False: 6.97M]
  ------------------
  129|  1.29k|        state_ = kEndState;
  130|  1.29k|        return *this;
  131|  1.29k|      }
  132|  6.97M|      const absl::string_view text = splitter_->text();
  133|  6.97M|      const absl::string_view d = delimiter_.Find(text, pos_);
  134|  6.97M|      if (d.data() == text.data() + text.size()) state_ = kLastState;
  ------------------
  |  Branch (134:11): [True: 1.29k, False: 6.96M]
  ------------------
  135|  6.97M|      curr_ = text.substr(pos_,
  136|  6.97M|                          static_cast<size_t>(d.data() - (text.data() + pos_)));
  137|  6.97M|      pos_ += curr_.size() + d.size();
  138|  6.97M|    } while (!predicate_(curr_));
  ------------------
  |  Branch (138:14): [True: 0, False: 6.97M]
  ------------------
  139|  6.97M|    return *this;
  140|  6.97M|  }
_ZZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEE18ConvertToContainerINSt3__16vectorIS4_NS7_9allocatorIS4_EEEES4_Lb0EEclERKS5_ENK8raw_viewcvS4_Ev:
  392|  6.97M|        operator absl::string_view() const {  // NOLINT(runtime/explicit)
  393|  6.97M|          return {data, size};
  394|  6.97M|        }

_ZN4absl16EqualsIgnoreCaseENS_11string_viewES0_:
   32|  12.0k|                      absl::string_view piece2) noexcept {
   33|  12.0k|  return (piece1.size() == piece2.size() &&
  ------------------
  |  Branch (33:11): [True: 7.22k, False: 4.81k]
  ------------------
   34|  12.0k|          0 == absl::strings_internal::memcasecmp(piece1.data(), piece2.data(),
  ------------------
  |  Branch (34:11): [True: 1.29k, False: 5.93k]
  ------------------
   35|  7.22k|                                                  piece1.size()));
   36|       |  // memcasecmp uses absl::ascii_tolower().
   37|  12.0k|}

_ZN4absl10SimpleAtofENS_11string_viewEPf:
   52|  1.29k|bool SimpleAtof(absl::string_view str, absl::Nonnull<float*> out) {
   53|  1.29k|  *out = 0.0;
   54|  1.29k|  str = StripAsciiWhitespace(str);
   55|       |  // std::from_chars doesn't accept an initial +, but SimpleAtof does, so if one
   56|       |  // is present, skip it, while avoiding accepting "+-0" as valid.
   57|  1.29k|  if (!str.empty() && str[0] == '+') {
  ------------------
  |  Branch (57:7): [True: 1.29k, False: 0]
  |  Branch (57:23): [True: 0, False: 1.29k]
  ------------------
   58|      0|    str.remove_prefix(1);
   59|      0|    if (!str.empty() && str[0] == '-') {
  ------------------
  |  Branch (59:9): [True: 0, False: 0]
  |  Branch (59:25): [True: 0, False: 0]
  ------------------
   60|      0|      return false;
   61|      0|    }
   62|      0|  }
   63|  1.29k|  auto result = absl::from_chars(str.data(), str.data() + str.size(), *out);
   64|  1.29k|  if (result.ec == std::errc::invalid_argument) {
  ------------------
  |  Branch (64:7): [True: 0, False: 1.29k]
  ------------------
   65|      0|    return false;
   66|      0|  }
   67|  1.29k|  if (result.ptr != str.data() + str.size()) {
  ------------------
  |  Branch (67:7): [True: 0, False: 1.29k]
  ------------------
   68|       |    // not all non-whitespace characters consumed
   69|      0|    return false;
   70|      0|  }
   71|       |  // from_chars() with DR 3081's current wording will return max() on
   72|       |  // overflow.  SimpleAtof returns infinity instead.
   73|  1.29k|  if (result.ec == std::errc::result_out_of_range) {
  ------------------
  |  Branch (73:7): [True: 0, False: 1.29k]
  ------------------
   74|      0|    if (*out > 1.0) {
  ------------------
  |  Branch (74:9): [True: 0, False: 0]
  ------------------
   75|      0|      *out = std::numeric_limits<float>::infinity();
   76|      0|    } else if (*out < -1.0) {
  ------------------
  |  Branch (76:16): [True: 0, False: 0]
  ------------------
   77|      0|      *out = -std::numeric_limits<float>::infinity();
   78|      0|    }
   79|      0|  }
   80|  1.29k|  return true;
   81|  1.29k|}
_ZN4absl10SimpleAtodENS_11string_viewEPd:
   83|  1.29k|bool SimpleAtod(absl::string_view str, absl::Nonnull<double*> out) {
   84|  1.29k|  *out = 0.0;
   85|  1.29k|  str = StripAsciiWhitespace(str);
   86|       |  // std::from_chars doesn't accept an initial +, but SimpleAtod does, so if one
   87|       |  // is present, skip it, while avoiding accepting "+-0" as valid.
   88|  1.29k|  if (!str.empty() && str[0] == '+') {
  ------------------
  |  Branch (88:7): [True: 1.29k, False: 0]
  |  Branch (88:23): [True: 0, False: 1.29k]
  ------------------
   89|      0|    str.remove_prefix(1);
   90|      0|    if (!str.empty() && str[0] == '-') {
  ------------------
  |  Branch (90:9): [True: 0, False: 0]
  |  Branch (90:25): [True: 0, False: 0]
  ------------------
   91|      0|      return false;
   92|      0|    }
   93|      0|  }
   94|  1.29k|  auto result = absl::from_chars(str.data(), str.data() + str.size(), *out);
   95|  1.29k|  if (result.ec == std::errc::invalid_argument) {
  ------------------
  |  Branch (95:7): [True: 0, False: 1.29k]
  ------------------
   96|      0|    return false;
   97|      0|  }
   98|  1.29k|  if (result.ptr != str.data() + str.size()) {
  ------------------
  |  Branch (98:7): [True: 0, False: 1.29k]
  ------------------
   99|       |    // not all non-whitespace characters consumed
  100|      0|    return false;
  101|      0|  }
  102|       |  // from_chars() with DR 3081's current wording will return max() on
  103|       |  // overflow.  SimpleAtod returns infinity instead.
  104|  1.29k|  if (result.ec == std::errc::result_out_of_range) {
  ------------------
  |  Branch (104:7): [True: 0, False: 1.29k]
  ------------------
  105|      0|    if (*out > 1.0) {
  ------------------
  |  Branch (105:9): [True: 0, False: 0]
  ------------------
  106|      0|      *out = std::numeric_limits<double>::infinity();
  107|      0|    } else if (*out < -1.0) {
  ------------------
  |  Branch (107:16): [True: 0, False: 0]
  ------------------
  108|      0|      *out = -std::numeric_limits<double>::infinity();
  109|      0|    }
  110|      0|  }
  111|  1.29k|  return true;
  112|  1.29k|}
_ZN4absl10SimpleAtobENS_11string_viewEPb:
  114|  1.29k|bool SimpleAtob(absl::string_view str, absl::Nonnull<bool*> out) {
  115|  1.29k|  ABSL_RAW_CHECK(out != nullptr, "Output pointer must not be nullptr.");
  ------------------
  |  |   60|  1.29k|  do {                                                                 \
  |  |   61|  1.29k|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  178|  1.29k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (178:31): [True: 0, False: 1.29k]
  |  |  |  |  |  Branch (178:49): [Folded - Ignored]
  |  |  |  |  |  Branch (178:58): [True: 0, False: 1.29k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   62|      0|      ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
  |  |  ------------------
  |  |  |  |   45|      0|  do {                                                                         \
  |  |  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|  1.29k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  116|  1.29k|  if (EqualsIgnoreCase(str, "true") || EqualsIgnoreCase(str, "t") ||
  ------------------
  |  Branch (116:7): [True: 0, False: 1.29k]
  |  Branch (116:7): [True: 180, False: 1.11k]
  |  Branch (116:40): [True: 0, False: 1.29k]
  ------------------
  117|  1.29k|      EqualsIgnoreCase(str, "yes") || EqualsIgnoreCase(str, "y") ||
  ------------------
  |  Branch (117:7): [True: 0, False: 1.29k]
  |  Branch (117:39): [True: 0, False: 1.29k]
  ------------------
  118|  1.29k|      EqualsIgnoreCase(str, "1")) {
  ------------------
  |  Branch (118:7): [True: 180, False: 1.11k]
  ------------------
  119|    180|    *out = true;
  120|    180|    return true;
  121|    180|  }
  122|  1.11k|  if (EqualsIgnoreCase(str, "false") || EqualsIgnoreCase(str, "f") ||
  ------------------
  |  Branch (122:7): [True: 0, False: 1.11k]
  |  Branch (122:7): [True: 1.11k, False: 0]
  |  Branch (122:41): [True: 0, False: 1.11k]
  ------------------
  123|  1.11k|      EqualsIgnoreCase(str, "no") || EqualsIgnoreCase(str, "n") ||
  ------------------
  |  Branch (123:7): [True: 0, False: 1.11k]
  |  Branch (123:38): [True: 0, False: 1.11k]
  ------------------
  124|  1.11k|      EqualsIgnoreCase(str, "0")) {
  ------------------
  |  Branch (124:7): [True: 1.11k, False: 0]
  ------------------
  125|  1.11k|    *out = false;
  126|  1.11k|    return true;
  127|  1.11k|  }
  128|      0|  return false;
  129|  1.11k|}
_ZN4absl16numbers_internal12PutTwoDigitsEjPc:
  466|  10.1k|void numbers_internal::PutTwoDigits(uint32_t i, absl::Nonnull<char*> buf) {
  467|  10.1k|  little_endian::Store16(
  468|  10.1k|      buf, static_cast<uint16_t>(PrepareTwoDigits(i) + kTwoZeroBytes));
  469|  10.1k|}
_ZN4absl16numbers_internal15FastIntToBufferEiPc:
  481|  5.17k|    int32_t i, absl::Nonnull<char*> buffer) {
  482|  5.17k|  buffer += static_cast<int>(i < 0);
  483|  5.17k|  uint32_t digits = absl::numbers_internal::Base10Digits(
  484|  5.17k|      absl::numbers_internal::UnsignedAbsoluteValue(i));
  485|  5.17k|  buffer += digits;
  486|  5.17k|  *buffer = '\0';  // We're going backward, so store this first
  487|  5.17k|  FastIntToBufferBackward(i, buffer, digits);
  488|  5.17k|  return buffer;
  489|  5.17k|}
_ZN4absl16numbers_internal23FastIntToBufferBackwardEiPcj:
  517|  5.17k|    int32_t i, absl::Nonnull<char*> buffer_end, uint32_t exact_digit_count) {
  518|  5.17k|  return DoFastIntToBufferBackward(i, buffer_end, exact_digit_count);
  519|  5.17k|}
_ZN4absl16numbers_internal17SixDigitsToBufferEdPc:
  773|  2.58k|                                           absl::Nonnull<char*> const buffer) {
  774|  2.58k|  static_assert(std::numeric_limits<float>::is_iec559,
  775|  2.58k|                "IEEE-754/IEC-559 support only");
  776|       |
  777|  2.58k|  char* out = buffer;  // we write data to out, incrementing as we go, but
  778|       |                       // FloatToBuffer always returns the address of the buffer
  779|       |                       // passed in.
  780|       |
  781|  2.58k|  if (std::isnan(d)) {
  ------------------
  |  Branch (781:7): [True: 0, False: 2.58k]
  ------------------
  782|      0|    strcpy(out, "nan");  // NOLINT(runtime/printf)
  783|      0|    return 3;
  784|      0|  }
  785|  2.58k|  if (d == 0) {  // +0 and -0 are handled here
  ------------------
  |  Branch (785:7): [True: 40, False: 2.54k]
  ------------------
  786|     40|    if (std::signbit(d)) *out++ = '-';
  ------------------
  |  Branch (786:9): [True: 0, False: 40]
  ------------------
  787|     40|    *out++ = '0';
  788|     40|    *out = 0;
  789|     40|    return static_cast<size_t>(out - buffer);
  790|     40|  }
  791|  2.54k|  if (d < 0) {
  ------------------
  |  Branch (791:7): [True: 1.61k, False: 932]
  ------------------
  792|  1.61k|    *out++ = '-';
  793|  1.61k|    d = -d;
  794|  1.61k|  }
  795|  2.54k|  if (d > std::numeric_limits<double>::max()) {
  ------------------
  |  Branch (795:7): [True: 0, False: 2.54k]
  ------------------
  796|      0|    strcpy(out, "inf");  // NOLINT(runtime/printf)
  797|      0|    return static_cast<size_t>(out + 3 - buffer);
  798|      0|  }
  799|       |
  800|  2.54k|  auto exp_dig = SplitToSix(d);
  801|  2.54k|  int exp = exp_dig.exponent;
  802|  2.54k|  const char* digits = exp_dig.digits;
  803|  2.54k|  out[0] = '0';
  804|  2.54k|  out[1] = '.';
  805|  2.54k|  switch (exp) {
  ------------------
  |  Branch (805:11): [True: 2.54k, False: 0]
  ------------------
  806|      0|    case 5:
  ------------------
  |  Branch (806:5): [True: 0, False: 2.54k]
  ------------------
  807|      0|      memcpy(out, &digits[0], 6), out += 6;
  808|      0|      *out = 0;
  809|      0|      return static_cast<size_t>(out - buffer);
  810|      0|    case 4:
  ------------------
  |  Branch (810:5): [True: 0, False: 2.54k]
  ------------------
  811|      0|      memcpy(out, &digits[0], 5), out += 5;
  812|      0|      if (digits[5] != '0') {
  ------------------
  |  Branch (812:11): [True: 0, False: 0]
  ------------------
  813|      0|        *out++ = '.';
  814|      0|        *out++ = digits[5];
  815|      0|      }
  816|      0|      *out = 0;
  817|      0|      return static_cast<size_t>(out - buffer);
  818|      0|    case 3:
  ------------------
  |  Branch (818:5): [True: 0, False: 2.54k]
  ------------------
  819|      0|      memcpy(out, &digits[0], 4), out += 4;
  820|      0|      if ((digits[5] | digits[4]) != '0') {
  ------------------
  |  Branch (820:11): [True: 0, False: 0]
  ------------------
  821|      0|        *out++ = '.';
  822|      0|        *out++ = digits[4];
  823|      0|        if (digits[5] != '0') *out++ = digits[5];
  ------------------
  |  Branch (823:13): [True: 0, False: 0]
  ------------------
  824|      0|      }
  825|      0|      *out = 0;
  826|      0|      return static_cast<size_t>(out - buffer);
  827|      0|    case 2:
  ------------------
  |  Branch (827:5): [True: 0, False: 2.54k]
  ------------------
  828|      0|      memcpy(out, &digits[0], 3), out += 3;
  829|      0|      *out++ = '.';
  830|      0|      memcpy(out, &digits[3], 3);
  831|      0|      out += 3;
  832|      0|      while (out[-1] == '0') --out;
  ------------------
  |  Branch (832:14): [True: 0, False: 0]
  ------------------
  833|      0|      if (out[-1] == '.') --out;
  ------------------
  |  Branch (833:11): [True: 0, False: 0]
  ------------------
  834|      0|      *out = 0;
  835|      0|      return static_cast<size_t>(out - buffer);
  836|      0|    case 1:
  ------------------
  |  Branch (836:5): [True: 0, False: 2.54k]
  ------------------
  837|      0|      memcpy(out, &digits[0], 2), out += 2;
  838|      0|      *out++ = '.';
  839|      0|      memcpy(out, &digits[2], 4);
  840|      0|      out += 4;
  841|      0|      while (out[-1] == '0') --out;
  ------------------
  |  Branch (841:14): [True: 0, False: 0]
  ------------------
  842|      0|      if (out[-1] == '.') --out;
  ------------------
  |  Branch (842:11): [True: 0, False: 0]
  ------------------
  843|      0|      *out = 0;
  844|      0|      return static_cast<size_t>(out - buffer);
  845|      0|    case 0:
  ------------------
  |  Branch (845:5): [True: 0, False: 2.54k]
  ------------------
  846|      0|      memcpy(out, &digits[0], 1), out += 1;
  847|      0|      *out++ = '.';
  848|      0|      memcpy(out, &digits[1], 5);
  849|      0|      out += 5;
  850|      0|      while (out[-1] == '0') --out;
  ------------------
  |  Branch (850:14): [True: 0, False: 0]
  ------------------
  851|      0|      if (out[-1] == '.') --out;
  ------------------
  |  Branch (851:11): [True: 0, False: 0]
  ------------------
  852|      0|      *out = 0;
  853|      0|      return static_cast<size_t>(out - buffer);
  854|      0|    case -4:
  ------------------
  |  Branch (854:5): [True: 0, False: 2.54k]
  ------------------
  855|      0|      out[2] = '0';
  856|      0|      ++out;
  857|      0|      ABSL_FALLTHROUGH_INTENDED;
  ------------------
  |  |  644|      0|#define ABSL_FALLTHROUGH_INTENDED [[fallthrough]]
  ------------------
  858|      0|    case -3:
  ------------------
  |  Branch (858:5): [True: 0, False: 2.54k]
  ------------------
  859|      0|      out[2] = '0';
  860|      0|      ++out;
  861|      0|      ABSL_FALLTHROUGH_INTENDED;
  ------------------
  |  |  644|      0|#define ABSL_FALLTHROUGH_INTENDED [[fallthrough]]
  ------------------
  862|      0|    case -2:
  ------------------
  |  Branch (862:5): [True: 0, False: 2.54k]
  ------------------
  863|      0|      out[2] = '0';
  864|      0|      ++out;
  865|      0|      ABSL_FALLTHROUGH_INTENDED;
  ------------------
  |  |  644|      0|#define ABSL_FALLTHROUGH_INTENDED [[fallthrough]]
  ------------------
  866|      0|    case -1:
  ------------------
  |  Branch (866:5): [True: 0, False: 2.54k]
  ------------------
  867|      0|      out += 2;
  868|      0|      memcpy(out, &digits[0], 6);
  869|      0|      out += 6;
  870|      0|      while (out[-1] == '0') --out;
  ------------------
  |  Branch (870:14): [True: 0, False: 0]
  ------------------
  871|      0|      *out = 0;
  872|      0|      return static_cast<size_t>(out - buffer);
  873|  2.54k|  }
  874|  2.54k|  assert(exp < -4 || exp >= 6);
  875|  2.54k|  out[0] = digits[0];
  876|  2.54k|  assert(out[1] == '.');
  877|  2.54k|  out += 2;
  878|  2.54k|  memcpy(out, &digits[1], 5), out += 5;
  879|  3.55k|  while (out[-1] == '0') --out;
  ------------------
  |  Branch (879:10): [True: 1.01k, False: 2.54k]
  ------------------
  880|  2.54k|  if (out[-1] == '.') --out;
  ------------------
  |  Branch (880:7): [True: 135, False: 2.41k]
  ------------------
  881|  2.54k|  *out++ = 'e';
  882|  2.54k|  if (exp > 0) {
  ------------------
  |  Branch (882:7): [True: 2.54k, False: 0]
  ------------------
  883|  2.54k|    *out++ = '+';
  884|  2.54k|  } else {
  885|      0|    *out++ = '-';
  886|      0|    exp = -exp;
  887|      0|  }
  888|  2.54k|  if (exp > 99) {
  ------------------
  |  Branch (888:7): [True: 1.27k, False: 1.27k]
  ------------------
  889|  1.27k|    int dig1 = exp / 100;
  890|  1.27k|    exp -= dig1 * 100;
  891|  1.27k|    *out++ = '0' + static_cast<char>(dig1);
  892|  1.27k|  }
  893|  2.54k|  PutTwoDigits(static_cast<uint32_t>(exp), out);
  894|  2.54k|  out += 2;
  895|  2.54k|  *out = 0;
  896|  2.54k|  return static_cast<size_t>(out - buffer);
  897|  2.54k|}
_ZN4absl16numbers_internal17safe_strto32_baseENS_11string_viewEPii:
 1340|  1.29k|                       int base) {
 1341|  1.29k|  return safe_int_internal<int32_t>(text, value, base);
 1342|  1.29k|}
numbers.cc:_ZN4absl12_GLOBAL__N_116PrepareTwoDigitsEj:
  221|  10.1k|inline uint32_t PrepareTwoDigits(uint32_t i) {
  222|  10.1k|  return PrepareTwoDigitsImpl(i, false);
  223|  10.1k|}
numbers.cc:_ZN4absl12_GLOBAL__N_120PrepareTwoDigitsImplEjb:
  215|  10.1k|inline uint32_t PrepareTwoDigitsImpl(uint32_t i, bool reversed) {
  216|  10.1k|  assert(i < 100);
  217|  10.1k|  uint32_t div10 = (i * kDivisionBy10Mul) / kDivisionBy10Div;
  218|  10.1k|  uint32_t mod10 = i - 10u * div10;
  219|  10.1k|  return (div10 << (reversed ? 8 : 0)) + (mod10 << (reversed ? 0 : 8));
  ------------------
  |  Branch (219:21): [True: 0, False: 10.1k]
  |  Branch (219:53): [True: 0, False: 10.1k]
  ------------------
  220|  10.1k|}
numbers.cc:_ZN4abslL10SplitToSixEd:
  652|  2.54k|static ExpDigits SplitToSix(const double value) {
  653|  2.54k|  ExpDigits exp_dig;
  654|  2.54k|  int exp = 5;
  655|  2.54k|  double d = value;
  656|       |  // First step: calculate a close approximation of the output, where the
  657|       |  // value d will be between 100,000 and 999,999, representing the digits
  658|       |  // in the output ASCII array, and exp is the base-10 exponent.  It would be
  659|       |  // faster to use a table here, and to look up the base-2 exponent of value,
  660|       |  // however value is an IEEE-754 64-bit number, so the table would have 2,000
  661|       |  // entries, which is not cache-friendly.
  662|  2.54k|  if (d >= 999999.5) {
  ------------------
  |  Branch (662:7): [True: 2.54k, False: 0]
  ------------------
  663|  2.54k|    if (d >= 1e+261) exp += 256, d *= 1e-256;
  ------------------
  |  Branch (663:9): [True: 1.27k, False: 1.27k]
  ------------------
  664|  2.54k|    if (d >= 1e+133) exp += 128, d *= 1e-128;
  ------------------
  |  Branch (664:9): [True: 0, False: 2.54k]
  ------------------
  665|  2.54k|    if (d >= 1e+69) exp += 64, d *= 1e-64;
  ------------------
  |  Branch (665:9): [True: 0, False: 2.54k]
  ------------------
  666|  2.54k|    if (d >= 1e+37) exp += 32, d *= 1e-32;
  ------------------
  |  Branch (666:9): [True: 2.20k, False: 344]
  ------------------
  667|  2.54k|    if (d >= 1e+21) exp += 16, d *= 1e-16;
  ------------------
  |  Branch (667:9): [True: 344, False: 2.20k]
  ------------------
  668|  2.54k|    if (d >= 1e+13) exp += 8, d *= 1e-8;
  ------------------
  |  Branch (668:9): [True: 1.43k, False: 1.11k]
  ------------------
  669|  2.54k|    if (d >= 1e+9) exp += 4, d *= 1e-4;
  ------------------
  |  Branch (669:9): [True: 1.34k, False: 1.20k]
  ------------------
  670|  2.54k|    if (d >= 1e+7) exp += 2, d *= 1e-2;
  ------------------
  |  Branch (670:9): [True: 1.29k, False: 1.25k]
  ------------------
  671|  2.54k|    if (d >= 1e+6) exp += 1, d *= 1e-1;
  ------------------
  |  Branch (671:9): [True: 1.73k, False: 810]
  ------------------
  672|  2.54k|  } else {
  673|      0|    if (d < 1e-250) exp -= 256, d *= 1e256;
  ------------------
  |  Branch (673:9): [True: 0, False: 0]
  ------------------
  674|      0|    if (d < 1e-122) exp -= 128, d *= 1e128;
  ------------------
  |  Branch (674:9): [True: 0, False: 0]
  ------------------
  675|      0|    if (d < 1e-58) exp -= 64, d *= 1e64;
  ------------------
  |  Branch (675:9): [True: 0, False: 0]
  ------------------
  676|      0|    if (d < 1e-26) exp -= 32, d *= 1e32;
  ------------------
  |  Branch (676:9): [True: 0, False: 0]
  ------------------
  677|      0|    if (d < 1e-10) exp -= 16, d *= 1e16;
  ------------------
  |  Branch (677:9): [True: 0, False: 0]
  ------------------
  678|      0|    if (d < 1e-2) exp -= 8, d *= 1e8;
  ------------------
  |  Branch (678:9): [True: 0, False: 0]
  ------------------
  679|      0|    if (d < 1e+2) exp -= 4, d *= 1e4;
  ------------------
  |  Branch (679:9): [True: 0, False: 0]
  ------------------
  680|      0|    if (d < 1e+4) exp -= 2, d *= 1e2;
  ------------------
  |  Branch (680:9): [True: 0, False: 0]
  ------------------
  681|      0|    if (d < 1e+5) exp -= 1, d *= 1e1;
  ------------------
  |  Branch (681:9): [True: 0, False: 0]
  ------------------
  682|      0|  }
  683|       |  // At this point, d is in the range [99999.5..999999.5) and exp is in the
  684|       |  // range [-324..308]. Since we need to round d up, we want to add a half
  685|       |  // and truncate.
  686|       |  // However, the technique above may have lost some precision, due to its
  687|       |  // repeated multiplication by constants that each may be off by half a bit
  688|       |  // of precision.  This only matters if we're close to the edge though.
  689|       |  // Since we'd like to know if the fractional part of d is close to a half,
  690|       |  // we multiply it by 65536 and see if the fractional part is close to 32768.
  691|       |  // (The number doesn't have to be a power of two,but powers of two are faster)
  692|  2.54k|  uint64_t d64k = d * 65536;
  693|  2.54k|  uint32_t dddddd;  // A 6-digit decimal integer.
  694|  2.54k|  if ((d64k % 65536) == 32767 || (d64k % 65536) == 32768) {
  ------------------
  |  Branch (694:7): [True: 0, False: 2.54k]
  |  Branch (694:34): [True: 0, False: 2.54k]
  ------------------
  695|       |    // OK, it's fairly likely that precision was lost above, which is
  696|       |    // not a surprise given only 52 mantissa bits are available.  Therefore
  697|       |    // redo the calculation using 128-bit numbers.  (64 bits are not enough).
  698|       |
  699|       |    // Start out with digits rounded down; maybe add one below.
  700|      0|    dddddd = static_cast<uint32_t>(d64k / 65536);
  701|       |
  702|       |    // mantissa is a 64-bit integer representing M.mmm... * 2^63.  The actual
  703|       |    // value we're representing, of course, is M.mmm... * 2^exp2.
  704|      0|    int exp2;
  705|      0|    double m = std::frexp(value, &exp2);
  706|      0|    uint64_t mantissa = m * (32768.0 * 65536.0 * 65536.0 * 65536.0);
  707|       |    // std::frexp returns an m value in the range [0.5, 1.0), however we
  708|       |    // can't multiply it by 2^64 and convert to an integer because some FPUs
  709|       |    // throw an exception when converting an number higher than 2^63 into an
  710|       |    // integer - even an unsigned 64-bit integer!  Fortunately it doesn't matter
  711|       |    // since m only has 52 significant bits anyway.
  712|      0|    mantissa <<= 1;
  713|      0|    exp2 -= 64;  // not needed, but nice for debugging
  714|       |
  715|       |    // OK, we are here to compare:
  716|       |    //     (dddddd + 0.5) * 10^(exp-5)  vs.  mantissa * 2^exp2
  717|       |    // so we can round up dddddd if appropriate.  Those values span the full
  718|       |    // range of 600 orders of magnitude of IEE 64-bit floating-point.
  719|       |    // Fortunately, we already know they are very close, so we don't need to
  720|       |    // track the base-2 exponent of both sides.  This greatly simplifies the
  721|       |    // the math since the 2^exp2 calculation is unnecessary and the power-of-10
  722|       |    // calculation can become a power-of-5 instead.
  723|       |
  724|      0|    std::pair<uint64_t, uint64_t> edge, val;
  725|      0|    if (exp >= 6) {
  ------------------
  |  Branch (725:9): [True: 0, False: 0]
  ------------------
  726|       |      // Compare (dddddd + 0.5) * 5 ^ (exp - 5) to mantissa
  727|       |      // Since we're tossing powers of two, 2 * dddddd + 1 is the
  728|       |      // same as dddddd + 0.5
  729|      0|      edge = PowFive(2 * dddddd + 1, exp - 5);
  730|       |
  731|      0|      val.first = mantissa;
  732|      0|      val.second = 0;
  733|      0|    } else {
  734|       |      // We can't compare (dddddd + 0.5) * 5 ^ (exp - 5) to mantissa as we did
  735|       |      // above because (exp - 5) is negative.  So we compare (dddddd + 0.5) to
  736|       |      // mantissa * 5 ^ (5 - exp)
  737|      0|      edge = PowFive(2 * dddddd + 1, 0);
  738|       |
  739|      0|      val = PowFive(mantissa, 5 - exp);
  740|      0|    }
  741|       |    // printf("exp=%d %016lx %016lx vs %016lx %016lx\n", exp, val.first,
  742|       |    //        val.second, edge.first, edge.second);
  743|      0|    if (val > edge) {
  ------------------
  |  Branch (743:9): [True: 0, False: 0]
  ------------------
  744|      0|      dddddd++;
  745|      0|    } else if (val == edge) {
  ------------------
  |  Branch (745:16): [True: 0, False: 0]
  ------------------
  746|      0|      dddddd += (dddddd & 1);
  747|      0|    }
  748|  2.54k|  } else {
  749|       |    // Here, we are not close to the edge.
  750|  2.54k|    dddddd = static_cast<uint32_t>((d64k + 32768) / 65536);
  751|  2.54k|  }
  752|  2.54k|  if (dddddd == 1000000) {
  ------------------
  |  Branch (752:7): [True: 41, False: 2.50k]
  ------------------
  753|     41|    dddddd = 100000;
  754|     41|    exp += 1;
  755|     41|  }
  756|  2.54k|  exp_dig.exponent = exp;
  757|       |
  758|  2.54k|  uint32_t two_digits = dddddd / 10000;
  759|  2.54k|  dddddd -= two_digits * 10000;
  760|  2.54k|  numbers_internal::PutTwoDigits(two_digits, &exp_dig.digits[0]);
  761|       |
  762|  2.54k|  two_digits = dddddd / 100;
  763|  2.54k|  dddddd -= two_digits * 100;
  764|  2.54k|  numbers_internal::PutTwoDigits(two_digits, &exp_dig.digits[2]);
  765|       |
  766|  2.54k|  numbers_internal::PutTwoDigits(dddddd, &exp_dig.digits[4]);
  767|  2.54k|  return exp_dig;
  768|  2.54k|}
numbers.cc:_ZN4absl12_GLOBAL__N_125DoFastIntToBufferBackwardIjPcEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueET0_E4typeES5_S6_j:
  435|  5.17k|DoFastIntToBufferBackward(T v, BackwardIt end, uint32_t digits) {
  436|  5.17k|  using PromotedT = std::decay_t<decltype(+v)>;
  437|  5.17k|  using Converter = FastUIntToStringConverter<PromotedT, BackwardIt>;
  438|  5.17k|  (void)digits;
  439|  5.17k|  return Converter().FastIntToBufferBackward(v, end);
  440|  5.17k|}
numbers.cc:_ZN4absl12_GLOBAL__N_125FastUIntToStringConverterIjPcE23FastIntToBufferBackwardEjS2_:
  306|  5.17k|  static BackwardIt FastIntToBufferBackward(T v, BackwardIt end) {
  307|       |    // THIS IS A HOT FUNCTION with a very deliberate structure to exploit branch
  308|       |    // prediction and shorten the critical path for smaller numbers.
  309|       |    // Do not move around the if/else blocks or attempt to simplify it
  310|       |    // without benchmarking any changes.
  311|       |
  312|  5.17k|    if (v < 10) {
  ------------------
  |  Branch (312:9): [True: 2.60k, False: 2.57k]
  ------------------
  313|  2.60k|      goto AT_LEAST_1 /* NOTE: mandatory for the 0 case */;
  314|  2.60k|    }
  315|  2.57k|    if (v < 1000) {
  ------------------
  |  Branch (315:9): [True: 56, False: 2.51k]
  ------------------
  316|     56|      goto AT_LEAST_10;
  317|     56|    }
  318|  2.51k|    if (v < 10000000) {
  ------------------
  |  Branch (318:9): [True: 214, False: 2.30k]
  ------------------
  319|    214|      goto AT_LEAST_1000;
  320|    214|    }
  321|       |
  322|  2.30k|    if (v >= 100000000 / 10) {
  ------------------
  |  Branch (322:9): [True: 2.30k, False: 0]
  ------------------
  323|  2.30k|      if (v >= 10000000000000000 / 10) {
  ------------------
  |  Branch (323:11): [True: 0, False: 2.30k]
  ------------------
  324|      0|        DoFastIntToBufferBackward<8>(v, end);
  325|      0|      }
  326|  2.30k|      DoFastIntToBufferBackward<8>(v, end);
  327|  2.30k|    }
  328|       |
  329|  2.30k|    if (v >= 10000 / 10) {
  ------------------
  |  Branch (329:9): [True: 0, False: 2.30k]
  ------------------
  330|    214|    AT_LEAST_1000:
  331|    214|      DoFastIntToBufferBackward<4>(v, end);
  332|    214|    }
  333|       |
  334|  2.51k|    if (v >= 100 / 10) {
  ------------------
  |  Branch (334:9): [True: 2.20k, False: 310]
  ------------------
  335|  2.26k|    AT_LEAST_10:
  336|  2.26k|      DoFastIntToBufferBackward<2>(v, end);
  337|  2.26k|    }
  338|       |
  339|  2.57k|    if (v >= 10 / 10) {
  ------------------
  |  Branch (339:9): [True: 330, False: 2.24k]
  ------------------
  340|  2.93k|    AT_LEAST_1:
  341|  2.93k|      end = DoFastIntToBufferBackward(v, end, std::integral_constant<int, 1>());
  342|  2.93k|    }
  343|  5.17k|    return end;
  344|  2.57k|  }
numbers.cc:_ZN4absl12_GLOBAL__N_125FastUIntToStringConverterIjPcE25DoFastIntToBufferBackwardILi8EEEvRjRS2_:
  354|  2.30k|  static void DoFastIntToBufferBackward(T& v, BackwardIt& end) {
  355|  2.30k|    constexpr T kModulus = Pow<T>(10, Exponent);
  356|  2.30k|    T remainder = static_cast<T>(v % kModulus);
  357|  2.30k|    v = static_cast<T>(v / kModulus);
  358|  2.30k|    end = DoFastIntToBufferBackward(remainder, end,
  359|  2.30k|                                    std::integral_constant<int, Exponent>());
  360|  2.30k|  }
numbers.cc:_ZN4absl12_GLOBAL__N_125FastUIntToStringConverterIjPcE25DoFastIntToBufferBackwardEjS2_NSt3__117integral_constantIiLi8EEE:
  392|  2.30k|                                              std::integral_constant<int, 8>) {
  393|  2.30k|    if (kIsContiguousIterator) {
  ------------------
  |  Branch (393:9): [Folded - Ignored]
  ------------------
  394|  2.30k|      const uint64_t digits =
  395|  2.30k|          PrepareEightDigits(static_cast<uint32_t>(v)) + kEightZeroBytes;
  396|  2.30k|      end -= sizeof(digits);
  397|  2.30k|      little_endian::Store64(&*end, digits);
  398|  2.30k|    } else {
  399|      0|      uint64_t digits = PrepareEightDigitsReversed(static_cast<uint32_t>(v)) +
  400|      0|                        kEightZeroBytes;
  401|      0|      for (size_t i = 0; i < sizeof(digits); ++i) {
  ------------------
  |  Branch (401:26): [True: 0, False: 0]
  ------------------
  402|      0|        *--end = static_cast<char>(digits);
  403|      0|        digits >>= CHAR_BIT;
  404|      0|      }
  405|      0|    }
  406|  2.30k|    return end;
  407|  2.30k|  }
numbers.cc:_ZN4absl12_GLOBAL__N_118PrepareEightDigitsEj:
  283|  2.30k|inline uint64_t PrepareEightDigits(uint32_t i) {
  284|  2.30k|  return PrepareEightDigitsImpl(i, false);
  285|  2.30k|}
numbers.cc:_ZN4absl12_GLOBAL__N_122PrepareEightDigitsImplEjb:
  265|  2.30k|inline uint64_t PrepareEightDigitsImpl(uint32_t i, bool reversed) {
  266|  2.30k|  ABSL_ASSUME(i < 10000'0000);
  ------------------
  |  |  259|  2.30k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  267|       |  // Prepare 2 blocks of 4 digits "in parallel".
  268|  2.30k|  uint32_t hi = i / 10000;
  269|  2.30k|  uint32_t lo = i % 10000;
  270|  2.30k|  uint64_t merged = (uint64_t{hi} << (reversed ? 32 : 0)) |
  ------------------
  |  Branch (270:39): [True: 0, False: 2.30k]
  ------------------
  271|  2.30k|                    (uint64_t{lo} << (reversed ? 0 : 32));
  ------------------
  |  Branch (271:39): [True: 0, False: 2.30k]
  ------------------
  272|  2.30k|  uint64_t div100 = ((merged * kDivisionBy100Mul) / kDivisionBy100Div) &
  273|  2.30k|                    ((0x7Full << 32) | 0x7Full);
  274|  2.30k|  uint64_t mod100 = merged - 100ull * div100;
  275|  2.30k|  uint64_t hundreds =
  276|  2.30k|      (mod100 << (reversed ? 0 : 16)) + (div100 << (reversed ? 16 : 0));
  ------------------
  |  Branch (276:19): [True: 0, False: 2.30k]
  |  Branch (276:53): [True: 0, False: 2.30k]
  ------------------
  277|  2.30k|  uint64_t tens = (hundreds * kDivisionBy10Mul) / kDivisionBy10Div;
  278|  2.30k|  tens &= (0xFull << 48) | (0xFull << 32) | (0xFull << 16) | 0xFull;
  279|  2.30k|  tens = (tens << (reversed ? 8 : 0)) +
  ------------------
  |  Branch (279:20): [True: 0, False: 2.30k]
  ------------------
  280|  2.30k|         ((hundreds - 10ull * tens) << (reversed ? 0 : 8));
  ------------------
  |  Branch (280:41): [True: 0, False: 2.30k]
  ------------------
  281|  2.30k|  return tens;
  282|  2.30k|}
numbers.cc:_ZN4absl12_GLOBAL__N_125FastUIntToStringConverterIjPcE25DoFastIntToBufferBackwardILi4EEEvRjRS2_:
  354|    214|  static void DoFastIntToBufferBackward(T& v, BackwardIt& end) {
  355|    214|    constexpr T kModulus = Pow<T>(10, Exponent);
  356|    214|    T remainder = static_cast<T>(v % kModulus);
  357|    214|    v = static_cast<T>(v / kModulus);
  358|    214|    end = DoFastIntToBufferBackward(remainder, end,
  359|    214|                                    std::integral_constant<int, Exponent>());
  360|    214|  }
numbers.cc:_ZN4absl12_GLOBAL__N_125FastUIntToStringConverterIjPcE25DoFastIntToBufferBackwardEjS2_NSt3__117integral_constantIiLi4EEE:
  374|    214|                                              std::integral_constant<int, 4>) {
  375|    214|    if (kIsContiguousIterator) {
  ------------------
  |  Branch (375:9): [Folded - Ignored]
  ------------------
  376|    214|      const uint32_t digits =
  377|    214|          PrepareFourDigits(static_cast<uint32_t>(v)) + kFourZeroBytes;
  378|    214|      end -= sizeof(digits);
  379|    214|      little_endian::Store32(&*end, digits);
  380|    214|    } else {
  381|      0|      uint32_t digits =
  382|      0|          PrepareFourDigitsReversed(static_cast<uint32_t>(v)) + kFourZeroBytes;
  383|      0|      for (size_t i = 0; i < sizeof(digits); ++i) {
  ------------------
  |  Branch (383:26): [True: 0, False: 0]
  ------------------
  384|      0|        *--end = static_cast<char>(digits);
  385|      0|        digits >>= CHAR_BIT;
  386|      0|      }
  387|      0|    }
  388|    214|    return end;
  389|    214|  }
numbers.cc:_ZN4absl12_GLOBAL__N_117PrepareFourDigitsEj:
  242|    214|inline uint32_t PrepareFourDigits(uint32_t n) {
  243|    214|  return PrepareFourDigitsImpl(n, false);
  244|    214|}
numbers.cc:_ZN4absl12_GLOBAL__N_121PrepareFourDigitsImplEjb:
  226|    214|inline uint32_t PrepareFourDigitsImpl(uint32_t n, bool reversed) {
  227|       |  // We split lower 2 digits and upper 2 digits of n into 2 byte consecutive
  228|       |  // blocks. 123 ->  [\0\1][\0\23]. We divide by 10 both blocks
  229|       |  // (it's 1 division + zeroing upper bits), and compute modulo 10 as well "in
  230|       |  // parallel". Then we combine both results to have both ASCII digits,
  231|       |  // strip trailing zeros, add ASCII '0000' and return.
  232|    214|  uint32_t div100 = (n * kDivisionBy100Mul) / kDivisionBy100Div;
  233|    214|  uint32_t mod100 = n - 100ull * div100;
  234|    214|  uint32_t hundreds =
  235|    214|      (mod100 << (reversed ? 0 : 16)) + (div100 << (reversed ? 16 : 0));
  ------------------
  |  Branch (235:19): [True: 0, False: 214]
  |  Branch (235:53): [True: 0, False: 214]
  ------------------
  236|    214|  uint32_t tens = (hundreds * kDivisionBy10Mul) / kDivisionBy10Div;
  237|    214|  tens &= (0xFull << 16) | 0xFull;
  238|    214|  tens = (tens << (reversed ? 8 : 0)) +
  ------------------
  |  Branch (238:20): [True: 0, False: 214]
  ------------------
  239|    214|         static_cast<uint32_t>((hundreds - 10ull * tens) << (reversed ? 0 : 8));
  ------------------
  |  Branch (239:62): [True: 0, False: 214]
  ------------------
  240|    214|  return tens;
  241|    214|}
numbers.cc:_ZN4absl12_GLOBAL__N_125FastUIntToStringConverterIjPcE25DoFastIntToBufferBackwardILi2EEEvRjRS2_:
  354|  2.26k|  static void DoFastIntToBufferBackward(T& v, BackwardIt& end) {
  355|  2.26k|    constexpr T kModulus = Pow<T>(10, Exponent);
  356|  2.26k|    T remainder = static_cast<T>(v % kModulus);
  357|  2.26k|    v = static_cast<T>(v / kModulus);
  358|  2.26k|    end = DoFastIntToBufferBackward(remainder, end,
  359|  2.26k|                                    std::integral_constant<int, Exponent>());
  360|  2.26k|  }
numbers.cc:_ZN4absl12_GLOBAL__N_125FastUIntToStringConverterIjPcE25DoFastIntToBufferBackwardILi2EEES2_jS2_NSt3__117integral_constantIiXT_EEE:
  411|  2.26k|      T v, BackwardIt end, std::integral_constant<int, Digits>) {
  412|  2.26k|    constexpr int kLogModulus = Digits - Digits / 2;
  413|  2.26k|    constexpr T kModulus = Pow(static_cast<T>(10), kLogModulus);
  414|  2.26k|    bool is_safe_to_use_division_trick = Digits <= 8;
  415|  2.26k|    T quotient, remainder;
  416|  2.26k|    if (is_safe_to_use_division_trick) {
  ------------------
  |  Branch (416:9): [True: 2.26k, False: 0]
  ------------------
  417|  2.26k|      constexpr uint64_t kCoefficient =
  418|  2.26k|          ComputePowerOf100DivisionCoefficient<uint64_t>(kLogModulus);
  419|  2.26k|      quotient = (v * kCoefficient) >> (10 * kLogModulus);
  420|  2.26k|      remainder = v - quotient * kModulus;
  421|  2.26k|    } else {
  422|      0|      quotient = v / kModulus;
  423|      0|      remainder = v % kModulus;
  424|      0|    }
  425|  2.26k|    end = DoFastIntToBufferBackward(remainder, end,
  426|  2.26k|                                    std::integral_constant<int, kLogModulus>());
  427|  2.26k|    return DoFastIntToBufferBackward(
  428|  2.26k|        quotient, end, std::integral_constant<int, Digits - kLogModulus>());
  429|  2.26k|  }
numbers.cc:_ZN4absl12_GLOBAL__N_125FastUIntToStringConverterIjPcE25DoFastIntToBufferBackwardEjS2_NSt3__117integral_constantIiLi1EEE:
  368|  7.45k|                                              std::integral_constant<int, 1>) {
  369|  7.45k|    *--end = static_cast<char>('0' + v);
  370|  7.45k|    return DoFastIntToBufferBackward(v, end, std::integral_constant<int, 0>());
  371|  7.45k|  }
numbers.cc:_ZN4absl12_GLOBAL__N_125FastUIntToStringConverterIjPcE25DoFastIntToBufferBackwardERKjS2_NSt3__117integral_constantIiLi0EEE:
  363|  7.45k|                                              std::integral_constant<int, 0>) {
  364|  7.45k|    return end;
  365|  7.45k|  }
numbers.cc:_ZN4absl12_GLOBAL__N_125DoFastIntToBufferBackwardIiPcEENSt3__19enable_ifIXsr3std9is_signedIT_EE5valueET0_E4typeES5_S6_j:
  444|  5.17k|DoFastIntToBufferBackward(T v, BackwardIt end, uint32_t digits) {
  445|  5.17k|  if (absl::numbers_internal::IsNegative(v)) {
  ------------------
  |  Branch (445:7): [True: 2.18k, False: 2.98k]
  ------------------
  446|       |    // Store the minus sign *before* we produce the number itself, not after.
  447|       |    // This gets us a tail call.
  448|  2.18k|    end[-static_cast<ptrdiff_t>(digits) - 1] = '-';
  449|  2.18k|  }
  450|  5.17k|  return DoFastIntToBufferBackward(
  451|  5.17k|      absl::numbers_internal::UnsignedAbsoluteValue(v), end, digits);
  452|  5.17k|}
numbers.cc:_ZN4absl12_GLOBAL__N_117safe_int_internalIiEEbNS_11string_viewEPT_i:
 1290|  1.29k|                              absl::Nonnull<IntType*> value_p, int base) {
 1291|  1.29k|  *value_p = 0;
 1292|  1.29k|  bool negative;
 1293|  1.29k|  if (!safe_parse_sign_and_base(&text, &base, &negative)) {
  ------------------
  |  Branch (1293:7): [True: 0, False: 1.29k]
  ------------------
 1294|      0|    return false;
 1295|      0|  }
 1296|  1.29k|  if (!negative) {
  ------------------
  |  Branch (1296:7): [True: 200, False: 1.09k]
  ------------------
 1297|    200|    return safe_parse_positive_int(text, base, value_p);
 1298|  1.09k|  } else {
 1299|  1.09k|    return safe_parse_negative_int(text, base, value_p);
 1300|  1.09k|  }
 1301|  1.29k|}
numbers.cc:_ZN4absl12_GLOBAL__N_124safe_parse_sign_and_baseEPNS_11string_viewEPiPb:
  923|  1.29k|    absl::Nonnull<bool*> negative_ptr /*output*/) {
  924|  1.29k|  if (text->data() == nullptr) {
  ------------------
  |  Branch (924:7): [True: 0, False: 1.29k]
  ------------------
  925|      0|    return false;
  926|      0|  }
  927|       |
  928|  1.29k|  const char* start = text->data();
  929|  1.29k|  const char* end = start + text->size();
  930|  1.29k|  int base = *base_ptr;
  931|       |
  932|       |  // Consume whitespace.
  933|  1.29k|  while (start < end &&
  ------------------
  |  Branch (933:10): [True: 1.29k, False: 0]
  ------------------
  934|  1.29k|         absl::ascii_isspace(static_cast<unsigned char>(start[0]))) {
  ------------------
  |  Branch (934:10): [True: 0, False: 1.29k]
  ------------------
  935|      0|    ++start;
  936|      0|  }
  937|  1.29k|  while (start < end &&
  ------------------
  |  Branch (937:10): [True: 1.29k, False: 0]
  ------------------
  938|  1.29k|         absl::ascii_isspace(static_cast<unsigned char>(end[-1]))) {
  ------------------
  |  Branch (938:10): [True: 0, False: 1.29k]
  ------------------
  939|      0|    --end;
  940|      0|  }
  941|  1.29k|  if (start >= end) {
  ------------------
  |  Branch (941:7): [True: 0, False: 1.29k]
  ------------------
  942|      0|    return false;
  943|      0|  }
  944|       |
  945|       |  // Consume sign.
  946|  1.29k|  *negative_ptr = (start[0] == '-');
  947|  1.29k|  if (*negative_ptr || start[0] == '+') {
  ------------------
  |  Branch (947:7): [True: 1.09k, False: 200]
  |  Branch (947:24): [True: 0, False: 200]
  ------------------
  948|  1.09k|    ++start;
  949|  1.09k|    if (start >= end) {
  ------------------
  |  Branch (949:9): [True: 0, False: 1.09k]
  ------------------
  950|      0|      return false;
  951|      0|    }
  952|  1.09k|  }
  953|       |
  954|       |  // Consume base-dependent prefix.
  955|       |  //  base 0: "0x" -> base 16, "0" -> base 8, default -> base 10
  956|       |  //  base 16: "0x" -> base 16
  957|       |  // Also validate the base.
  958|  1.29k|  if (base == 0) {
  ------------------
  |  Branch (958:7): [True: 0, False: 1.29k]
  ------------------
  959|      0|    if (end - start >= 2 && start[0] == '0' &&
  ------------------
  |  Branch (959:9): [True: 0, False: 0]
  |  Branch (959:29): [True: 0, False: 0]
  ------------------
  960|      0|        (start[1] == 'x' || start[1] == 'X')) {
  ------------------
  |  Branch (960:10): [True: 0, False: 0]
  |  Branch (960:29): [True: 0, False: 0]
  ------------------
  961|      0|      base = 16;
  962|      0|      start += 2;
  963|      0|      if (start >= end) {
  ------------------
  |  Branch (963:11): [True: 0, False: 0]
  ------------------
  964|       |        // "0x" with no digits after is invalid.
  965|      0|        return false;
  966|      0|      }
  967|      0|    } else if (end - start >= 1 && start[0] == '0') {
  ------------------
  |  Branch (967:16): [True: 0, False: 0]
  |  Branch (967:36): [True: 0, False: 0]
  ------------------
  968|      0|      base = 8;
  969|      0|      start += 1;
  970|      0|    } else {
  971|      0|      base = 10;
  972|      0|    }
  973|  1.29k|  } else if (base == 16) {
  ------------------
  |  Branch (973:14): [True: 0, False: 1.29k]
  ------------------
  974|      0|    if (end - start >= 2 && start[0] == '0' &&
  ------------------
  |  Branch (974:9): [True: 0, False: 0]
  |  Branch (974:29): [True: 0, False: 0]
  ------------------
  975|      0|        (start[1] == 'x' || start[1] == 'X')) {
  ------------------
  |  Branch (975:10): [True: 0, False: 0]
  |  Branch (975:29): [True: 0, False: 0]
  ------------------
  976|      0|      start += 2;
  977|      0|      if (start >= end) {
  ------------------
  |  Branch (977:11): [True: 0, False: 0]
  ------------------
  978|       |        // "0x" with no digits after is invalid.
  979|      0|        return false;
  980|      0|      }
  981|      0|    }
  982|  1.29k|  } else if (base >= 2 && base <= 36) {
  ------------------
  |  Branch (982:14): [True: 1.29k, False: 0]
  |  Branch (982:27): [True: 1.29k, False: 0]
  ------------------
  983|       |    // okay
  984|  1.29k|  } else {
  985|      0|    return false;
  986|      0|  }
  987|  1.29k|  *text = absl::string_view(start, static_cast<size_t>(end - start));
  988|  1.29k|  *base_ptr = base;
  989|  1.29k|  return true;
  990|  1.29k|}
numbers.cc:_ZN4absl12_GLOBAL__N_123safe_parse_positive_intIiEEbNS_11string_viewEiPT_:
 1208|    200|                                    absl::Nonnull<IntType*> value_p) {
 1209|    200|  IntType value = 0;
 1210|    200|  const IntType vmax = std::numeric_limits<IntType>::max();
 1211|    200|  assert(vmax > 0);
 1212|    200|  assert(base >= 0);
 1213|    200|  const IntType base_inttype = static_cast<IntType>(base);
 1214|    200|  assert(vmax >= base_inttype);
 1215|    200|  const IntType vmax_over_base = LookupTables<IntType>::kVmaxOverBase[base];
 1216|    200|  assert(base < 2 ||
 1217|    200|         std::numeric_limits<IntType>::max() / base_inttype == vmax_over_base);
 1218|    200|  const char* start = text.data();
 1219|    200|  const char* end = start + text.size();
 1220|       |  // loop over digits
 1221|  1.73k|  for (; start < end; ++start) {
  ------------------
  |  Branch (1221:10): [True: 1.53k, False: 200]
  ------------------
 1222|  1.53k|    unsigned char c = static_cast<unsigned char>(start[0]);
 1223|  1.53k|    IntType digit = static_cast<IntType>(kAsciiToInt[c]);
 1224|  1.53k|    if (digit >= base_inttype) {
  ------------------
  |  Branch (1224:9): [True: 0, False: 1.53k]
  ------------------
 1225|      0|      *value_p = value;
 1226|      0|      return false;
 1227|      0|    }
 1228|  1.53k|    if (value > vmax_over_base) {
  ------------------
  |  Branch (1228:9): [True: 0, False: 1.53k]
  ------------------
 1229|      0|      *value_p = vmax;
 1230|      0|      return false;
 1231|      0|    }
 1232|  1.53k|    value *= base_inttype;
 1233|  1.53k|    if (value > vmax - digit) {
  ------------------
  |  Branch (1233:9): [True: 0, False: 1.53k]
  ------------------
 1234|      0|      *value_p = vmax;
 1235|      0|      return false;
 1236|      0|    }
 1237|  1.53k|    value += digit;
 1238|  1.53k|  }
 1239|    200|  *value_p = value;
 1240|    200|  return true;
 1241|    200|}
numbers.cc:_ZN4absl12_GLOBAL__N_123safe_parse_negative_intIiEEbNS_11string_viewEiPT_:
 1245|  1.09k|                                    absl::Nonnull<IntType*> value_p) {
 1246|  1.09k|  IntType value = 0;
 1247|  1.09k|  const IntType vmin = std::numeric_limits<IntType>::min();
 1248|  1.09k|  assert(vmin < 0);
 1249|  1.09k|  assert(vmin <= 0 - base);
 1250|  1.09k|  IntType vmin_over_base = LookupTables<IntType>::kVminOverBase[base];
 1251|  1.09k|  assert(base < 2 ||
 1252|  1.09k|         std::numeric_limits<IntType>::min() / base == vmin_over_base);
 1253|       |  // 2003 c++ standard [expr.mul]
 1254|       |  // "... the sign of the remainder is implementation-defined."
 1255|       |  // Although (vmin/base)*base + vmin%base is always vmin.
 1256|       |  // 2011 c++ standard tightens the spec but we cannot rely on it.
 1257|       |  // TODO(junyer): Handle this in the lookup table generation.
 1258|  1.09k|  if (vmin % base > 0) {
  ------------------
  |  Branch (1258:7): [True: 0, False: 1.09k]
  ------------------
 1259|      0|    vmin_over_base += 1;
 1260|      0|  }
 1261|  1.09k|  const char* start = text.data();
 1262|  1.09k|  const char* end = start + text.size();
 1263|       |  // loop over digits
 1264|  11.6k|  for (; start < end; ++start) {
  ------------------
  |  Branch (1264:10): [True: 10.5k, False: 1.09k]
  ------------------
 1265|  10.5k|    unsigned char c = static_cast<unsigned char>(start[0]);
 1266|  10.5k|    int digit = kAsciiToInt[c];
 1267|  10.5k|    if (digit >= base) {
  ------------------
  |  Branch (1267:9): [True: 0, False: 10.5k]
  ------------------
 1268|      0|      *value_p = value;
 1269|      0|      return false;
 1270|      0|    }
 1271|  10.5k|    if (value < vmin_over_base) {
  ------------------
  |  Branch (1271:9): [True: 0, False: 10.5k]
  ------------------
 1272|      0|      *value_p = vmin;
 1273|      0|      return false;
 1274|      0|    }
 1275|  10.5k|    value *= base;
 1276|  10.5k|    if (value < vmin + digit) {
  ------------------
  |  Branch (1276:9): [True: 0, False: 10.5k]
  ------------------
 1277|      0|      *value_p = vmin;
 1278|      0|      return false;
 1279|      0|    }
 1280|  10.5k|    value -= digit;
 1281|  10.5k|  }
 1282|  1.09k|  *value_p = value;
 1283|  1.09k|  return true;
 1284|  1.09k|}

_ZN4absl10SimpleAtoiIiEEbNS_11string_viewEPT_:
  423|  1.29k|                                     absl::Nonnull<int_type*> out) {
  424|  1.29k|  return numbers_internal::safe_strtoi_base(str, out, 10);
  425|  1.29k|}
_ZN4absl16numbers_internal16safe_strtoi_baseIiEEbNS_11string_viewEPT_i:
  354|  1.29k|                                           int base) {
  355|  1.29k|  static_assert(sizeof(*out) == 4 || sizeof(*out) == 8,
  356|  1.29k|                "SimpleAtoi works only with 32-bit or 64-bit integers.");
  357|  1.29k|  static_assert(!std::is_floating_point<int_type>::value,
  358|  1.29k|                "Use SimpleAtof or SimpleAtod instead.");
  359|  1.29k|  bool parsed;
  360|       |  // TODO(jorg): This signed-ness check is used because it works correctly
  361|       |  // with enums, and it also serves to check that int_type is not a pointer.
  362|       |  // If one day something like std::is_signed<enum E> works, switch to it.
  363|       |  // These conditions are constexpr bools to suppress MSVC warning C4127.
  364|  1.29k|  constexpr bool kIsSigned = static_cast<int_type>(1) - 2 < 0;
  365|  1.29k|  constexpr bool kUse64Bit = sizeof(*out) == 64 / 8;
  366|  1.29k|  if (kIsSigned) {
  ------------------
  |  Branch (366:7): [Folded - Ignored]
  ------------------
  367|  1.29k|    if (kUse64Bit) {
  ------------------
  |  Branch (367:9): [Folded - Ignored]
  ------------------
  368|      0|      int64_t val;
  369|      0|      parsed = numbers_internal::safe_strto64_base(s, &val, base);
  370|      0|      *out = static_cast<int_type>(val);
  371|  1.29k|    } else {
  372|  1.29k|      int32_t val;
  373|  1.29k|      parsed = numbers_internal::safe_strto32_base(s, &val, base);
  374|  1.29k|      *out = static_cast<int_type>(val);
  375|  1.29k|    }
  376|  1.29k|  } else {
  377|      0|    if (kUse64Bit) {
  ------------------
  |  Branch (377:9): [Folded - Ignored]
  ------------------
  378|      0|      uint64_t val;
  379|      0|      parsed = numbers_internal::safe_strtou64_base(s, &val, base);
  380|      0|      *out = static_cast<int_type>(val);
  381|      0|    } else {
  382|      0|      uint32_t val;
  383|      0|      parsed = numbers_internal::safe_strtou32_base(s, &val, base);
  384|      0|      *out = static_cast<int_type>(val);
  385|      0|    }
  386|      0|  }
  387|  1.29k|  return parsed;
  388|  1.29k|}
_ZN4absl16numbers_internal12Base10DigitsIjEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEjE4typeES4_j:
  199|  5.17k|    T v, const uint32_t initial_digits = 1) {
  200|  5.17k|  uint32_t r = initial_digits;
  201|       |  // If code size becomes an issue, the 'if' stage can be removed for a minor
  202|       |  // performance loss.
  203|  7.54k|  for (;;) {
  204|  7.54k|    if (ABSL_PREDICT_TRUE(v < 10 * 10)) {
  ------------------
  |  |  179|  7.54k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (179:30): [True: 2.72k, False: 4.81k]
  |  |  |  Branch (179:48): [Folded - Ignored]
  |  |  |  Branch (179:57): [True: 2.72k, False: 4.81k]
  |  |  ------------------
  ------------------
  205|  2.72k|      r += (v >= 10);
  206|  2.72k|      break;
  207|  2.72k|    }
  208|  4.81k|    if (ABSL_PREDICT_TRUE(v < 1000 * 10)) {
  ------------------
  |  |  179|  4.81k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (179:30): [True: 2.34k, False: 2.47k]
  |  |  |  Branch (179:48): [Folded - Ignored]
  |  |  |  Branch (179:57): [True: 2.34k, False: 2.47k]
  |  |  ------------------
  ------------------
  209|  2.34k|      r += (v >= 1000) + 2;
  210|  2.34k|      break;
  211|  2.34k|    }
  212|  2.47k|    if (ABSL_PREDICT_TRUE(v < 100000 * 10)) {
  ------------------
  |  |  179|  2.47k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (179:30): [True: 108, False: 2.36k]
  |  |  |  Branch (179:48): [Folded - Ignored]
  |  |  |  Branch (179:57): [True: 108, False: 2.36k]
  |  |  ------------------
  ------------------
  213|    108|      r += (v >= 100000) + 4;
  214|    108|      break;
  215|    108|    }
  216|  2.36k|    r += 6;
  217|  2.36k|    v = static_cast<T>(v / 1000000);
  218|  2.36k|  }
  219|  5.17k|  return r;
  220|  5.17k|}
_ZN4absl16numbers_internal21UnsignedAbsoluteValueIiEENSt3__19enable_ifIXntsr3std11is_unsignedIT_EE5valueENS2_13make_unsignedIS4_E4typeEE4typeES4_:
  187|  10.3k|    UnsignedAbsoluteValue(T v) {
  188|  10.3k|  using U = std::make_unsigned_t<T>;
  189|  10.3k|  return IsNegative(v) ? U() - static_cast<U>(v) : static_cast<U>(v);
  ------------------
  |  Branch (189:10): [True: 4.37k, False: 5.97k]
  ------------------
  190|  10.3k|}
_ZN4absl16numbers_internal10IsNegativeIiEENSt3__19enable_ifIXntsr3std11is_unsignedIT_EE5valueEbE4typeERKS4_:
  165|  15.5k|std::enable_if_t<!std::is_unsigned<T>::value, bool> IsNegative(const T& v) {
  166|  15.5k|  return v < T();
  167|  15.5k|}

_ZN4absl16strings_internal37STLStringAppendUninitializedAmortizedEPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEm:
  102|  1.29k|                                           size_t to_append) {
  103|  1.29k|  strings_internal::AppendUninitializedTraits<std::string>::Append(dest,
  104|  1.29k|                                                                   to_append);
  105|  1.29k|}
_ZN4absl16strings_internal9CatPiecesESt16initializer_listINS_11string_viewEE:
  225|  1.29k|std::string CatPieces(std::initializer_list<absl::string_view> pieces) {
  226|  1.29k|  std::string result;
  227|  1.29k|  size_t total_size = 0;
  228|  6.47k|  for (absl::string_view piece : pieces) total_size += piece.size();
  ------------------
  |  Branch (228:32): [True: 6.47k, False: 1.29k]
  ------------------
  229|  1.29k|  strings_internal::STLStringResizeUninitialized(&result, total_size);
  230|       |
  231|  1.29k|  char* const begin = &result[0];
  232|  1.29k|  char* out = begin;
  233|  6.47k|  for (absl::string_view piece : pieces) {
  ------------------
  |  Branch (233:32): [True: 6.47k, False: 1.29k]
  ------------------
  234|  6.47k|    const size_t this_size = piece.size();
  235|  6.47k|    if (this_size != 0) {
  ------------------
  |  Branch (235:9): [True: 5.80k, False: 669]
  ------------------
  236|  5.80k|      memcpy(out, piece.data(), this_size);
  237|  5.80k|      out += this_size;
  238|  5.80k|    }
  239|  6.47k|  }
  240|  1.29k|  assert(out == begin + result.size());
  241|  1.29k|  return result;
  242|  1.29k|}
_ZN4absl9StrAppendEPNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEERKNS_8AlphaNumE:
  277|  1.29k|void StrAppend(absl::Nonnull<std::string*> dest, const AlphaNum& a) {
  278|  1.29k|  ASSERT_NO_OVERLAP(*dest, a);
  ------------------
  |  |  250|  1.29k|  assert(((src).size() == 0) ||      \
  |  |  251|  1.29k|         (uintptr_t((src).data() - (dest).data()) > uintptr_t((dest).size())))
  ------------------
  279|  1.29k|  std::string::size_type old_size = dest->size();
  280|  1.29k|  strings_internal::STLStringAppendUninitializedAmortized(dest, a.size());
  281|  1.29k|  char* const begin = &(*dest)[0];
  282|  1.29k|  char* out = begin + old_size;
  283|  1.29k|  out = Append(out, a);
  284|  1.29k|  assert(out == begin + dest->size());
  285|  1.29k|}
str_cat.cc:_ZN4absl12_GLOBAL__N_16AppendEPcRKNS_8AlphaNumE:
   46|  1.29k|absl::Nonnull<char*> Append(absl::Nonnull<char*> out, const AlphaNum& x) {
   47|       |  // memcpy is allowed to overwrite arbitrary memory, so doing this after the
   48|       |  // call would force an extra fetch of x.size().
   49|  1.29k|  char* after = out + x.size();
   50|  1.29k|  if (x.size() != 0) {
  ------------------
  |  Branch (50:7): [True: 168, False: 1.12k]
  ------------------
   51|    168|    memcpy(out, x.data(), x.size());
   52|    168|  }
   53|  1.29k|  return after;
   54|  1.29k|}

_ZN4absl8AlphaNumC2Ef:
  346|  1.29k|      : piece_(digits_, numbers_internal::SixDigitsToBuffer(f, digits_)) {}
_ZN4absl8AlphaNumC2Ed:
  348|  1.29k|      : piece_(digits_, numbers_internal::SixDigitsToBuffer(f, digits_)) {}
_ZN4absl8AlphaNumC2Ei:
  323|  2.58k|                            &digits_[0])) {}
_ZN4absl8AlphaNumC2INSt3__19allocatorIcEEEERKNS2_12basic_stringIcNS2_11char_traitsIcEET_EE:
  374|  2.58k|      : piece_(str) {}
_ZN4absl6StrCatIJEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_8AlphaNumESA_SA_SA_SA_DpRKT_:
  509|  1.29k|    const AlphaNum& e, const AV&... args) {
  510|  1.29k|  return strings_internal::CatPieces(
  511|  1.29k|      {a.Piece(), b.Piece(), c.Piece(), d.Piece(), e.Piece(),
  512|  1.29k|       static_cast<const AlphaNum&>(args).Piece()...});
  513|  1.29k|}
_ZNK4absl8AlphaNum5PieceEv:
  384|  6.47k|  absl::string_view Piece() const { return piece_; }
_ZNK4absl8AlphaNum4sizeEv:
  382|  4.05k|  absl::string_view::size_type size() const { return piece_.size(); }
_ZNK4absl8AlphaNum4dataEv:
  383|    168|  absl::Nullable<const char*> data() const { return piece_.data(); }

_ZN4absl9StrFormatIJfEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_19str_format_internal18FormatSpecTemplateIJXspclsr19str_format_internalE14ArgumentToConvIT_EEEEEEDpRKSA_:
  363|  1.29k|                                           const Args&... args) {
  364|  1.29k|  return str_format_internal::FormatPack(
  365|  1.29k|      str_format_internal::UntypedFormatSpecImpl::Extract(format),
  366|  1.29k|      {str_format_internal::FormatArgImpl(args)...});
  367|  1.29k|}
_ZN4absl17UntypedFormatSpecC2ENS_11string_viewE:
  111|  5.17k|  explicit UntypedFormatSpec(string_view s) : spec_(s) {}
_ZN4absl9StrFormatIJdEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_19str_format_internal18FormatSpecTemplateIJXspclsr19str_format_internalE14ArgumentToConvIT_EEEEEEDpRKSA_:
  363|  1.29k|                                           const Args&... args) {
  364|  1.29k|  return str_format_internal::FormatPack(
  365|  1.29k|      str_format_internal::UntypedFormatSpecImpl::Extract(format),
  366|  1.29k|      {str_format_internal::FormatArgImpl(args)...});
  367|  1.29k|}
_ZN4absl9StrFormatIJiEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_19str_format_internal18FormatSpecTemplateIJXspclsr19str_format_internalE14ArgumentToConvIT_EEEEEEDpRKSA_:
  363|  1.29k|                                           const Args&... args) {
  364|  1.29k|  return str_format_internal::FormatPack(
  365|  1.29k|      str_format_internal::UntypedFormatSpecImpl::Extract(format),
  366|  1.29k|      {str_format_internal::FormatArgImpl(args)...});
  367|  1.29k|}
_ZN4absl9StrFormatIJbEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_19str_format_internal18FormatSpecTemplateIJXspclsr19str_format_internalE14ArgumentToConvIT_EEEEEEDpRKSA_:
  363|  1.29k|                                           const Args&... args) {
  364|  1.29k|  return str_format_internal::FormatPack(
  365|  1.29k|      str_format_internal::UntypedFormatSpecImpl::Extract(format),
  366|  1.29k|      {str_format_internal::FormatArgImpl(args)...});
  367|  1.29k|}

_ZN4absl7StrJoinINSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEEEES8_RKT_NS_11string_viewE:
  268|  1.29k|std::string StrJoin(const Range& range, absl::string_view separator) {
  269|  1.29k|  return strings_internal::JoinRange(range, separator);
  270|  1.29k|}

_ZN4absl8ByStringC2ENS_11string_viewE:
   85|  1.29k|ByString::ByString(absl::string_view sp) : delimiter_(sp) {}
_ZNK4absl8ByString4FindENS_11string_viewEm:
   87|  6.97M|absl::string_view ByString::Find(absl::string_view text, size_t pos) const {
   88|  6.97M|  if (delimiter_.length() == 1) {
  ------------------
  |  Branch (88:7): [True: 6.97M, False: 0]
  ------------------
   89|       |    // Much faster to call find on a single character than on an
   90|       |    // absl::string_view.
   91|  6.97M|    size_t found_pos = text.find(delimiter_[0], pos);
   92|  6.97M|    if (found_pos == absl::string_view::npos)
  ------------------
  |  Branch (92:9): [True: 1.29k, False: 6.96M]
  ------------------
   93|  1.29k|      return absl::string_view(text.data() + text.size(), 0);
   94|  6.96M|    return text.substr(found_pos, 1);
   95|  6.97M|  }
   96|      0|  return GenericFind(text, delimiter_, pos, LiteralPolicy());
   97|  6.97M|}

_ZN4absl8StrSplitIPKcEENS_16strings_internal8SplitterINS3_15SelectDelimiterIT_E4typeENS_10AllowEmptyENS_11string_viewEEENS3_23ConvertibleToStringViewES6_:
  517|  1.29k|StrSplit(strings_internal::ConvertibleToStringView text, Delimiter d) {
  518|  1.29k|  using DelimiterType =
  519|  1.29k|      typename strings_internal::SelectDelimiter<Delimiter>::type;
  520|  1.29k|  return strings_internal::Splitter<DelimiterType, AllowEmpty,
  521|  1.29k|                                    absl::string_view>(
  522|  1.29k|      text.value(), DelimiterType(d), AllowEmpty());
  523|  1.29k|}
_ZNK4absl10AllowEmptyclENS_11string_viewE:
  348|  6.97M|  bool operator()(absl::string_view) const { return true; }

_ZNK4absl11string_view4findEcm:
  118|  6.97M|string_view::size_type string_view::find(char c, size_type pos) const noexcept {
  119|  6.97M|  if (empty() || pos >= length_) {
  ------------------
  |  Branch (119:7): [True: 0, False: 6.97M]
  |  Branch (119:18): [True: 0, False: 6.97M]
  ------------------
  120|      0|    return npos;
  121|      0|  }
  122|  6.97M|  const char* result =
  123|  6.97M|      static_cast<const char*>(memchr(ptr_ + pos, c, length_ - pos));
  124|  6.97M|  return result != nullptr ? static_cast<size_type>(result - ptr_) : npos;
  ------------------
  |  Branch (124:10): [True: 6.96M, False: 1.29k]
  ------------------
  125|  6.97M|}

_ZN4absl11string_viewC2EPKcm:
  204|  20.9M|      : ptr_(data), length_(CheckLengthInternal(len)) {}
_ZN4absl11string_view19CheckLengthInternalEm:
  668|  20.9M|  static constexpr size_type CheckLengthInternal(size_type len) {
  669|  20.9M|    return ABSL_HARDENING_ASSERT(len <= kMaxSize), len;
  ------------------
  |  |  128|  20.9M|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |   95|  20.9M|  (false ? static_cast<void>(expr) : static_cast<void>(0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (95:4): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  670|  20.9M|  }
_ZN4absl11string_viewC2EPKc:
  200|  21.0k|      : ptr_(str), length_(str ? StrlenInternal(str) : 0) {}
_ZN4absl11string_view14StrlenInternalEPKc:
  672|  21.0k|  static constexpr size_type StrlenInternal(absl::Nonnull<const char*> str) {
  673|       |#if defined(_MSC_VER) && !defined(__clang__)
  674|       |    // MSVC 2017+ can evaluate this at compile-time.
  675|       |    const char* begin = str;
  676|       |    while (*str != '\0') ++str;
  677|       |    return str - begin;
  678|       |#elif ABSL_HAVE_BUILTIN(__builtin_strlen) || \
  679|       |    (defined(__GNUC__) && !defined(__clang__))
  680|       |    // GCC has __builtin_strlen according to
  681|       |    // https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html, but
  682|       |    // ABSL_HAVE_BUILTIN doesn't detect that, so we use the extra checks above.
  683|       |    // __builtin_strlen is constexpr.
  684|  21.0k|    return __builtin_strlen(str);
  685|       |#else
  686|       |    return str ? strlen(str) : 0;
  687|       |#endif
  688|  21.0k|  }
_ZN4absl11string_viewC2INSt3__19allocatorIcEEEERKNS2_12basic_stringIcNS2_11char_traitsIcEET_EE:
  192|  10.3k|      : string_view(str.data(), str.size(), SkipCheckLengthTag{}) {}
_ZN4absl11string_viewC2EPKcmNS0_18SkipCheckLengthTagE:
  663|  10.3k|      : ptr_(data), length_(len) {}
_ZNK4absl11string_view4dataEv:
  332|  55.8M|  constexpr const_pointer data() const noexcept { return ptr_; }
_ZNK4absl11string_view4sizeEv:
  273|  55.8M|  constexpr size_type size() const noexcept { return length_; }
_ZN4absl11string_viewC2Ev:
  180|  2.57k|  constexpr string_view() noexcept : ptr_(nullptr), length_(0) {}
_ZNK4absl11string_view6substrEmm:
  395|  13.9M|  constexpr string_view substr(size_type pos = 0, size_type n = npos) const {
  396|  13.9M|    return ABSL_PREDICT_FALSE(pos > length_)
  ------------------
  |  |  178|  13.9M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 13.9M]
  |  |  |  Branch (178:49): [Folded - Ignored]
  |  |  |  Branch (178:58): [True: 0, False: 13.9M]
  |  |  ------------------
  ------------------
  397|  13.9M|               ? (base_internal::ThrowStdOutOfRange(
  398|      0|                      "absl::string_view::substr"),
  399|      0|                  string_view())
  400|  13.9M|               : string_view(ptr_ + pos, Min(n, length_ - pos));
  401|  13.9M|  }
_ZN4absl11string_view3MinEmm:
  690|  13.9M|  static constexpr size_t Min(size_type length_a, size_type length_b) {
  691|  13.9M|    return length_a < length_b ? length_a : length_b;
  ------------------
  |  Branch (691:12): [True: 13.9M, False: 6.47k]
  ------------------
  692|  13.9M|  }
_ZNK4absl11string_viewcvNSt3__112basic_stringIcNS1_11char_traitsIcEET_EEINS1_9allocatorIcEEEEv:
  368|  6.97M|  explicit operator std::basic_string<char, traits_type, A>() const {
  369|  6.97M|    if (!data()) return {};
  ------------------
  |  Branch (369:9): [True: 0, False: 6.97M]
  ------------------
  370|  6.97M|    return std::basic_string<char, traits_type, A>(data(), size());
  371|  6.97M|  }
_ZNK4absl11string_view5beginEv:
  216|  10.3k|  constexpr const_iterator begin() const noexcept { return ptr_; }
_ZNK4absl11string_view3endEv:
  223|  5.17k|  constexpr const_iterator end() const noexcept { return ptr_ + length_; }
_ZNK4absl11string_view6rbeginEv:
  242|  2.58k|  const_reverse_iterator rbegin() const noexcept {
  243|  2.58k|    return const_reverse_iterator(end());
  244|  2.58k|  }
_ZNK4absl11string_view4rendEv:
  251|  5.17k|  const_reverse_iterator rend() const noexcept {
  252|  5.17k|    return const_reverse_iterator(begin());
  253|  5.17k|  }
_ZNK4absl11string_view5emptyEv:
  288|  6.97M|  constexpr bool empty() const noexcept { return length_ == 0; }
_ZNK4absl11string_viewixEm:
  294|  2.58k|  constexpr const_reference operator[](size_type i) const {
  295|  2.58k|    return ABSL_HARDENING_ASSERT(i < size()), ptr_[i];
  ------------------
  |  |  128|  2.58k|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |   95|  2.58k|  (false ? static_cast<void>(expr) : static_cast<void>(0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (95:4): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  296|  2.58k|  }

_ZN4absl4SpanIKNS_19str_format_internal13FormatArgImplEEC2IS3_S3_EESt16initializer_listIS2_E:
  273|  5.17k|      : Span(v.begin(), v.size()) {}
_ZN4absl4SpanIKNS_19str_format_internal13FormatArgImplEEC2EPS3_m:
  193|  5.17k|      : ptr_(array), len_(length) {}
_ZNK4absl4SpanIKNS_19str_format_internal13FormatArgImplEE4sizeEv:
  286|  5.17k|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl4SpanIKNS_19str_format_internal13FormatArgImplEEixEm:
  301|  5.17k|  constexpr reference operator[](size_type i) const noexcept {
  302|  5.17k|    return ABSL_HARDENING_ASSERT(i < size()), ptr_[i];
  ------------------
  |  |  128|  5.17k|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |   95|  5.17k|  (false ? static_cast<void>(expr) : static_cast<void>(0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (95:4): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  303|  5.17k|  }

LLVMFuzzerTestOneInput:
   28|  1.29k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   29|  1.29k|	FuzzedDataProvider fuzzed_data(data, size);
   30|  1.29k|	float float_value = fuzzed_data.ConsumeFloatingPoint<float>();
   31|  1.29k|	double double_value = fuzzed_data.ConsumeFloatingPoint<double>();
   32|  1.29k|	int int_value = fuzzed_data.ConsumeIntegral<int>();
   33|  1.29k|	bool bool_value = fuzzed_data.ConsumeBool();
   34|  1.29k|	std::string str1 = fuzzed_data.ConsumeRandomLengthString();
   35|  1.29k|	std::string str2 = fuzzed_data.ConsumeRemainingBytesAsString();
   36|       |
   37|  1.29k|	std::string float_str = absl::StrFormat("%g", float_value);
   38|  1.29k|	std::string double_str = absl::StrFormat("%g", double_value);
   39|  1.29k|	std::string int_str = absl::StrFormat("%d", int_value);
   40|  1.29k|	std::string bool_str = absl::StrFormat("%d", bool_value);
   41|       |	
   42|  1.29k|	if (!absl::SimpleAtof(float_str, &float_value))
  ------------------
  |  Branch (42:6): [True: 0, False: 1.29k]
  ------------------
   43|      0|		return 0;
   44|  1.29k|	if (!absl::SimpleAtod(double_str, &double_value))
  ------------------
  |  Branch (44:6): [True: 0, False: 1.29k]
  ------------------
   45|      0|		return 0;
   46|  1.29k|	if (!absl::SimpleAtoi(int_str, &int_value))
  ------------------
  |  Branch (46:6): [True: 0, False: 1.29k]
  ------------------
   47|      0|		return 0;
   48|  1.29k|	if (!absl::SimpleAtob(bool_str, &bool_value))
  ------------------
  |  Branch (48:6): [True: 0, False: 1.29k]
  ------------------
   49|      0|		return 0;
   50|       |
   51|  1.29k|	absl::StrAppend(&str1, str2);
   52|  1.29k|	std::string str_result = absl::StrCat(str1, float_value, double_value, int_value, bool_value);
   53|  1.29k|	std::vector<std::string> v = absl::StrSplit(str_result, ".");
   54|  1.29k|	absl::StrJoin(v, ".");
   55|  1.29k|	return 0;
   56|  1.29k|}