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

_ZN4absl13little_endian10FromHost16Et:
  107|  12.0k|inline uint16_t FromHost16(uint16_t x) { return x; }
_ZN4absl13little_endian10FromHost64Em:
  113|  2.46k|inline uint64_t FromHost64(uint64_t x) { return x; }
_ZN4absl13little_endian7Store16EPvt:
  168|  12.0k|inline void Store16(absl::Nonnull<void *> p, uint16_t v) {
  169|  12.0k|  ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
  ------------------
  |  |   81|  12.0k|  (absl::base_internal::UnalignedStore16(_p, _val))
  ------------------
  170|  12.0k|}
_ZN4absl13little_endian7Store64EPvm:
  184|  2.46k|inline void Store64(absl::Nonnull<void *> p, uint64_t v) {
  185|  2.46k|  ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
  ------------------
  |  |   85|  2.46k|  (absl::base_internal::UnalignedStore64(_p, _val))
  ------------------
  186|  2.46k|}

_ZN4absl13base_internal16UnalignedStore16EPvt:
   57|  12.0k|inline void UnalignedStore16(absl::Nonnull<void *> p, uint16_t v) {
   58|  12.0k|  memcpy(p, &v, sizeof v);
   59|  12.0k|}
_ZN4absl13base_internal16UnalignedStore64EPvm:
   65|  2.46k|inline void UnalignedStore64(absl::Nonnull<void *> p, uint64_t v) {
   66|  2.46k|  memcpy(p, &v, sizeof v);
   67|  2.46k|}

_ZN4absl11countl_zeroImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES3_:
  103|  2.44k|    countl_zero(T x) noexcept {
  104|  2.44k|  return numeric_internal::CountLeadingZeroes(x);
  105|  2.44k|}
_ZN4absl11countr_zeroImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES3_:
  118|    156|    countr_zero(T x) noexcept {
  119|    156|  return numeric_internal::CountTrailingZeroes(x);
  120|    156|}

_ZN4absl7uint128pLES0_:
  618|     69|inline uint128& uint128::operator+=(uint128 other) {
  619|     69|  *this = *this + other;
  620|     69|  return *this;
  621|     69|}
_ZN4absl12Uint128Low64ENS_7uint128E:
  643|  2.57k|constexpr uint64_t Uint128Low64(uint128 v) { return v.lo_; }
_ZN4absl13Uint128High64ENS_7uint128E:
  645|  7.57k|constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; }
_ZNK4absl7uint128cvoEv:
  776|  5.16k|constexpr uint128::operator unsigned __int128() const {
  777|  5.16k|  return (static_cast<unsigned __int128>(hi_) << 64) + lo_;
  778|  5.16k|}
_ZN4abslplENS_7uint128ES0_:
  977|     69|constexpr uint128 operator+(uint128 lhs, uint128 rhs) {
  978|     69|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  979|     69|  return static_cast<unsigned __int128>(lhs) +
  980|     69|         static_cast<unsigned __int128>(rhs);
  981|       |#else
  982|       |  return int128_internal::AddResult(
  983|       |      MakeUint128(Uint128High64(lhs) + Uint128High64(rhs),
  984|       |                  Uint128Low64(lhs) + Uint128Low64(rhs)),
  985|       |      lhs);
  986|       |#endif
  987|     69|}
_ZN4abslmlENS_7uint128ES0_:
 1012|  2.51k|inline uint128 operator*(uint128 lhs, uint128 rhs) {
 1013|  2.51k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
 1014|       |  // TODO(strel) Remove once alignment issues are resolved and unsigned __int128
 1015|       |  // can be used for uint128 storage.
 1016|  2.51k|  return static_cast<unsigned __int128>(lhs) *
 1017|  2.51k|         static_cast<unsigned __int128>(rhs);
 1018|       |#elif defined(_MSC_VER) && defined(_M_X64) && !defined(_M_ARM64EC)
 1019|       |  uint64_t carry;
 1020|       |  uint64_t low = _umul128(Uint128Low64(lhs), Uint128Low64(rhs), &carry);
 1021|       |  return MakeUint128(Uint128Low64(lhs) * Uint128High64(rhs) +
 1022|       |                         Uint128High64(lhs) * Uint128Low64(rhs) + carry,
 1023|       |                     low);
 1024|       |#else   // ABSL_HAVE_INTRINSIC128
 1025|       |  uint64_t a32 = Uint128Low64(lhs) >> 32;
 1026|       |  uint64_t a00 = Uint128Low64(lhs) & 0xffffffff;
 1027|       |  uint64_t b32 = Uint128Low64(rhs) >> 32;
 1028|       |  uint64_t b00 = Uint128Low64(rhs) & 0xffffffff;
 1029|       |  uint128 result =
 1030|       |      MakeUint128(Uint128High64(lhs) * Uint128Low64(rhs) +
 1031|       |                      Uint128Low64(lhs) * Uint128High64(rhs) + a32 * b32,
 1032|       |                  a00 * b00);
 1033|       |  result += uint128(a32 * b00) << 32;
 1034|       |  result += uint128(a00 * b32) << 32;
 1035|       |  return result;
 1036|       |#endif  // ABSL_HAVE_INTRINSIC128
 1037|  2.51k|}
_ZN4absl7uint128C2Eo:
  675|  2.58k|      hi_{static_cast<uint64_t>(v >> 64)} {}
_ZN4absl7uint128C2Em:
  665|  5.09k|constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {}

_ZN4absl16numeric_internal20CountLeadingZeroes64Em:
  182|  2.44k|CountLeadingZeroes64(uint64_t x) {
  183|  2.44k|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clzll)
  184|       |  // Use __builtin_clzll, which uses the following instructions:
  185|       |  //  x86: bsr, lzcnt
  186|       |  //  ARM64: clz
  187|       |  //  PPC: cntlzd
  188|  2.44k|  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
  189|  2.44k|                "__builtin_clzll does not take 64-bit arg");
  190|       |
  191|       |  // Handle 0 as a special case because __builtin_clzll(0) is undefined.
  192|  2.44k|  return x == 0 ? 64 : __builtin_clzll(x);
  ------------------
  |  Branch (192:10): [True: 0, False: 2.44k]
  ------------------
  193|       |#elif defined(_MSC_VER) && !defined(__clang__) && \
  194|       |    (defined(_M_X64) || defined(_M_ARM64))
  195|       |  // MSVC does not have __buitin_clzll. Use _BitScanReverse64.
  196|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  197|       |  if (_BitScanReverse64(&result, x)) {
  198|       |    return 63 - result;
  199|       |  }
  200|       |  return 64;
  201|       |#elif defined(_MSC_VER) && !defined(__clang__)
  202|       |  // MSVC does not have __buitin_clzll. Compose two calls to _BitScanReverse
  203|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  204|       |  if ((x >> 32) &&
  205|       |      _BitScanReverse(&result, static_cast<unsigned long>(x >> 32))) {
  206|       |    return 31 - result;
  207|       |  }
  208|       |  if (_BitScanReverse(&result, static_cast<unsigned long>(x))) {
  209|       |    return 63 - result;
  210|       |  }
  211|       |  return 64;
  212|       |#else
  213|       |  int zeroes = 60;
  214|       |  if (x >> 32) {
  215|       |    zeroes -= 32;
  216|       |    x >>= 32;
  217|       |  }
  218|       |  if (x >> 16) {
  219|       |    zeroes -= 16;
  220|       |    x >>= 16;
  221|       |  }
  222|       |  if (x >> 8) {
  223|       |    zeroes -= 8;
  224|       |    x >>= 8;
  225|       |  }
  226|       |  if (x >> 4) {
  227|       |    zeroes -= 4;
  228|       |    x >>= 4;
  229|       |  }
  230|       |  return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[x] + zeroes;
  231|       |#endif
  232|  2.44k|}
_ZN4absl16numeric_internal28CountTrailingZeroesNonzero64Em:
  275|    156|CountTrailingZeroesNonzero64(uint64_t x) {
  276|    156|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctzll)
  277|    156|  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
  278|    156|                "__builtin_ctzll does not take 64-bit arg");
  279|    156|  return __builtin_ctzll(x);
  280|       |#elif defined(_MSC_VER) && !defined(__clang__) && \
  281|       |    (defined(_M_X64) || defined(_M_ARM64))
  282|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  283|       |  _BitScanForward64(&result, x);
  284|       |  return result;
  285|       |#elif defined(_MSC_VER) && !defined(__clang__)
  286|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  287|       |  if (static_cast<uint32_t>(x) == 0) {
  288|       |    _BitScanForward(&result, static_cast<unsigned long>(x >> 32));
  289|       |    return result + 32;
  290|       |  }
  291|       |  _BitScanForward(&result, static_cast<unsigned long>(x));
  292|       |  return result;
  293|       |#else
  294|       |  int c = 63;
  295|       |  x &= ~x + 1;
  296|       |  if (x & 0x00000000FFFFFFFF) c -= 32;
  297|       |  if (x & 0x0000FFFF0000FFFF) c -= 16;
  298|       |  if (x & 0x00FF00FF00FF00FF) c -= 8;
  299|       |  if (x & 0x0F0F0F0F0F0F0F0F) c -= 4;
  300|       |  if (x & 0x3333333333333333) c -= 2;
  301|       |  if (x & 0x5555555555555555) c -= 1;
  302|       |  return c;
  303|       |#endif
  304|    156|}
_ZN4absl16numeric_internal18CountLeadingZeroesImEEiT_:
  236|  2.44k|CountLeadingZeroes(T x) {
  237|  2.44k|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  238|  2.44k|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  239|  2.44k|                "T must have a power-of-2 size");
  240|  2.44k|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  241|  2.44k|  return sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (241:10): [Folded - Ignored]
  ------------------
  242|  2.44k|             ? CountLeadingZeroes16(static_cast<uint16_t>(x)) -
  243|      0|                   (std::numeric_limits<uint16_t>::digits -
  244|      0|                    std::numeric_limits<T>::digits)
  245|  2.44k|             : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (245:17): [Folded - Ignored]
  ------------------
  246|  2.44k|                    ? CountLeadingZeroes32(static_cast<uint32_t>(x)) -
  247|      0|                          (std::numeric_limits<uint32_t>::digits -
  248|      0|                           std::numeric_limits<T>::digits)
  249|  2.44k|                    : CountLeadingZeroes64(x));
  250|  2.44k|}
_ZN4absl16numeric_internal19CountTrailingZeroesImEEiT_:
  321|    156|CountTrailingZeroes(T x) noexcept {
  322|    156|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  323|    156|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  324|    156|                "T must have a power-of-2 size");
  325|    156|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  326|    156|  return x == 0 ? std::numeric_limits<T>::digits
  ------------------
  |  Branch (326:10): [True: 0, False: 156]
  ------------------
  327|    156|                : (sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (327:20): [Folded - Ignored]
  ------------------
  328|    156|                       ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x))
  329|    156|                       : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (329:27): [Folded - Ignored]
  ------------------
  330|    156|                              ? CountTrailingZeroesNonzero32(
  331|      0|                                    static_cast<uint32_t>(x))
  332|    156|                              : CountTrailingZeroesNonzero64(x)));
  333|    156|}

_ZN4absl13ascii_isspaceEh:
  105|  7.44k|inline bool ascii_isspace(unsigned char c) {
  106|  7.44k|  return (ascii_internal::kPropertyBits[c] & 0x08) != 0;
  107|  7.44k|}
_ZN4absl27StripLeadingAsciiWhitespaceENS_11string_viewE:
  230|  2.48k|    absl::string_view str) {
  231|  2.48k|  auto it = std::find_if_not(str.begin(), str.end(), absl::ascii_isspace);
  232|  2.48k|  return str.substr(static_cast<size_t>(it - str.begin()));
  233|  2.48k|}
_ZN4absl28StripTrailingAsciiWhitespaceENS_11string_viewE:
  244|  2.48k|    absl::string_view str) {
  245|  2.48k|  auto it = std::find_if_not(str.rbegin(), str.rend(), absl::ascii_isspace);
  246|  2.48k|  return str.substr(0, static_cast<size_t>(str.rend() - it));
  247|  2.48k|}
_ZN4absl20StripAsciiWhitespaceENS_11string_viewE:
  258|  2.48k|    absl::string_view str) {
  259|  2.48k|  return StripTrailingAsciiWhitespace(StripLeadingAsciiWhitespace(str));
  260|  2.48k|}

_ZN4absl10from_charsEPKcS1_RdNS_12chars_formatE:
  953|  1.24k|                             chars_format fmt) {
  954|  1.24k|  return FromCharsImpl(first, last, value, fmt);
  955|  1.24k|}
_ZN4absl10from_charsEPKcS1_RfNS_12chars_formatE:
  959|  1.24k|                             chars_format fmt) {
  960|  1.24k|  return FromCharsImpl(first, last, value, fmt);
  961|  1.24k|}
charconv.cc:_ZN4absl12_GLOBAL__N_113FromCharsImplIdEENS_17from_chars_resultEPKcS4_RT_NS_12chars_formatE:
  866|  1.24k|                                FloatType& value, chars_format fmt_flags) {
  867|  1.24k|  from_chars_result result;
  868|  1.24k|  result.ptr = first;  // overwritten on successful parse
  869|  1.24k|  result.ec = std::errc();
  870|       |
  871|  1.24k|  bool negative = false;
  872|  1.24k|  if (first != last && *first == '-') {
  ------------------
  |  Branch (872:7): [True: 1.24k, False: 0]
  |  Branch (872:24): [True: 850, False: 391]
  ------------------
  873|    850|    ++first;
  874|    850|    negative = true;
  875|    850|  }
  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.24k|  if ((fmt_flags & chars_format::hex) == chars_format{} && last - first >= 2 &&
  ------------------
  |  Branch (878:7): [True: 1.24k, False: 0]
  |  Branch (878:60): [True: 1.22k, False: 14]
  ------------------
  879|  1.24k|      *first == '0' && (first[1] == 'x' || first[1] == 'X')) {
  ------------------
  |  Branch (879:7): [True: 0, False: 1.22k]
  |  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.24k|  if ((fmt_flags & chars_format::hex) == chars_format::hex) {
  ------------------
  |  Branch (911:7): [True: 0, False: 1.24k]
  ------------------
  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.24k|  } else {
  927|  1.24k|    strings_internal::ParsedFloat decimal_parse =
  928|  1.24k|        strings_internal::ParseFloat<10>(first, last, fmt_flags);
  929|  1.24k|    if (decimal_parse.end == nullptr) {
  ------------------
  |  Branch (929:9): [True: 0, False: 1.24k]
  ------------------
  930|      0|      result.ec = std::errc::invalid_argument;
  931|      0|      return result;
  932|      0|    }
  933|  1.24k|    result.ptr = decimal_parse.end;
  934|  1.24k|    if (HandleEdgeCase(decimal_parse, negative, &value)) {
  ------------------
  |  Branch (934:9): [True: 14, False: 1.22k]
  ------------------
  935|     14|      return result;
  936|     14|    }
  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.22k|    if ((decimal_parse.subrange_begin == nullptr) &&
  ------------------
  |  Branch (939:9): [True: 1.22k, False: 0]
  ------------------
  940|  1.22k|        EiselLemire<FloatType>(decimal_parse, negative, &value, &result.ec)) {
  ------------------
  |  Branch (940:9): [True: 1.22k, False: 0]
  ------------------
  941|  1.22k|      return result;
  942|  1.22k|    }
  943|      0|    CalculatedFloat calculated =
  944|      0|        CalculateFromParsedDecimal<FloatType>(decimal_parse);
  945|      0|    EncodeResult(calculated, negative, &result, &value);
  946|      0|    return result;
  947|  1.22k|  }
  948|  1.24k|}
charconv.cc:_ZN4absl12_GLOBAL__N_114HandleEdgeCaseIdEEbRKNS_16strings_internal11ParsedFloatEbPT_:
  360|  1.24k|                    absl::Nonnull<FloatType*> value) {
  361|  1.24k|  if (input.type == strings_internal::FloatType::kNan) {
  ------------------
  |  Branch (361:7): [True: 0, False: 1.24k]
  ------------------
  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.24k|  if (input.type == strings_internal::FloatType::kInfinity) {
  ------------------
  |  Branch (389:7): [True: 0, False: 1.24k]
  ------------------
  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.24k|  if (input.mantissa == 0) {
  ------------------
  |  Branch (394:7): [True: 14, False: 1.22k]
  ------------------
  395|     14|    *value = negative ? -0.0 : 0.0;
  ------------------
  |  Branch (395:14): [True: 0, False: 14]
  ------------------
  396|     14|    return true;
  397|     14|  }
  398|  1.22k|  return false;
  399|  1.24k|}
charconv.cc:_ZN4absl12_GLOBAL__N_111EiselLemireIdEEbRKNS_16strings_internal11ParsedFloatEbPT_PNSt3__14errcE:
  691|  1.22k|                 absl::Nonnull<std::errc*> ec) {
  692|  1.22k|  uint64_t man = input.mantissa;
  693|  1.22k|  int exp10 = input.exponent;
  694|  1.22k|  if (exp10 < FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10) {
  ------------------
  |  Branch (694:7): [True: 0, False: 1.22k]
  ------------------
  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.22k|  } else if (exp10 >= FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10) {
  ------------------
  |  Branch (698:14): [True: 0, False: 1.22k]
  ------------------
  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.22k|  static_assert(
  710|  1.22k|      FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10 >=
  711|  1.22k|          kPower10TableMinInclusive,
  712|  1.22k|      "(exp10-kPower10TableMinInclusive) in kPower10MantissaHighTable bounds");
  713|  1.22k|  static_assert(
  714|  1.22k|      FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10 <=
  715|  1.22k|          kPower10TableMaxExclusive,
  716|  1.22k|      "(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.22k|  int clz = countl_zero(man);
  732|  1.22k|  man <<= static_cast<unsigned int>(clz);
  733|       |  // The 217706 etc magic numbers are from the Power10Exponent function.
  734|  1.22k|  uint64_t ret_exp2 =
  735|  1.22k|      static_cast<uint64_t>((217706 * exp10 >> 16) + 64 +
  736|  1.22k|                            FloatTraits<FloatType>::kExponentBias - clz);
  737|       |
  738|       |  // (+) Multiplication.
  739|  1.22k|  uint128 x = static_cast<uint128>(man) *
  740|  1.22k|              static_cast<uint128>(
  741|  1.22k|                  kPower10MantissaHighTable[exp10 - kPower10TableMinInclusive]);
  742|       |
  743|       |  // (+) Wider Approximation.
  744|  1.22k|  static constexpr uint64_t high64_mask =
  745|  1.22k|      FloatTraits<FloatType>::kEiselLemireMask;
  746|  1.22k|  if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (746:7): [True: 75, False: 1.15k]
  ------------------
  747|  1.22k|      (man > (std::numeric_limits<uint64_t>::max() - Uint128Low64(x)))) {
  ------------------
  |  Branch (747:7): [True: 69, False: 6]
  ------------------
  748|     69|    uint128 y =
  749|     69|        static_cast<uint128>(man) *
  750|     69|        static_cast<uint128>(
  751|     69|            kPower10MantissaLowTable[exp10 - kPower10TableMinInclusive]);
  752|     69|    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|     69|    if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (762:9): [True: 51, False: 18]
  ------------------
  763|     69|        ((Uint128Low64(x) + 1) == 0) &&
  ------------------
  |  Branch (763:9): [True: 0, False: 51]
  ------------------
  764|     69|        (man > (std::numeric_limits<uint64_t>::max() - Uint128Low64(y)))) {
  ------------------
  |  Branch (764:9): [True: 0, False: 0]
  ------------------
  765|      0|      return false;
  766|      0|    }
  767|     69|  }
  768|       |
  769|       |  // (+) Shifting to 54 Bits (or for single precision, to 25 bits).
  770|  1.22k|  uint64_t msb = Uint128High64(x) >> 63;
  771|  1.22k|  uint64_t ret_man =
  772|  1.22k|      Uint128High64(x) >> (msb + FloatTraits<FloatType>::kEiselLemireShift);
  773|  1.22k|  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.22k|  if ((Uint128Low64(x) == 0) && ((Uint128High64(x) & high64_mask) == 0) &&
  ------------------
  |  Branch (784:7): [True: 8, False: 1.21k]
  |  Branch (784:33): [True: 0, False: 8]
  ------------------
  785|  1.22k|      ((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.22k|  ret_man += ret_man & 1;  // Line From54a.
  791|  1.22k|  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.22k|  if ((ret_man >> FloatTraits<FloatType>::kTargetMantissaBits) > 0) {
  ------------------
  |  Branch (800:7): [True: 0, False: 1.22k]
  ------------------
  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.22k|  static constexpr uint64_t max_exp2 =
  825|  1.22k|      (1 << FloatTraits<FloatType>::kTargetExponentBits) - 1;
  826|  1.22k|  if ((ret_exp2 - 1) >= (max_exp2 - 1)) {
  ------------------
  |  Branch (826:7): [True: 0, False: 1.22k]
  ------------------
  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.22k|  if (FloatTraits<FloatType>::kTargetBits == 64) {
  ------------------
  |  Branch (843:7): [Folded - Ignored]
  ------------------
  844|  1.22k|    uint64_t ret_bits = (ret_exp2 << 52) | (ret_man & 0x000FFFFFFFFFFFFFu);
  845|  1.22k|    if (negative) {
  ------------------
  |  Branch (845:9): [True: 850, False: 377]
  ------------------
  846|    850|      ret_bits |= 0x8000000000000000u;
  847|    850|    }
  848|  1.22k|    *value = absl::bit_cast<double>(ret_bits);
  849|  1.22k|    return true;
  850|  1.22k|  } 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.22k|}
charconv.cc:_ZN4absl12_GLOBAL__N_113FromCharsImplIfEENS_17from_chars_resultEPKcS4_RT_NS_12chars_formatE:
  866|  1.24k|                                FloatType& value, chars_format fmt_flags) {
  867|  1.24k|  from_chars_result result;
  868|  1.24k|  result.ptr = first;  // overwritten on successful parse
  869|  1.24k|  result.ec = std::errc();
  870|       |
  871|  1.24k|  bool negative = false;
  872|  1.24k|  if (first != last && *first == '-') {
  ------------------
  |  Branch (872:7): [True: 1.24k, False: 0]
  |  Branch (872:24): [True: 722, False: 519]
  ------------------
  873|    722|    ++first;
  874|    722|    negative = true;
  875|    722|  }
  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.24k|  if ((fmt_flags & chars_format::hex) == chars_format{} && last - first >= 2 &&
  ------------------
  |  Branch (878:7): [True: 1.24k, False: 0]
  |  Branch (878:60): [True: 1.21k, False: 23]
  ------------------
  879|  1.24k|      *first == '0' && (first[1] == 'x' || first[1] == 'X')) {
  ------------------
  |  Branch (879:7): [True: 0, False: 1.21k]
  |  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.24k|  if ((fmt_flags & chars_format::hex) == chars_format::hex) {
  ------------------
  |  Branch (911:7): [True: 0, False: 1.24k]
  ------------------
  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.24k|  } else {
  927|  1.24k|    strings_internal::ParsedFloat decimal_parse =
  928|  1.24k|        strings_internal::ParseFloat<10>(first, last, fmt_flags);
  929|  1.24k|    if (decimal_parse.end == nullptr) {
  ------------------
  |  Branch (929:9): [True: 0, False: 1.24k]
  ------------------
  930|      0|      result.ec = std::errc::invalid_argument;
  931|      0|      return result;
  932|      0|    }
  933|  1.24k|    result.ptr = decimal_parse.end;
  934|  1.24k|    if (HandleEdgeCase(decimal_parse, negative, &value)) {
  ------------------
  |  Branch (934:9): [True: 23, False: 1.21k]
  ------------------
  935|     23|      return result;
  936|     23|    }
  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.21k|    if ((decimal_parse.subrange_begin == nullptr) &&
  ------------------
  |  Branch (939:9): [True: 1.21k, False: 0]
  ------------------
  940|  1.21k|        EiselLemire<FloatType>(decimal_parse, negative, &value, &result.ec)) {
  ------------------
  |  Branch (940:9): [True: 1.21k, False: 0]
  ------------------
  941|  1.21k|      return result;
  942|  1.21k|    }
  943|      0|    CalculatedFloat calculated =
  944|      0|        CalculateFromParsedDecimal<FloatType>(decimal_parse);
  945|      0|    EncodeResult(calculated, negative, &result, &value);
  946|      0|    return result;
  947|  1.21k|  }
  948|  1.24k|}
charconv.cc:_ZN4absl12_GLOBAL__N_114HandleEdgeCaseIfEEbRKNS_16strings_internal11ParsedFloatEbPT_:
  360|  1.24k|                    absl::Nonnull<FloatType*> value) {
  361|  1.24k|  if (input.type == strings_internal::FloatType::kNan) {
  ------------------
  |  Branch (361:7): [True: 0, False: 1.24k]
  ------------------
  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.24k|  if (input.type == strings_internal::FloatType::kInfinity) {
  ------------------
  |  Branch (389:7): [True: 0, False: 1.24k]
  ------------------
  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.24k|  if (input.mantissa == 0) {
  ------------------
  |  Branch (394:7): [True: 23, False: 1.21k]
  ------------------
  395|     23|    *value = negative ? -0.0 : 0.0;
  ------------------
  |  Branch (395:14): [True: 0, False: 23]
  ------------------
  396|     23|    return true;
  397|     23|  }
  398|  1.21k|  return false;
  399|  1.24k|}
charconv.cc:_ZN4absl12_GLOBAL__N_111EiselLemireIfEEbRKNS_16strings_internal11ParsedFloatEbPT_PNSt3__14errcE:
  691|  1.21k|                 absl::Nonnull<std::errc*> ec) {
  692|  1.21k|  uint64_t man = input.mantissa;
  693|  1.21k|  int exp10 = input.exponent;
  694|  1.21k|  if (exp10 < FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10) {
  ------------------
  |  Branch (694:7): [True: 0, False: 1.21k]
  ------------------
  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.21k|  } else if (exp10 >= FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10) {
  ------------------
  |  Branch (698:14): [True: 0, False: 1.21k]
  ------------------
  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.21k|  static_assert(
  710|  1.21k|      FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10 >=
  711|  1.21k|          kPower10TableMinInclusive,
  712|  1.21k|      "(exp10-kPower10TableMinInclusive) in kPower10MantissaHighTable bounds");
  713|  1.21k|  static_assert(
  714|  1.21k|      FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10 <=
  715|  1.21k|          kPower10TableMaxExclusive,
  716|  1.21k|      "(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.21k|  int clz = countl_zero(man);
  732|  1.21k|  man <<= static_cast<unsigned int>(clz);
  733|       |  // The 217706 etc magic numbers are from the Power10Exponent function.
  734|  1.21k|  uint64_t ret_exp2 =
  735|  1.21k|      static_cast<uint64_t>((217706 * exp10 >> 16) + 64 +
  736|  1.21k|                            FloatTraits<FloatType>::kExponentBias - clz);
  737|       |
  738|       |  // (+) Multiplication.
  739|  1.21k|  uint128 x = static_cast<uint128>(man) *
  740|  1.21k|              static_cast<uint128>(
  741|  1.21k|                  kPower10MantissaHighTable[exp10 - kPower10TableMinInclusive]);
  742|       |
  743|       |  // (+) Wider Approximation.
  744|  1.21k|  static constexpr uint64_t high64_mask =
  745|  1.21k|      FloatTraits<FloatType>::kEiselLemireMask;
  746|  1.21k|  if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (746:7): [True: 0, False: 1.21k]
  ------------------
  747|  1.21k|      (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.21k|  uint64_t msb = Uint128High64(x) >> 63;
  771|  1.21k|  uint64_t ret_man =
  772|  1.21k|      Uint128High64(x) >> (msb + FloatTraits<FloatType>::kEiselLemireShift);
  773|  1.21k|  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.21k|  if ((Uint128Low64(x) == 0) && ((Uint128High64(x) & high64_mask) == 0) &&
  ------------------
  |  Branch (784:7): [True: 93, False: 1.12k]
  |  Branch (784:33): [True: 0, False: 93]
  ------------------
  785|  1.21k|      ((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.21k|  ret_man += ret_man & 1;  // Line From54a.
  791|  1.21k|  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.21k|  if ((ret_man >> FloatTraits<FloatType>::kTargetMantissaBits) > 0) {
  ------------------
  |  Branch (800:7): [True: 0, False: 1.21k]
  ------------------
  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.21k|  static constexpr uint64_t max_exp2 =
  825|  1.21k|      (1 << FloatTraits<FloatType>::kTargetExponentBits) - 1;
  826|  1.21k|  if ((ret_exp2 - 1) >= (max_exp2 - 1)) {
  ------------------
  |  Branch (826:7): [True: 0, False: 1.21k]
  ------------------
  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.21k|  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.21k|  } else if (FloatTraits<FloatType>::kTargetBits == 32) {
  ------------------
  |  Branch (850:14): [Folded - Ignored]
  ------------------
  851|  1.21k|    uint32_t ret_bits = (static_cast<uint32_t>(ret_exp2) << 23) |
  852|  1.21k|                        (static_cast<uint32_t>(ret_man) & 0x007FFFFFu);
  853|  1.21k|    if (negative) {
  ------------------
  |  Branch (853:9): [True: 722, False: 496]
  ------------------
  854|    722|      ret_bits |= 0x80000000u;
  855|    722|    }
  856|  1.21k|    *value = absl::bit_cast<float>(ret_bits);
  857|  1.21k|    return true;
  858|  1.21k|  }
  859|      0|#endif  // ABSL_BIT_PACK_FLOATS
  860|      0|  return false;
  861|  1.21k|}

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

_ZN4absl16strings_internal10ParseFloatILi10EEENS0_11ParsedFloatEPKcS4_NS_12chars_formatE:
  356|  2.48k|                                         chars_format format_flags) {
  357|  2.48k|  strings_internal::ParsedFloat result;
  358|       |
  359|       |  // Exit early if we're given an empty range.
  360|  2.48k|  if (begin == end) return result;
  ------------------
  |  Branch (360:7): [True: 0, False: 2.48k]
  ------------------
  361|       |
  362|       |  // Handle the infinity and NaN cases.
  363|  2.48k|  if (ParseInfinityOrNan(begin, end, &result)) {
  ------------------
  |  Branch (363:7): [True: 0, False: 2.48k]
  ------------------
  364|      0|    return result;
  365|      0|  }
  366|       |
  367|  2.48k|  const char* const mantissa_begin = begin;
  368|  2.51k|  while (begin < end && *begin == '0') {
  ------------------
  |  Branch (368:10): [True: 2.48k, False: 37]
  |  Branch (368:25): [True: 37, False: 2.44k]
  ------------------
  369|     37|    ++begin;  // skip leading zeros
  370|     37|  }
  371|  2.48k|  uint64_t mantissa = 0;
  372|       |
  373|  2.48k|  int exponent_adjustment = 0;
  374|  2.48k|  bool mantissa_is_inexact = false;
  375|  2.48k|  int pre_decimal_digits = ConsumeDigits<base>(
  376|  2.48k|      begin, end, MantissaDigitsMax<base>(), &mantissa, &mantissa_is_inexact);
  377|  2.48k|  begin += pre_decimal_digits;
  378|  2.48k|  int digits_left;
  379|  2.48k|  if (pre_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (379:7): [True: 0, False: 2.48k]
  ------------------
  380|       |    // refuse to parse pathological inputs
  381|      0|    return result;
  382|  2.48k|  } else if (pre_decimal_digits > MantissaDigitsMax<base>()) {
  ------------------
  |  Branch (382:14): [True: 0, False: 2.48k]
  ------------------
  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.48k|  } else {
  389|  2.48k|    digits_left =
  390|  2.48k|        static_cast<int>(MantissaDigitsMax<base>() - pre_decimal_digits);
  391|  2.48k|  }
  392|  2.48k|  if (begin < end && *begin == '.') {
  ------------------
  |  Branch (392:7): [True: 2.44k, False: 37]
  |  Branch (392:22): [True: 2.27k, False: 171]
  ------------------
  393|  2.27k|    ++begin;
  394|  2.27k|    if (mantissa == 0) {
  ------------------
  |  Branch (394:9): [True: 0, False: 2.27k]
  ------------------
  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.27k|    int post_decimal_digits = ConsumeDigits<base>(
  409|  2.27k|        begin, end, digits_left, &mantissa, &mantissa_is_inexact);
  410|  2.27k|    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.27k|    if (post_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (416:9): [True: 0, False: 2.27k]
  ------------------
  417|       |      // refuse to parse pathological inputs
  418|      0|      return result;
  419|  2.27k|    } else if (post_decimal_digits > digits_left) {
  ------------------
  |  Branch (419:16): [True: 0, False: 2.27k]
  ------------------
  420|      0|      exponent_adjustment -= digits_left;
  421|  2.27k|    } else {
  422|  2.27k|      exponent_adjustment -= post_decimal_digits;
  423|  2.27k|    }
  424|  2.27k|  }
  425|       |  // If we've found no mantissa whatsoever, this isn't a number.
  426|  2.48k|  if (mantissa_begin == begin) {
  ------------------
  |  Branch (426:7): [True: 0, False: 2.48k]
  ------------------
  427|      0|    return result;
  428|      0|  }
  429|       |  // A bare "." doesn't count as a mantissa either.
  430|  2.48k|  if (begin - mantissa_begin == 1 && *mantissa_begin == '.') {
  ------------------
  |  Branch (430:7): [True: 208, False: 2.27k]
  |  Branch (430:38): [True: 0, False: 208]
  ------------------
  431|      0|    return result;
  432|      0|  }
  433|       |
  434|  2.48k|  if (mantissa_is_inexact) {
  ------------------
  |  Branch (434:7): [True: 0, False: 2.48k]
  ------------------
  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.48k|  result.mantissa = mantissa;
  448|       |
  449|  2.48k|  const char* const exponent_begin = begin;
  450|  2.48k|  result.literal_exponent = 0;
  451|  2.48k|  bool found_exponent = false;
  452|  2.48k|  if (AllowExponent(format_flags) && begin < end &&
  ------------------
  |  Branch (452:7): [True: 2.48k, False: 0]
  |  Branch (452:38): [True: 2.44k, False: 37]
  ------------------
  453|  2.48k|      IsExponentCharacter<base>(*begin)) {
  ------------------
  |  Branch (453:7): [True: 2.44k, False: 0]
  ------------------
  454|  2.44k|    bool negative_exponent = false;
  455|  2.44k|    ++begin;
  456|  2.44k|    if (begin < end && *begin == '-') {
  ------------------
  |  Branch (456:9): [True: 2.44k, False: 0]
  |  Branch (456:24): [True: 0, False: 2.44k]
  ------------------
  457|      0|      negative_exponent = true;
  458|      0|      ++begin;
  459|  2.44k|    } else if (begin < end && *begin == '+') {
  ------------------
  |  Branch (459:16): [True: 2.44k, False: 0]
  |  Branch (459:31): [True: 2.44k, False: 0]
  ------------------
  460|  2.44k|      ++begin;
  461|  2.44k|    }
  462|  2.44k|    const char* const exponent_digits_begin = begin;
  463|       |    // Exponent is always expressed in decimal, even for hexadecimal floats.
  464|  2.44k|    begin += ConsumeDigits<10>(begin, end, kDecimalExponentDigitsMax,
  465|  2.44k|                               &result.literal_exponent, nullptr);
  466|  2.44k|    if (begin == exponent_digits_begin) {
  ------------------
  |  Branch (466:9): [True: 0, False: 2.44k]
  ------------------
  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.44k|    } else {
  472|  2.44k|      found_exponent = true;
  473|  2.44k|      if (negative_exponent) {
  ------------------
  |  Branch (473:11): [True: 0, False: 2.44k]
  ------------------
  474|      0|        result.literal_exponent = -result.literal_exponent;
  475|      0|      }
  476|  2.44k|    }
  477|  2.44k|  }
  478|       |
  479|  2.48k|  if (!found_exponent && RequireExponent(format_flags)) {
  ------------------
  |  Branch (479:7): [True: 37, False: 2.44k]
  |  Branch (479:26): [True: 0, False: 37]
  ------------------
  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.48k|  result.type = strings_internal::FloatType::kNumber;
  487|  2.48k|  if (result.mantissa > 0) {
  ------------------
  |  Branch (487:7): [True: 2.44k, False: 37]
  ------------------
  488|  2.44k|    result.exponent = result.literal_exponent +
  489|  2.44k|                      (DigitMagnitude<base>() * exponent_adjustment);
  490|  2.44k|  } else {
  491|     37|    result.exponent = 0;
  492|     37|  }
  493|  2.48k|  result.end = begin;
  494|  2.48k|  return result;
  495|  2.48k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_113AllowExponentENS_12chars_formatE:
  122|  2.48k|bool AllowExponent(chars_format flags) {
  123|  2.48k|  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
  124|  2.48k|  bool scientific =
  125|  2.48k|      (flags & chars_format::scientific) == chars_format::scientific;
  126|  2.48k|  return scientific || !fixed;
  ------------------
  |  Branch (126:10): [True: 2.48k, False: 0]
  |  Branch (126:24): [True: 0, False: 0]
  ------------------
  127|  2.48k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_115RequireExponentENS_12chars_formatE:
  130|     37|bool RequireExponent(chars_format flags) {
  131|     37|  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
  132|     37|  bool scientific =
  133|     37|      (flags & chars_format::scientific) == chars_format::scientific;
  134|     37|  return scientific && !fixed;
  ------------------
  |  Branch (134:10): [True: 37, False: 0]
  |  Branch (134:24): [True: 0, False: 37]
  ------------------
  135|     37|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_119IsExponentCharacterILi10EEEbc:
  201|  2.44k|bool IsExponentCharacter<10>(char ch) {
  202|  2.44k|  return ch == 'e' || ch == 'E';
  ------------------
  |  Branch (202:10): [True: 2.44k, False: 0]
  |  Branch (202:23): [True: 0, False: 0]
  ------------------
  203|  2.44k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_117MantissaDigitsMaxILi10EEEiv:
  211|  7.44k|constexpr int MantissaDigitsMax<10>() {
  212|  7.44k|  return kDecimalMantissaDigitsMax;
  213|  7.44k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_110DigitLimitILi10EEEiv:
  220|  4.75k|constexpr int DigitLimit<10>() {
  221|  4.75k|  return kDecimalDigitLimit;
  222|  4.75k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_114DigitMagnitudeILi10EEEiv:
  229|  2.44k|constexpr int DigitMagnitude<10>() {
  230|  2.44k|  return 1;
  231|  2.44k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_118ParseInfinityOrNanEPKcS2_PNS_16strings_internal11ParsedFloatE:
  298|  2.48k|                        strings_internal::ParsedFloat* out) {
  299|  2.48k|  if (end - begin < 3) {
  ------------------
  |  Branch (299:7): [True: 37, False: 2.44k]
  ------------------
  300|     37|    return false;
  301|     37|  }
  302|  2.44k|  switch (*begin) {
  303|      0|    case 'i':
  ------------------
  |  Branch (303:5): [True: 0, False: 2.44k]
  ------------------
  304|      0|    case 'I': {
  ------------------
  |  Branch (304:5): [True: 0, False: 2.44k]
  ------------------
  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.44k]
  ------------------
  320|      0|    case 'N': {
  ------------------
  |  Branch (320:5): [True: 0, False: 2.44k]
  ------------------
  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.44k|    default:
  ------------------
  |  Branch (346:5): [True: 2.44k, False: 0]
  ------------------
  347|  2.44k|      return false;
  348|  2.44k|  }
  349|  2.44k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_113ConsumeDigitsILi10EmEEiPKcS3_iPT0_Pb:
  250|  4.75k|                  bool* dropped_nonzero_digit) {
  251|  4.75k|  if (base == 10) {
  ------------------
  |  Branch (251:7): [Folded - Ignored]
  ------------------
  252|  4.75k|    assert(max_digits <= std::numeric_limits<T>::digits10);
  253|  4.75k|  } else if (base == 16) {
  ------------------
  |  Branch (253:14): [Folded - Ignored]
  ------------------
  254|      0|    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
  255|      0|  }
  256|  4.75k|  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|  4.75k|  while (!*out && end != begin && *begin == '0') ++begin;
  ------------------
  |  Branch (261:10): [True: 2.48k, False: 2.27k]
  |  Branch (261:19): [True: 2.44k, False: 37]
  |  Branch (261:35): [True: 0, False: 2.44k]
  ------------------
  262|       |
  263|  4.75k|  T accumulator = *out;
  264|  4.75k|  const char* significant_digits_end =
  265|  4.75k|      (end - begin > max_digits) ? begin + max_digits : end;
  ------------------
  |  Branch (265:7): [True: 0, False: 4.75k]
  ------------------
  266|  18.2k|  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (266:10): [True: 18.1k, False: 37]
  |  Branch (266:44): [True: 13.4k, False: 4.71k]
  ------------------
  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|  13.4k|    auto digit = static_cast<T>(ToDigit<base>(*begin));
  270|  13.4k|    assert(accumulator * base >= accumulator);
  271|  13.4k|    accumulator *= base;
  272|  13.4k|    assert(accumulator + digit >= accumulator);
  273|  13.4k|    accumulator += digit;
  274|  13.4k|    ++begin;
  275|  13.4k|  }
  276|  4.75k|  bool dropped_nonzero = false;
  277|  4.75k|  while (begin < end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (277:10): [True: 4.71k, False: 37]
  |  Branch (277:25): [True: 0, False: 4.71k]
  ------------------
  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|  4.75k|  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
  ------------------
  |  Branch (281:7): [True: 0, False: 4.75k]
  |  Branch (281:26): [True: 0, False: 0]
  ------------------
  282|      0|    *dropped_nonzero_digit = true;
  283|      0|  }
  284|  4.75k|  *out = accumulator;
  285|  4.75k|  return static_cast<int>(begin - original_begin);
  286|  4.75k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_17IsDigitILi10EEEbc:
  183|  29.0k|bool IsDigit<10>(char ch) {
  184|  29.0k|  return ch >= '0' && ch <= '9';
  ------------------
  |  Branch (184:10): [True: 24.4k, False: 4.54k]
  |  Branch (184:23): [True: 19.5k, False: 4.89k]
  ------------------
  185|  29.0k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_17ToDigitILi10EEEjc:
  192|  19.5k|unsigned ToDigit<10>(char ch) {
  193|  19.5k|  return static_cast<unsigned>(ch - '0');
  194|  19.5k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_113ConsumeDigitsILi10EiEEiPKcS3_iPT0_Pb:
  250|  2.44k|                  bool* dropped_nonzero_digit) {
  251|  2.44k|  if (base == 10) {
  ------------------
  |  Branch (251:7): [Folded - Ignored]
  ------------------
  252|  2.44k|    assert(max_digits <= std::numeric_limits<T>::digits10);
  253|  2.44k|  } else if (base == 16) {
  ------------------
  |  Branch (253:14): [Folded - Ignored]
  ------------------
  254|      0|    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
  255|      0|  }
  256|  2.44k|  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.44k|  while (!*out && end != begin && *begin == '0') ++begin;
  ------------------
  |  Branch (261:10): [True: 2.44k, False: 0]
  |  Branch (261:19): [True: 2.44k, False: 0]
  |  Branch (261:35): [True: 0, False: 2.44k]
  ------------------
  262|       |
  263|  2.44k|  T accumulator = *out;
  264|  2.44k|  const char* significant_digits_end =
  265|  2.44k|      (end - begin > max_digits) ? begin + max_digits : end;
  ------------------
  |  Branch (265:7): [True: 0, False: 2.44k]
  ------------------
  266|  8.56k|  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (266:10): [True: 6.11k, False: 2.44k]
  |  Branch (266:44): [True: 6.11k, 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.11k|    auto digit = static_cast<T>(ToDigit<base>(*begin));
  270|  6.11k|    assert(accumulator * base >= accumulator);
  271|  6.11k|    accumulator *= base;
  272|  6.11k|    assert(accumulator + digit >= accumulator);
  273|  6.11k|    accumulator += digit;
  274|  6.11k|    ++begin;
  275|  6.11k|  }
  276|  2.44k|  bool dropped_nonzero = false;
  277|  2.44k|  while (begin < end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (277:10): [True: 0, False: 2.44k]
  |  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.44k|  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
  ------------------
  |  Branch (281:7): [True: 0, False: 2.44k]
  |  Branch (281:26): [True: 0, False: 0]
  ------------------
  282|      0|    *dropped_nonzero_digit = true;
  283|      0|  }
  284|  2.44k|  *out = accumulator;
  285|  2.44k|  return static_cast<int>(begin - original_begin);
  286|  2.44k|}

_ZN4absl16strings_internal10memcasecmpEPKcS2_m:
   25|  6.87k|int memcasecmp(const char* s1, const char* s2, size_t len) {
   26|  6.87k|  const unsigned char* us1 = reinterpret_cast<const unsigned char*>(s1);
   27|  6.87k|  const unsigned char* us2 = reinterpret_cast<const unsigned char*>(s2);
   28|       |
   29|  8.12k|  for (size_t i = 0; i < len; i++) {
  ------------------
  |  Branch (29:22): [True: 6.87k, False: 1.24k]
  ------------------
   30|  6.87k|    unsigned char c1 = us1[i];
   31|  6.87k|    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|  6.87k|    if (c1 != c2) {
  ------------------
  |  Branch (36:9): [True: 5.63k, False: 1.24k]
  ------------------
   37|  5.63k|      c1 = c1 >= 'A' && c1 <= 'Z' ? c1 - 'A' + 'a' : c1;
  ------------------
  |  Branch (37:12): [True: 0, False: 5.63k]
  |  Branch (37:25): [True: 0, False: 0]
  ------------------
   38|  5.63k|      c2 = c2 >= 'A' && c2 <= 'Z' ? c2 - 'A' + 'a' : c2;
  ------------------
  |  Branch (38:12): [True: 4.58k, False: 1.05k]
  |  Branch (38:25): [True: 0, False: 4.58k]
  ------------------
   39|  5.63k|      const int diff = int{c1} - int{c2};
   40|  5.63k|      if (diff != 0) return diff;
  ------------------
  |  Branch (40:11): [True: 5.63k, False: 0]
  ------------------
   41|  5.63k|    }
   42|  6.87k|  }
   43|  1.24k|  return 0;
   44|  6.87k|}

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

_ZN4absl19str_format_internal13ConvertIntArgIiEEbT_NS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  403|  2.48k|bool ConvertIntArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
  404|  2.48k|  using U = typename MakeUnsigned<T>::type;
  405|  2.48k|  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.48k|  switch (static_cast<uint8_t>(conv.conversion_char())) {
  412|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::c):
  ------------------
  |  Branch (412:5): [True: 0, False: 2.48k]
  ------------------
  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.48k]
  ------------------
  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.48k]
  ------------------
  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.48k]
  ------------------
  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.48k]
  ------------------
  430|      0|      as_digits.PrintAsDec(static_cast<U>(v));
  431|      0|      break;
  432|       |
  433|  2.48k|    case static_cast<uint8_t>(FormatConversionCharInternal::d):
  ------------------
  |  Branch (433:5): [True: 2.48k, False: 0]
  ------------------
  434|  2.48k|    case static_cast<uint8_t>(FormatConversionCharInternal::i):
  ------------------
  |  Branch (434:5): [True: 0, False: 2.48k]
  ------------------
  435|  2.48k|    case static_cast<uint8_t>(FormatConversionCharInternal::v):
  ------------------
  |  Branch (435:5): [True: 0, False: 2.48k]
  ------------------
  436|  2.48k|      as_digits.PrintAsDec(v);
  437|  2.48k|      break;
  438|       |
  439|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::a):
  ------------------
  |  Branch (439:5): [True: 0, False: 2.48k]
  ------------------
  440|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::e):
  ------------------
  |  Branch (440:5): [True: 0, False: 2.48k]
  ------------------
  441|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::f):
  ------------------
  |  Branch (441:5): [True: 0, False: 2.48k]
  ------------------
  442|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::g):
  ------------------
  |  Branch (442:5): [True: 0, False: 2.48k]
  ------------------
  443|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::A):
  ------------------
  |  Branch (443:5): [True: 0, False: 2.48k]
  ------------------
  444|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::E):
  ------------------
  |  Branch (444:5): [True: 0, False: 2.48k]
  ------------------
  445|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::F):
  ------------------
  |  Branch (445:5): [True: 0, False: 2.48k]
  ------------------
  446|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::G):
  ------------------
  |  Branch (446:5): [True: 0, False: 2.48k]
  ------------------
  447|      0|      return ConvertFloatImpl(static_cast<double>(v), conv, sink);
  448|       |
  449|      0|    default:
  ------------------
  |  Branch (449:5): [True: 0, False: 2.48k]
  ------------------
  450|      0|      ABSL_ASSUME(false);
  ------------------
  |  |  268|      0|#define ABSL_ASSUME(cond) assert(cond)
  ------------------
  451|  2.48k|  }
  452|       |
  453|  2.48k|  if (conv.is_basic()) {
  ------------------
  |  Branch (453:7): [True: 2.48k, False: 0]
  ------------------
  454|  2.48k|    sink->Append(as_digits.with_neg_and_zero());
  455|  2.48k|    return true;
  456|  2.48k|  }
  457|      0|  return ConvertIntImplInnerSlow(as_digits, conv, sink);
  458|  2.48k|}
_ZN4absl19str_format_internal17FormatConvertImplEfNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  577|  1.24k|                                        FormatSinkImpl *sink) {
  578|  1.24k|  return {ConvertFloatArg(v, conv, sink)};
  579|  1.24k|}
_ZN4absl19str_format_internal17FormatConvertImplEdNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  582|  1.24k|                                        FormatSinkImpl *sink) {
  583|  1.24k|  return {ConvertFloatArg(v, conv, sink)};
  584|  1.24k|}
_ZN4absl19str_format_internal17FormatConvertImplEiNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  625|  2.48k|                                        FormatSinkImpl *sink) {
  626|  2.48k|  return {ConvertIntArg(v, conv, sink)};
  627|  2.48k|}
arg.cc:_ZNK4absl19str_format_internal12_GLOBAL__N_19IntDigits17with_neg_and_zeroEv:
  176|  2.48k|  string_view with_neg_and_zero() const { return {start_, size_}; }
arg.cc:_ZN4absl19str_format_internal12_GLOBAL__N_19IntDigits10PrintAsDecIiEEvT_:
   99|  2.48k|  void PrintAsDec(T v) {
  100|  2.48k|    static_assert(std::is_integral<T>::value, "");
  101|  2.48k|    start_ = storage_;
  102|  2.48k|    size_ = static_cast<size_t>(numbers_internal::FastIntToBuffer(v, storage_) -
  103|  2.48k|                                storage_);
  104|  2.48k|  }
arg.cc:_ZN4absl19str_format_internal12_GLOBAL__N_115ConvertFloatArgIfEEbT_NS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  295|  1.24k|bool ConvertFloatArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
  296|  1.24k|  if (conv.conversion_char() == FormatConversionCharInternal::v) {
  ------------------
  |  Branch (296:7): [True: 0, False: 1.24k]
  ------------------
  297|      0|    conv.set_conversion_char(FormatConversionCharInternal::g);
  298|      0|  }
  299|       |
  300|  1.24k|  return FormatConversionCharIsFloat(conv.conversion_char()) &&
  ------------------
  |  Branch (300:10): [True: 1.24k, False: 0]
  ------------------
  301|  1.24k|         ConvertFloatImpl(v, conv, sink);
  ------------------
  |  Branch (301:10): [True: 1.24k, False: 0]
  ------------------
  302|  1.24k|}
arg.cc:_ZN4absl19str_format_internal12_GLOBAL__N_115ConvertFloatArgIdEEbT_NS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  295|  1.24k|bool ConvertFloatArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
  296|  1.24k|  if (conv.conversion_char() == FormatConversionCharInternal::v) {
  ------------------
  |  Branch (296:7): [True: 0, False: 1.24k]
  ------------------
  297|      0|    conv.set_conversion_char(FormatConversionCharInternal::g);
  298|      0|  }
  299|       |
  300|  1.24k|  return FormatConversionCharIsFloat(conv.conversion_char()) &&
  ------------------
  |  Branch (300:10): [True: 1.24k, False: 0]
  ------------------
  301|  1.24k|         ConvertFloatImpl(v, conv, sink);
  ------------------
  |  Branch (301:10): [True: 1.24k, False: 0]
  ------------------
  302|  1.24k|}

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

_ZN4absl19str_format_internal13FormatUntypedENS0_17FormatRawSinkImplENS0_21UntypedFormatSpecImplENS_4SpanIKNS0_13FormatArgImplEEE:
  214|  4.96k|                   absl::Span<const FormatArgImpl> args) {
  215|  4.96k|  FormatSinkImpl sink(raw_sink);
  216|  4.96k|  using Converter = DefaultConverter;
  217|  4.96k|  return ConvertAll(format, args, Converter(&sink));
  218|  4.96k|}
_ZN4absl19str_format_internal10FormatPackENS0_21UntypedFormatSpecImplENS_4SpanIKNS0_13FormatArgImplEEE:
  235|  4.96k|                       absl::Span<const FormatArgImpl> args) {
  236|  4.96k|  std::string out;
  237|  4.96k|  if (ABSL_PREDICT_FALSE(!FormatUntyped(&out, format, args))) {
  ------------------
  |  |  189|  4.96k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 4.96k]
  |  |  |  Branch (189:49): [Folded - Ignored]
  |  |  |  Branch (189:58): [True: 0, False: 4.96k]
  |  |  ------------------
  ------------------
  238|      0|    out.clear();
  239|      0|  }
  240|  4.96k|  return out;
  241|  4.96k|}
bind.cc:_ZN4absl19str_format_internal12_GLOBAL__N_110ArgContextC2ENS_4SpanIKNS0_13FormatArgImplEEE:
   55|  4.96k|  explicit ArgContext(absl::Span<const FormatArgImpl> pack) : pack_(pack) {}
bind.cc:_ZN4absl19str_format_internal12_GLOBAL__N_110ArgContext4BindEPKNS0_17UnboundConversionEPNS0_15BoundConversionE:
   70|  4.96k|                             BoundConversion* bound) {
   71|  4.96k|  const FormatArgImpl* arg = nullptr;
   72|  4.96k|  int arg_position = unbound->arg_position;
   73|  4.96k|  if (static_cast<size_t>(arg_position - 1) >= pack_.size()) return false;
  ------------------
  |  Branch (73:7): [True: 0, False: 4.96k]
  ------------------
   74|  4.96k|  arg = &pack_[static_cast<size_t>(arg_position - 1)];  // 1-based
   75|       |
   76|  4.96k|  if (unbound->flags != Flags::kBasic) {
  ------------------
  |  Branch (76:7): [True: 0, False: 4.96k]
  ------------------
   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|  4.96k|  } else {
  110|  4.96k|    FormatConversionSpecImplFriend::SetFlags(unbound->flags, bound);
  111|  4.96k|    FormatConversionSpecImplFriend::SetWidth(-1, bound);
  112|  4.96k|    FormatConversionSpecImplFriend::SetPrecision(-1, bound);
  113|  4.96k|  }
  114|  4.96k|  FormatConversionSpecImplFriend::SetConversionChar(unbound->conv, bound);
  115|  4.96k|  bound->set_arg(arg);
  116|  4.96k|  return true;
  117|  4.96k|}
bind.cc:_ZN4absl19str_format_internal12_GLOBAL__N_116DefaultConverterC2EPNS0_14FormatSinkImplE:
  154|  4.96k|  explicit DefaultConverter(FormatSinkImpl* sink) : sink_(sink) {}
bind.cc:_ZN4absl19str_format_internal12_GLOBAL__N_110ConvertAllINS1_16DefaultConverterEEEbNS0_21UntypedFormatSpecImplENS_4SpanIKNS0_13FormatArgImplEEET_:
  142|  4.96k|                absl::Span<const FormatArgImpl> args, Converter converter) {
  143|  4.96k|  if (format.has_parsed_conversion()) {
  ------------------
  |  Branch (143:7): [True: 0, False: 4.96k]
  ------------------
  144|      0|    return format.parsed_conversion()->ProcessFormat(
  145|      0|        ConverterConsumer<Converter>(converter, args));
  146|  4.96k|  } else {
  147|  4.96k|    return ParseFormatString(format.str(),
  148|  4.96k|                             ConverterConsumer<Converter>(converter, args));
  149|  4.96k|  }
  150|  4.96k|}
bind.cc:_ZN4absl19str_format_internal12_GLOBAL__N_117ConverterConsumerINS1_16DefaultConverterEE10ConvertOneERKNS0_17UnboundConversionENS_11string_viewE:
  129|  4.96k|  bool ConvertOne(const UnboundConversion& conv, string_view conv_string) {
  130|  4.96k|    BoundConversion bound;
  131|  4.96k|    if (!arg_context_.Bind(&conv, &bound)) return false;
  ------------------
  |  Branch (131:9): [True: 0, False: 4.96k]
  ------------------
  132|  4.96k|    return converter_.ConvertOne(bound, conv_string);
  133|  4.96k|  }
bind.cc:_ZNK4absl19str_format_internal12_GLOBAL__N_116DefaultConverter10ConvertOneERKNS0_15BoundConversionENS_11string_viewE:
  158|  4.96k|  bool ConvertOne(const BoundConversion& bound, string_view /*conv*/) const {
  159|  4.96k|    return FormatArgImplFriend::Convert(*bound.arg(), bound, sink_);
  160|  4.96k|  }
bind.cc:_ZN4absl19str_format_internal12_GLOBAL__N_117ConverterConsumerINS1_16DefaultConverterEE6AppendENS_11string_viewE:
  125|  4.96k|  bool Append(string_view s) {
  126|  4.96k|    converter_.Append(s);
  127|  4.96k|    return true;
  128|  4.96k|  }
bind.cc:_ZNK4absl19str_format_internal12_GLOBAL__N_116DefaultConverter6AppendENS_11string_viewE:
  156|  4.96k|  void Append(string_view s) const { sink_->Append(s); }
bind.cc:_ZN4absl19str_format_internal12_GLOBAL__N_117ConverterConsumerINS1_16DefaultConverterEEC2ES3_NS_4SpanIKNS0_13FormatArgImplEEE:
  123|  4.96k|      : converter_(converter), arg_context_(pack) {}

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

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

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

_ZNK4absl19str_format_internal24FormatConversionSpecImpl15conversion_charEv:
  290|  23.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|  23.5k|    static_assert(offsetof(FormatConversionSpecImpl, conv_) == 0, "");
  294|  23.5k|    return conv_;
  295|  23.5k|  }
_ZN4absl19str_format_internal8ContainsENS_23FormatConversionCharSetENS_20FormatConversionCharE:
  442|  4.96k|constexpr bool Contains(FormatConversionCharSet set, FormatConversionChar c) {
  443|  4.96k|  return (static_cast<uint64_t>(set) & FormatConversionCharToConvInt(c)) != 0;
  444|  4.96k|}
_ZN4absl19str_format_internal29FormatConversionCharToConvIntENS_20FormatConversionCharE:
  360|  4.96k|constexpr uint64_t FormatConversionCharToConvInt(FormatConversionChar c) {
  361|  4.96k|  return uint64_t{1} << (1 + static_cast<uint8_t>(c));
  362|  4.96k|}
_ZN4absl19str_format_internal17FormatRawSinkImpl5WriteENS_11string_viewE:
   48|  4.96k|  void Write(string_view s) { write_(sink_, s); }
_ZN4absl19str_format_internal14FormatSinkImplC2ENS0_17FormatRawSinkImplE:
   68|  4.96k|  explicit FormatSinkImpl(FormatRawSinkImpl raw) : raw_(raw) {}
_ZN4absl19str_format_internal14FormatSinkImplD2Ev:
   70|  4.96k|  ~FormatSinkImpl() { Flush(); }
_ZN4absl19str_format_internal14FormatSinkImpl5FlushEv:
   72|  4.96k|  void Flush() {
   73|  4.96k|    raw_.Write(string_view(buf_, static_cast<size_t>(pos_ - buf_)));
   74|  4.96k|    pos_ = buf_;
   75|  4.96k|  }
_ZN4absl19str_format_internal14FormatSinkImpl6AppendEmc:
   77|  4.48k|  void Append(size_t n, char c) {
   78|  4.48k|    if (n == 0) return;
  ------------------
  |  Branch (78:9): [True: 3.76k, False: 722]
  ------------------
   79|    722|    size_ += n;
   80|    722|    auto raw_append = [&](size_t count) {
   81|    722|      memset(pos_, c, count);
   82|    722|      pos_ += count;
   83|    722|    };
   84|    722|    while (n > Avail()) {
  ------------------
  |  Branch (84:12): [True: 0, False: 722]
  ------------------
   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|    722|    raw_append(n);
   92|    722|  }
_ZN4absl19str_format_internal14FormatSinkImpl6AppendENS_11string_viewE:
   94|  9.92k|  void Append(string_view v) {
   95|  9.92k|    size_t n = v.size();
   96|  9.92k|    if (n == 0) return;
  ------------------
  |  Branch (96:9): [True: 4.96k, False: 4.96k]
  ------------------
   97|  4.96k|    size_ += n;
   98|  4.96k|    if (n >= Avail()) {
  ------------------
  |  Branch (98:9): [True: 0, False: 4.96k]
  ------------------
   99|      0|      Flush();
  100|      0|      raw_.Write(v);
  101|      0|      return;
  102|      0|    }
  103|  4.96k|    memcpy(pos_, v.data(), n);
  104|  4.96k|    pos_ += n;
  105|  4.96k|  }
_ZNK4absl19str_format_internal14FormatSinkImpl5AvailEv:
  123|  5.68k|  size_t Avail() const {
  124|  5.68k|    return static_cast<size_t>(buf_ + sizeof(buf_) - pos_);
  125|  5.68k|  }
_ZNK4absl19str_format_internal24FormatConversionSpecImpl8is_basicEv:
  277|  2.48k|  bool is_basic() const { return flags_ == Flags::kBasic; }
_ZNK4absl19str_format_internal24FormatConversionSpecImpl13has_left_flagEv:
  278|  1.25k|  bool has_left_flag() const { return FlagsContains(flags_, Flags::kLeft); }
_ZNK4absl19str_format_internal24FormatConversionSpecImpl17has_show_pos_flagEv:
  279|    910|  bool has_show_pos_flag() const {
  280|    910|    return FlagsContains(flags_, Flags::kShowPos);
  281|    910|  }
_ZNK4absl19str_format_internal24FormatConversionSpecImpl17has_sign_col_flagEv:
  282|    910|  bool has_sign_col_flag() const {
  283|    910|    return FlagsContains(flags_, Flags::kSignCol);
  284|    910|  }
_ZNK4absl19str_format_internal24FormatConversionSpecImpl12has_alt_flagEv:
  285|  1.25k|  bool has_alt_flag() const { return FlagsContains(flags_, Flags::kAlt); }
_ZNK4absl19str_format_internal24FormatConversionSpecImpl13has_zero_flagEv:
  286|  1.25k|  bool has_zero_flag() const { return FlagsContains(flags_, Flags::kZero); }
_ZNK4absl19str_format_internal24FormatConversionSpecImpl5widthEv:
  301|  2.48k|  int width() const { return width_; }
_ZNK4absl19str_format_internal24FormatConversionSpecImpl9precisionEv:
  304|  3.70k|  int precision() const { return precision_; }
_ZN4absl19str_format_internal30FormatConversionSpecImplFriend8SetFlagsENS0_5FlagsEPNS0_24FormatConversionSpecImplE:
  321|  4.96k|  static void SetFlags(Flags f, FormatConversionSpecImpl* conv) {
  322|  4.96k|    conv->flags_ = f;
  323|  4.96k|  }
_ZN4absl19str_format_internal30FormatConversionSpecImplFriend17SetConversionCharENS_20FormatConversionCharEPNS0_24FormatConversionSpecImplE:
  328|  4.96k|                                FormatConversionSpecImpl* conv) {
  329|  4.96k|    conv->conv_ = c;
  330|  4.96k|  }
_ZN4absl19str_format_internal30FormatConversionSpecImplFriend8SetWidthEiPNS0_24FormatConversionSpecImplE:
  331|  4.96k|  static void SetWidth(int w, FormatConversionSpecImpl* conv) {
  332|  4.96k|    conv->width_ = w;
  333|  4.96k|  }
_ZN4absl19str_format_internal30FormatConversionSpecImplFriend12SetPrecisionEiPNS0_24FormatConversionSpecImplE:
  334|  4.96k|  static void SetPrecision(int p, FormatConversionSpecImpl* conv) {
  335|  4.96k|    conv->precision_ = p;
  336|  4.96k|  }
_ZN4absl19str_format_internal30FormatConversionSpecImplFriend13FlagsToStringERKNS0_24FormatConversionSpecImplE:
  337|  1.22k|  static std::string FlagsToString(const FormatConversionSpecImpl& spec) {
  338|  1.22k|    return str_format_internal::FlagsToString(spec.flags_);
  339|  1.22k|  }
_ZN4absl19str_format_internal13FlagsContainsENS0_5FlagsES1_:
  150|  11.7k|constexpr bool FlagsContains(Flags haystack, Flags needle) {
  151|  11.7k|  return (static_cast<uint8_t>(haystack) & static_cast<uint8_t>(needle)) ==
  152|  11.7k|         static_cast<uint8_t>(needle);
  153|  11.7k|}
_ZN4absl19str_format_internal27FormatConversionCharIsUpperENS_20FormatConversionCharE:
  220|  1.21k|inline bool FormatConversionCharIsUpper(FormatConversionChar c) {
  221|  1.21k|  if (c == FormatConversionCharInternal::X ||
  ------------------
  |  Branch (221:7): [True: 0, False: 1.21k]
  ------------------
  222|  1.21k|      c == FormatConversionCharInternal::F ||
  ------------------
  |  Branch (222:7): [True: 0, False: 1.21k]
  ------------------
  223|  1.21k|      c == FormatConversionCharInternal::E ||
  ------------------
  |  Branch (223:7): [True: 0, False: 1.21k]
  ------------------
  224|  1.21k|      c == FormatConversionCharInternal::G ||
  ------------------
  |  Branch (224:7): [True: 0, False: 1.21k]
  ------------------
  225|  1.21k|      c == FormatConversionCharInternal::A) {
  ------------------
  |  Branch (225:7): [True: 0, False: 1.21k]
  ------------------
  226|      0|    return true;
  227|  1.21k|  } else {
  228|  1.21k|    return false;
  229|  1.21k|  }
  230|  1.21k|}
_ZN4absl19str_format_internal27FormatConversionCharIsFloatENS_20FormatConversionCharE:
  232|  2.48k|inline bool FormatConversionCharIsFloat(FormatConversionChar c) {
  233|  2.48k|  if (c == FormatConversionCharInternal::a ||
  ------------------
  |  Branch (233:7): [True: 0, False: 2.48k]
  ------------------
  234|  2.48k|      c == FormatConversionCharInternal::e ||
  ------------------
  |  Branch (234:7): [True: 0, False: 2.48k]
  ------------------
  235|  2.48k|      c == FormatConversionCharInternal::f ||
  ------------------
  |  Branch (235:7): [True: 0, False: 2.48k]
  ------------------
  236|  2.48k|      c == FormatConversionCharInternal::g ||
  ------------------
  |  Branch (236:7): [True: 2.48k, False: 0]
  ------------------
  237|  2.48k|      c == FormatConversionCharInternal::A ||
  ------------------
  |  Branch (237:7): [True: 0, False: 0]
  ------------------
  238|  2.48k|      c == FormatConversionCharInternal::E ||
  ------------------
  |  Branch (238:7): [True: 0, False: 0]
  ------------------
  239|  2.48k|      c == FormatConversionCharInternal::F ||
  ------------------
  |  Branch (239:7): [True: 0, False: 0]
  ------------------
  240|  2.48k|      c == FormatConversionCharInternal::G) {
  ------------------
  |  Branch (240:7): [True: 0, False: 0]
  ------------------
  241|  2.48k|    return true;
  242|  2.48k|  } else {
  243|      0|    return false;
  244|      0|  }
  245|  2.48k|}
_ZN4absl19str_format_internal26FormatConversionCharToCharENS_20FormatConversionCharE:
  247|  1.22k|inline char FormatConversionCharToChar(FormatConversionChar c) {
  248|  1.22k|  if (c == FormatConversionCharInternal::kNone) {
  ------------------
  |  Branch (248:7): [True: 0, False: 1.22k]
  ------------------
  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.22k|  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.22k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.22k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  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.22k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.22k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  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.22k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.22k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  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.22k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.22k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  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.22k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.22k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  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.22k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.22k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  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.22k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.22k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  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.22k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.22k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  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.22k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.22k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  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.22k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.22k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  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.22k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.22k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  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.22k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 0, False: 1.22k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  253|      0|    return #e[0];
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  170|  1.22k|  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.22k|  } else if (c == FormatConversionCharInternal::e) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (252:14): [True: 1.22k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  253|  1.22k|    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.22k|  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
  |  |  |  |  ------------------
  |  |  |  |  |  |  252|  1.22k|  } 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.22k|#undef ABSL_INTERNAL_X_VAL
  262|  1.22k|#undef ABSL_INTERNAL_X_SEP
  263|  1.22k|}
_ZZN4absl19str_format_internal14FormatSinkImpl6AppendEmcENKUlmE_clEm:
   80|    722|    auto raw_append = [&](size_t count) {
   81|    722|      memset(pos_, c, count);
   82|    722|      pos_ += count;
   83|    722|    };
_ZN4absl19str_format_internal17FormatRawSinkImplC2INSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEELPv0EEEPT_:
   46|  4.96k|      : sink_(raw), write_(&FormatRawSinkImpl::Flush<T>) {}
_ZN4absl19str_format_internal17FormatRawSinkImpl5FlushINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvPvNS_11string_viewE:
   57|  4.96k|  static void Flush(void* r, string_view s) {
   58|  4.96k|    str_format_internal::InvokeFlush(static_cast<T*>(r), s);
   59|  4.96k|  }

_ZN4absl19str_format_internal16ConvertFloatImplEfRKNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
 1446|  1.24k|                      FormatSinkImpl *sink) {
 1447|  1.24k|  return FloatToSink(static_cast<double>(v), conv, sink);
 1448|  1.24k|}
_ZN4absl19str_format_internal16ConvertFloatImplEdRKNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
 1451|  1.24k|                      FormatSinkImpl *sink) {
 1452|  1.24k|  return FloatToSink(v, conv, sink);
 1453|  1.24k|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_119PrintIntegralDigitsILNS1_11FormatStyleE1EmEEmT0_PNS1_6BufferE:
 1140|     37|size_t PrintIntegralDigits(Int digits, Buffer* out) {
 1141|     37|  size_t printed = 0;
 1142|     37|  if (digits) {
  ------------------
  |  Branch (1142:7): [True: 0, False: 37]
  ------------------
 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|     37|  } 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|     37|  return printed;
 1157|     37|}
float_conversion.cc:_ZNK4absl19str_format_internal12_GLOBAL__N_16Buffer4sizeEv:
 1025|  1.21k|  size_t size() const { return static_cast<size_t>(end - begin); }
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_120RemoveExtraPrecisionEmbPNS1_6BufferEPi:
 1163|  1.21k|                          int* exp_out) {
 1164|       |  // Back out the extra digits
 1165|  1.21k|  out->end -= extra_digits;
 1166|       |
 1167|  1.21k|  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.21k|    if (*out->end > '5') return true;
 1171|  1.21k|    if (*out->end < '5') return false;
 1172|  1.21k|    if (has_leftover_value || std::any_of(out->end + 1, out->end + extra_digits,
 1173|  1.21k|                                          [](char c) { return c != '0'; }))
 1174|  1.21k|      return true;
 1175|       |
 1176|       |    // Ends in ...50*, round to even.
 1177|  1.21k|    return out->last_digit() % 2 == 1;
 1178|  1.21k|  }();
 1179|       |
 1180|  1.21k|  if (needs_to_round_up) {
  ------------------
  |  Branch (1180:7): [True: 546, False: 672]
  ------------------
 1181|    546|    RoundUp<FormatStyle::Precision>(out, exp_out);
 1182|    546|  }
 1183|  1.21k|}
float_conversion.cc:_ZZN4absl19str_format_internal12_GLOBAL__N_120RemoveExtraPrecisionEmbPNS1_6BufferEPiENK3$_0clEv:
 1167|  1.21k|  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.21k|    if (*out->end > '5') return true;
  ------------------
  |  Branch (1170:9): [True: 446, False: 772]
  ------------------
 1171|    772|    if (*out->end < '5') return false;
  ------------------
  |  Branch (1171:9): [True: 672, False: 100]
  ------------------
 1172|    100|    if (has_leftover_value || std::any_of(out->end + 1, out->end + extra_digits,
  ------------------
  |  Branch (1172:9): [True: 0, False: 100]
  |  Branch (1172:9): [True: 100, False: 0]
  |  Branch (1172:31): [True: 100, False: 0]
  ------------------
 1173|    100|                                          [](char c) { return c != '0'; }))
 1174|    100|      return true;
 1175|       |
 1176|       |    // Ends in ...50*, round to even.
 1177|      0|    return out->last_digit() % 2 == 1;
 1178|    100|  }();
float_conversion.cc:_ZZZN4absl19str_format_internal12_GLOBAL__N_120RemoveExtraPrecisionEmbPNS1_6BufferEPiENK3$_0clEvENKUlcE_clEc:
 1173|    141|                                          [](char c) { return c != '0'; }))
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_16Buffer9push_backEc:
 1009|  5.09k|  void push_back(char c) {
 1010|  5.09k|    assert(end < data + sizeof(data));
 1011|  5.09k|    *end++ = c;
 1012|  5.09k|  }
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_16Buffer10push_frontEc:
 1005|  47.2k|  void push_front(char c) {
 1006|  47.2k|    assert(begin > data);
 1007|  47.2k|    *--begin = c;
 1008|  47.2k|  }
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_17RoundUpILNS1_11FormatStyleE1EEEvPNS1_6BufferEPi:
 1063|    546|void RoundUp(Buffer *buffer, int *exp) {
 1064|    546|  char *p = &buffer->back();
 1065|  1.19k|  while (p >= buffer->begin && (*p == '9' || *p == '.')) {
  ------------------
  |  Branch (1065:10): [True: 1.12k, False: 75]
  |  Branch (1065:33): [True: 573, False: 551]
  |  Branch (1065:46): [True: 80, False: 471]
  ------------------
 1066|    653|    if (*p == '9') *p = '0';
  ------------------
  |  Branch (1066:9): [True: 573, False: 80]
  ------------------
 1067|    653|    --p;
 1068|    653|  }
 1069|       |
 1070|    546|  if (p < buffer->begin) {
  ------------------
  |  Branch (1070:7): [True: 75, False: 471]
  ------------------
 1071|     75|    *p = '1';
 1072|     75|    buffer->begin = p;
 1073|     75|    if (mode == FormatStyle::Precision) {
  ------------------
  |  Branch (1073:9): [Folded - Ignored]
  ------------------
 1074|     75|      std::swap(p[1], p[2]);  // move the .
 1075|     75|      ++*exp;
 1076|     75|      buffer->pop_back();
 1077|     75|    }
 1078|    471|  } else {
 1079|    471|    ++*p;
 1080|    471|  }
 1081|    546|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_119PrintIntegralDigitsILNS1_11FormatStyleE1EoEEmT0_PNS1_6BufferE:
 1140|  1.21k|size_t PrintIntegralDigits(Int digits, Buffer* out) {
 1141|  1.21k|  size_t printed = 0;
 1142|  1.21k|  if (digits) {
  ------------------
  |  Branch (1142:7): [True: 1.21k, False: 0]
  ------------------
 1143|  47.1k|    for (; digits; digits /= 10) out->push_front(digits % 10 + '0');
  ------------------
  |  Branch (1143:12): [True: 45.9k, False: 1.21k]
  ------------------
 1144|  1.21k|    printed = out->size();
 1145|  1.21k|    if (mode == FormatStyle::Precision) {
  ------------------
  |  Branch (1145:9): [Folded - Ignored]
  ------------------
 1146|  1.21k|      out->push_front(*out->begin);
 1147|  1.21k|      out->begin[1] = '.';
 1148|  1.21k|    } else {
 1149|      0|      out->push_back('.');
 1150|      0|    }
 1151|  1.21k|  } 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.21k|  return printed;
 1157|  1.21k|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_112CopyStringToENS_11string_viewEPc:
  956|  2.45k|char *CopyStringTo(absl::string_view v, char *out) {
  957|  2.45k|  std::memcpy(out, v.data(), v.size());
  958|  2.45k|  return out + v.size();
  959|  2.45k|}
float_conversion.cc:_ZNK4absl19str_format_internal12_GLOBAL__N_16Buffer4backEv:
 1018|  3.80k|  char &back() const {
 1019|  3.80k|    assert(begin < end);
 1020|  3.80k|    return end[-1];
 1021|  3.80k|  }
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_16Buffer8pop_backEv:
 1013|    944|  void pop_back() {
 1014|    944|    assert(begin < end);
 1015|    944|    --end;
 1016|    944|  }
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_113PrintExponentEicPNS1_6BufferE:
 1083|  1.21k|void PrintExponent(int exp, char e, Buffer *out) {
 1084|  1.21k|  out->push_back(e);
 1085|  1.21k|  if (exp < 0) {
  ------------------
  |  Branch (1085:7): [True: 0, False: 1.21k]
  ------------------
 1086|      0|    out->push_back('-');
 1087|      0|    exp = -exp;
 1088|  1.21k|  } else {
 1089|  1.21k|    out->push_back('+');
 1090|  1.21k|  }
 1091|       |  // Exponent digits.
 1092|  1.21k|  if (exp > 99) {
  ------------------
  |  Branch (1092:7): [True: 0, False: 1.21k]
  ------------------
 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.21k|  } else {
 1097|  1.21k|    out->push_back(static_cast<char>(exp / 10 + '0'));
 1098|  1.21k|    out->push_back(static_cast<char>(exp % 10 + '0'));
 1099|  1.21k|  }
 1100|  1.21k|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_117WriteBufferToSinkEcNS_11string_viewERKNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
 1310|  1.25k|                       FormatSinkImpl *sink) {
 1311|  1.25k|  size_t left_spaces = 0, zeros = 0, right_spaces = 0;
 1312|  1.25k|  size_t missing_chars = 0;
 1313|  1.25k|  if (conv.width() >= 0) {
  ------------------
  |  Branch (1313:7): [True: 0, False: 1.25k]
  ------------------
 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.25k|  if (conv.has_left_flag()) {
  ------------------
  |  Branch (1320:7): [True: 0, False: 1.25k]
  ------------------
 1321|      0|    right_spaces = missing_chars;
 1322|  1.25k|  } else if (conv.has_zero_flag()) {
  ------------------
  |  Branch (1322:14): [True: 0, False: 1.25k]
  ------------------
 1323|      0|    zeros = missing_chars;
 1324|  1.25k|  } else {
 1325|  1.25k|    left_spaces = missing_chars;
 1326|  1.25k|  }
 1327|       |
 1328|  1.25k|  sink->Append(left_spaces, ' ');
 1329|  1.25k|  if (sign_char != '\0') sink->Append(1, sign_char);
  ------------------
  |  Branch (1329:7): [True: 722, False: 533]
  ------------------
 1330|  1.25k|  sink->Append(zeros, '0');
 1331|  1.25k|  sink->Append(str);
 1332|  1.25k|  sink->Append(right_spaces, ' ');
 1333|  1.25k|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_111FloatToSinkIdEEbT_RKNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
 1337|  2.48k|                 FormatSinkImpl *sink) {
 1338|       |  // Print the sign or the sign column.
 1339|  2.48k|  Float abs_v = v;
 1340|  2.48k|  char sign_char = 0;
 1341|  2.48k|  if (std::signbit(abs_v)) {
  ------------------
  |  Branch (1341:7): [True: 1.57k, False: 910]
  ------------------
 1342|  1.57k|    sign_char = '-';
 1343|  1.57k|    abs_v = -abs_v;
 1344|  1.57k|  } else if (conv.has_show_pos_flag()) {
  ------------------
  |  Branch (1344:14): [True: 0, False: 910]
  ------------------
 1345|      0|    sign_char = '+';
 1346|    910|  } else if (conv.has_sign_col_flag()) {
  ------------------
  |  Branch (1346:14): [True: 0, False: 910]
  ------------------
 1347|      0|    sign_char = ' ';
 1348|      0|  }
 1349|       |
 1350|       |  // Print nan/inf.
 1351|  2.48k|  if (ConvertNonNumericFloats(sign_char, abs_v, conv, sink)) {
  ------------------
  |  Branch (1351:7): [True: 0, False: 2.48k]
  ------------------
 1352|      0|    return true;
 1353|      0|  }
 1354|       |
 1355|  2.48k|  size_t precision =
 1356|  2.48k|      conv.precision() < 0 ? 6 : static_cast<size_t>(conv.precision());
  ------------------
  |  Branch (1356:7): [True: 2.48k, False: 0]
  ------------------
 1357|       |
 1358|  2.48k|  int exp = 0;
 1359|       |
 1360|  2.48k|  auto decomposed = Decompose(abs_v);
 1361|       |
 1362|  2.48k|  Buffer buffer;
 1363|       |
 1364|  2.48k|  FormatConversionChar c = conv.conversion_char();
 1365|       |
 1366|  2.48k|  if (c == FormatConversionCharInternal::f ||
  ------------------
  |  Branch (1366:7): [True: 0, False: 2.48k]
  ------------------
 1367|  2.48k|      c == FormatConversionCharInternal::F) {
  ------------------
  |  Branch (1367:7): [True: 0, False: 2.48k]
  ------------------
 1368|      0|    FormatF(decomposed.mantissa, decomposed.exponent,
 1369|      0|            {sign_char, precision, conv, sink});
 1370|      0|    return true;
 1371|  2.48k|  } else if (c == FormatConversionCharInternal::e ||
  ------------------
  |  Branch (1371:14): [True: 0, False: 2.48k]
  ------------------
 1372|  2.48k|             c == FormatConversionCharInternal::E) {
  ------------------
  |  Branch (1372:14): [True: 0, False: 2.48k]
  ------------------
 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.48k|  } else if (c == FormatConversionCharInternal::g ||
  ------------------
  |  Branch (1381:14): [True: 2.48k, False: 0]
  ------------------
 1382|  2.48k|             c == FormatConversionCharInternal::G) {
  ------------------
  |  Branch (1382:14): [True: 0, False: 0]
  ------------------
 1383|  2.48k|    precision = std::max(precision, size_t{1}) - 1;
 1384|  2.48k|    if (!FloatToBuffer<FormatStyle::Precision>(decomposed, precision, &buffer,
  ------------------
  |  Branch (1384:9): [True: 1.22k, False: 1.25k]
  ------------------
 1385|  2.48k|                                               &exp)) {
 1386|  1.22k|      return FallbackToSnprintf(v, conv, sink);
 1387|  1.22k|    }
 1388|  1.25k|    if ((exp < 0 || precision + 1 > static_cast<size_t>(exp)) && exp >= -4) {
  ------------------
  |  Branch (1388:10): [True: 0, False: 1.25k]
  |  Branch (1388:21): [True: 37, False: 1.21k]
  |  Branch (1388:66): [True: 37, False: 0]
  ------------------
 1389|     37|      if (exp < 0) {
  ------------------
  |  Branch (1389:11): [True: 0, False: 37]
  ------------------
 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|     37|      } else if (exp > 0) {
  ------------------
  |  Branch (1397:18): [True: 0, False: 37]
  ------------------
 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|     37|      exp = 0;
 1403|     37|    }
 1404|  1.25k|    if (!conv.has_alt_flag()) {
  ------------------
  |  Branch (1404:9): [True: 1.25k, False: 0]
  ------------------
 1405|  2.00k|      while (buffer.back() == '0') buffer.pop_back();
  ------------------
  |  Branch (1405:14): [True: 750, False: 1.25k]
  ------------------
 1406|  1.25k|      if (buffer.back() == '.') buffer.pop_back();
  ------------------
  |  Branch (1406:11): [True: 119, False: 1.13k]
  ------------------
 1407|  1.25k|    }
 1408|  1.25k|    if (exp) {
  ------------------
  |  Branch (1408:9): [True: 1.21k, False: 37]
  ------------------
 1409|  1.21k|      PrintExponent(
 1410|  1.21k|          exp, FormatConversionCharIsUpper(conv.conversion_char()) ? 'E' : 'e',
  ------------------
  |  Branch (1410:16): [True: 0, False: 1.21k]
  ------------------
 1411|  1.21k|          &buffer);
 1412|  1.21k|    }
 1413|  1.25k|  } 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.25k|  WriteBufferToSink(
 1424|  1.25k|      sign_char,
 1425|  1.25k|      absl::string_view(buffer.begin,
 1426|  1.25k|                        static_cast<size_t>(buffer.end - buffer.begin)),
 1427|  1.25k|      conv, sink);
 1428|       |
 1429|  1.25k|  return true;
 1430|  2.48k|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_123ConvertNonNumericFloatsIdEEbcT_RKNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
 1039|  2.48k|                             FormatSinkImpl *sink) {
 1040|  2.48k|  char text[4], *ptr = text;
 1041|  2.48k|  if (sign_char != '\0') *ptr++ = sign_char;
  ------------------
  |  Branch (1041:7): [True: 1.57k, False: 910]
  ------------------
 1042|  2.48k|  if (std::isnan(v)) {
  ------------------
  |  Branch (1042:7): [True: 0, False: 2.48k]
  ------------------
 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.48k|  } else if (std::isinf(v)) {
  ------------------
  |  Branch (1046:14): [True: 0, False: 2.48k]
  ------------------
 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.48k|  } else {
 1051|  2.48k|    return false;
 1052|  2.48k|  }
 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.48k|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_19DecomposeIdEENS1_10DecomposedIT_EES4_:
 1127|  2.48k|Decomposed<Float> Decompose(Float v) {
 1128|  2.48k|  int exp;
 1129|  2.48k|  Float m = std::frexp(v, &exp);
 1130|  2.48k|  m = std::ldexp(m, std::numeric_limits<Float>::digits);
 1131|  2.48k|  exp -= std::numeric_limits<Float>::digits;
 1132|       |
 1133|  2.48k|  return {static_cast<typename Decomposed<Float>::MantissaType>(m), exp};
 1134|  2.48k|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_113FloatToBufferILNS1_11FormatStyleE1EdEEbNS1_10DecomposedIT0_EEmPNS1_6BufferEPi:
 1288|  2.48k|                   int* exp) {
 1289|  2.48k|  if (precision > kMaxFixedPrecision) return false;
  ------------------
  |  Branch (1289:7): [True: 0, False: 2.48k]
  ------------------
 1290|       |
 1291|       |  // Try with uint64_t.
 1292|  2.48k|  if (CanFitMantissa<Float, std::uint64_t>() &&
  ------------------
  |  Branch (1292:7): [Folded - Ignored]
  ------------------
 1293|  2.48k|      FloatToBufferImpl<std::uint64_t, Float, mode>(
  ------------------
  |  Branch (1293:7): [True: 37, False: 2.44k]
  ------------------
 1294|  2.48k|          static_cast<std::uint64_t>(decomposed.mantissa), decomposed.exponent,
 1295|  2.48k|          precision, out, exp))
 1296|     37|    return true;
 1297|       |
 1298|  2.44k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
 1299|       |  // If that is not enough, try with __uint128_t.
 1300|  2.44k|  return CanFitMantissa<Float, __uint128_t>() &&
  ------------------
  |  Branch (1300:10): [Folded - Ignored]
  ------------------
 1301|  2.44k|         FloatToBufferImpl<__uint128_t, Float, mode>(
  ------------------
  |  Branch (1301:10): [True: 1.21k, False: 1.22k]
  ------------------
 1302|  2.44k|             static_cast<__uint128_t>(decomposed.mantissa), decomposed.exponent,
 1303|  2.44k|             precision, out, exp);
 1304|      0|#endif
 1305|      0|  return false;
 1306|  2.48k|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_117FloatToBufferImplImdLNS1_11FormatStyleE1EEEbT_imPNS1_6BufferEPi:
 1193|  2.48k|                       int* exp_out) {
 1194|  2.48k|  assert((CanFitMantissa<Float, Int>()));
 1195|       |
 1196|  2.48k|  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.48k|  out->begin = out->end =
 1202|  2.48k|      out->data + 1 + kMaxFixedPrecision + (mode == FormatStyle::Precision);
 1203|       |
 1204|  2.48k|  if (exp >= 0) {
  ------------------
  |  Branch (1204:7): [True: 2.44k, False: 37]
  ------------------
 1205|  2.44k|    if (std::numeric_limits<Float>::digits + exp > int_bits) {
  ------------------
  |  Branch (1205:9): [True: 2.44k, False: 0]
  ------------------
 1206|       |      // The value will overflow the Int
 1207|  2.44k|      return false;
 1208|  2.44k|    }
 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|     37|  exp = -exp;
 1225|       |  // We need at least 4 empty bits for the next decimal digit.
 1226|       |  // We will multiply by 10.
 1227|     37|  if (exp > int_bits - 4) return false;
  ------------------
  |  Branch (1227:7): [True: 0, False: 37]
  ------------------
 1228|       |
 1229|     37|  const Int mask = (Int{1} << exp) - 1;
 1230|       |
 1231|       |  // Print the integral part first.
 1232|     37|  size_t digits_printed = PrintIntegralDigits<mode>(int_mantissa >> exp, out);
 1233|     37|  int_mantissa &= mask;
 1234|       |
 1235|     37|  size_t fractional_count = precision;
 1236|     37|  if (mode == FormatStyle::Precision) {
  ------------------
  |  Branch (1236:7): [Folded - Ignored]
  ------------------
 1237|     37|    if (digits_printed == 0) {
  ------------------
  |  Branch (1237:9): [True: 37, False: 0]
  ------------------
 1238|       |      // Find the first non-zero digit, when in Precision mode.
 1239|     37|      *exp_out = 0;
 1240|     37|      if (int_mantissa) {
  ------------------
  |  Branch (1240:11): [True: 0, False: 37]
  ------------------
 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|     37|      out->push_front(static_cast<char>(int_mantissa >> exp) + '0');
 1247|     37|      out->push_back('.');
 1248|     37|      int_mantissa &= mask;
 1249|     37|    } 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|     37|  }
 1262|       |
 1263|     37|  auto get_next_digit = [&] {
 1264|     37|    int_mantissa *= 10;
 1265|     37|    char digit = static_cast<char>(int_mantissa >> exp);
 1266|     37|    int_mantissa &= mask;
 1267|     37|    return digit;
 1268|     37|  };
 1269|       |
 1270|       |  // Print fractional_count more digits, if available.
 1271|    222|  for (; fractional_count > 0; --fractional_count) {
  ------------------
  |  Branch (1271:10): [True: 185, False: 37]
  ------------------
 1272|    185|    out->push_back(get_next_digit() + '0');
 1273|    185|  }
 1274|       |
 1275|     37|  char next_digit = get_next_digit();
 1276|     37|  if (next_digit > 5 ||
  ------------------
  |  Branch (1276:7): [True: 0, False: 37]
  ------------------
 1277|     37|      (next_digit == 5 && (int_mantissa || out->last_digit() % 2 == 1))) {
  ------------------
  |  Branch (1277:8): [True: 0, False: 37]
  |  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|     37|  return true;
 1282|     37|}
float_conversion.cc:_ZZN4absl19str_format_internal12_GLOBAL__N_117FloatToBufferImplImdLNS1_11FormatStyleE1EEEbT_imPNS1_6BufferEPiENKUlvE_clEv:
 1263|    222|  auto get_next_digit = [&] {
 1264|    222|    int_mantissa *= 10;
 1265|    222|    char digit = static_cast<char>(int_mantissa >> exp);
 1266|    222|    int_mantissa &= mask;
 1267|    222|    return digit;
 1268|    222|  };
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_117FloatToBufferImplIodLNS1_11FormatStyleE1EEEbT_imPNS1_6BufferEPi:
 1193|  2.44k|                       int* exp_out) {
 1194|  2.44k|  assert((CanFitMantissa<Float, Int>()));
 1195|       |
 1196|  2.44k|  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.44k|  out->begin = out->end =
 1202|  2.44k|      out->data + 1 + kMaxFixedPrecision + (mode == FormatStyle::Precision);
 1203|       |
 1204|  2.44k|  if (exp >= 0) {
  ------------------
  |  Branch (1204:7): [True: 2.44k, False: 0]
  ------------------
 1205|  2.44k|    if (std::numeric_limits<Float>::digits + exp > int_bits) {
  ------------------
  |  Branch (1205:9): [True: 1.22k, False: 1.21k]
  ------------------
 1206|       |      // The value will overflow the Int
 1207|  1.22k|      return false;
 1208|  1.22k|    }
 1209|  1.21k|    size_t digits_printed = PrintIntegralDigits<mode>(int_mantissa << exp, out);
 1210|  1.21k|    size_t digits_to_zero_pad = precision;
 1211|  1.21k|    if (mode == FormatStyle::Precision) {
  ------------------
  |  Branch (1211:9): [Folded - Ignored]
  ------------------
 1212|  1.21k|      *exp_out = static_cast<int>(digits_printed - 1);
 1213|  1.21k|      if (digits_to_zero_pad < digits_printed - 1) {
  ------------------
  |  Branch (1213:11): [True: 1.21k, False: 0]
  ------------------
 1214|  1.21k|        RemoveExtraPrecision(digits_printed - 1 - digits_to_zero_pad, false,
 1215|  1.21k|                             out, exp_out);
 1216|  1.21k|        return true;
 1217|  1.21k|      }
 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.21k|  }
 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.22k|                        FormatSinkImpl *sink) {
  964|  1.22k|  int w = conv.width() >= 0 ? conv.width() : 0;
  ------------------
  |  Branch (964:11): [True: 0, False: 1.22k]
  ------------------
  965|  1.22k|  int p = conv.precision() >= 0 ? conv.precision() : -1;
  ------------------
  |  Branch (965:11): [True: 0, False: 1.22k]
  ------------------
  966|  1.22k|  char fmt[32];
  967|  1.22k|  {
  968|  1.22k|    char *fp = fmt;
  969|  1.22k|    *fp++ = '%';
  970|  1.22k|    fp = CopyStringTo(FormatConversionSpecImplFriend::FlagsToString(conv), fp);
  971|  1.22k|    fp = CopyStringTo("*.*", fp);
  972|  1.22k|    if (std::is_same<long double, Float>()) {
  ------------------
  |  Branch (972:9): [Folded - Ignored]
  ------------------
  973|      0|      *fp++ = 'L';
  974|      0|    }
  975|  1.22k|    *fp++ = FormatConversionCharToChar(conv.conversion_char());
  976|  1.22k|    *fp = 0;
  977|  1.22k|    assert(fp < fmt + sizeof(fmt));
  978|  1.22k|  }
  979|  1.22k|  std::string space(512, '\0');
  980|  1.22k|  absl::string_view result;
  981|  1.22k|  while (true) {
  ------------------
  |  Branch (981:10): [Folded - Ignored]
  ------------------
  982|  1.22k|    int n = snprintf(&space[0], space.size(), fmt, w, p, v);
  983|  1.22k|    if (n < 0) return false;
  ------------------
  |  Branch (983:9): [True: 0, False: 1.22k]
  ------------------
  984|  1.22k|    if (static_cast<size_t>(n) < space.size()) {
  ------------------
  |  Branch (984:9): [True: 1.22k, False: 0]
  ------------------
  985|  1.22k|      result = absl::string_view(space.data(), static_cast<size_t>(n));
  986|  1.22k|      break;
  987|  1.22k|    }
  988|      0|    space.resize(static_cast<size_t>(n) + 1);
  989|      0|  }
  990|  1.22k|  sink->Append(result);
  991|  1.22k|  return true;
  992|  1.22k|}

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

bind.cc:_ZN4absl19str_format_internal17ParseFormatStringINS0_12_GLOBAL__N_117ConverterConsumerINS2_16DefaultConverterEEEEEbNS_11string_viewET_:
   57|  4.96k|bool ParseFormatString(string_view src, Consumer consumer) {
   58|  4.96k|  int next_arg = 0;
   59|  4.96k|  const char* p = src.data();
   60|  4.96k|  const char* const end = p + src.size();
   61|  9.92k|  while (p != end) {
  ------------------
  |  Branch (61:10): [True: 4.96k, False: 4.96k]
  ------------------
   62|  4.96k|    const char* percent =
   63|  4.96k|        static_cast<const char*>(memchr(p, '%', static_cast<size_t>(end - p)));
   64|  4.96k|    if (!percent) {
  ------------------
  |  Branch (64:9): [True: 0, False: 4.96k]
  ------------------
   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|  4.96k|    if (ABSL_PREDICT_FALSE(!consumer.Append(
  ------------------
  |  |  189|  4.96k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 4.96k]
  |  |  |  Branch (189:49): [Folded - Ignored]
  |  |  |  Branch (189:58): [True: 0, False: 4.96k]
  |  |  ------------------
  ------------------
   70|  4.96k|            string_view(p, static_cast<size_t>(percent - p))))) {
   71|      0|      return false;
   72|      0|    }
   73|  4.96k|    if (ABSL_PREDICT_FALSE(percent + 1 >= end)) return false;
  ------------------
  |  |  189|  4.96k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 4.96k]
  |  |  |  Branch (189:49): [Folded - Ignored]
  |  |  |  Branch (189:58): [True: 0, False: 4.96k]
  |  |  ------------------
  ------------------
   74|       |
   75|  4.96k|    auto tag = GetTagForChar(percent[1]);
   76|  4.96k|    if (tag.is_conv()) {
  ------------------
  |  Branch (76:9): [True: 4.96k, False: 0]
  ------------------
   77|  4.96k|      if (ABSL_PREDICT_FALSE(next_arg < 0)) {
  ------------------
  |  |  189|  4.96k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 4.96k]
  |  |  |  Branch (189:49): [Folded - Ignored]
  |  |  |  Branch (189:58): [True: 0, False: 4.96k]
  |  |  ------------------
  ------------------
   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|  4.96k|      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|  4.96k|      UnboundConversion conv;
   90|  4.96k|      conv.conv = tag.as_conv();
   91|  4.96k|      conv.arg_position = ++next_arg;
   92|  4.96k|      if (ABSL_PREDICT_FALSE(
  ------------------
  |  |  189|  4.96k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 4.96k]
  |  |  |  Branch (189:49): [Folded - Ignored]
  |  |  |  Branch (189:58): [True: 0, False: 4.96k]
  |  |  ------------------
  ------------------
   93|  4.96k|              !consumer.ConvertOne(conv, string_view(percent + 1, 1)))) {
   94|      0|        return false;
   95|      0|      }
   96|  4.96k|    } 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;
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded - Ignored]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  100|      0|      if (ABSL_PREDICT_FALSE(!consumer.ConvertOne(
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded - Ignored]
  |  |  |  Branch (189: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;
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded - Ignored]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  107|      0|      p = percent + 2;
  108|      0|      continue;
  109|      0|    }
  110|  4.96k|  }
  111|  4.96k|  return true;
  112|  4.96k|}

_ZN4absl16strings_internal9JoinRangeINSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEEEES9_RKT_NS_11string_viewE:
  319|  1.24k|std::string JoinRange(const Range& range, absl::string_view separator) {
  320|  1.24k|  using std::begin;
  321|  1.24k|  using std::end;
  322|  1.24k|  return JoinRange(begin(range), end(range), separator);
  323|  1.24k|}
_ZN4absl16strings_internal9JoinRangeINSt3__111__wrap_iterIPKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEES9_T_SD_NS_11string_viewE:
  303|  1.24k|                      absl::string_view separator) {
  304|       |  // No formatter was explicitly given, so a default must be chosen.
  305|  1.24k|  typedef typename std::iterator_traits<Iterator>::value_type ValueType;
  306|  1.24k|  typedef typename DefaultFormatter<ValueType>::Type Formatter;
  307|  1.24k|  return JoinAlgorithm(first, last, separator, Formatter());
  308|  1.24k|}
_ZN4absl16strings_internal13JoinAlgorithmINSt3__111__wrap_iterIPKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEvEES9_T_SD_NS_11string_viewENS0_11NoFormatterE:
  235|  1.24k|                          NoFormatter) {
  236|  1.24k|  std::string result;
  237|  1.24k|  if (start != end) {
  ------------------
  |  Branch (237:7): [True: 1.24k, False: 0]
  ------------------
  238|       |    // Sums size
  239|  1.24k|    auto&& start_value = *start;
  240|       |    // Use uint64_t to prevent size_t overflow. We assume it is not possible for
  241|       |    // in memory strings to overflow a uint64_t.
  242|  1.24k|    uint64_t result_size = start_value.size();
  243|  13.6M|    for (Iterator it = start; ++it != end;) {
  ------------------
  |  Branch (243:31): [True: 13.6M, False: 1.24k]
  ------------------
  244|  13.6M|      result_size += s.size();
  245|  13.6M|      result_size += (*it).size();
  246|  13.6M|    }
  247|       |
  248|  1.24k|    if (result_size > 0) {
  ------------------
  |  Branch (248:9): [True: 1.24k, False: 0]
  ------------------
  249|  1.24k|      constexpr uint64_t kMaxSize =
  250|  1.24k|          uint64_t{(std::numeric_limits<size_t>::max)()};
  251|  1.24k|      ABSL_INTERNAL_CHECK(result_size <= kMaxSize, "size_t overflow");
  ------------------
  |  |   85|  1.24k|  do {                                                             \
  |  |   86|  1.24k|    if (ABSL_PREDICT_FALSE(!(condition))) {                        \
  |  |  ------------------
  |  |  |  |  189|  1.24k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 1.24k]
  |  |  |  |  |  Branch (189:49): [Folded - Ignored]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 1.24k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   87|      0|      std::string death_message = "Check " #condition " failed: "; \
  |  |   88|      0|      death_message += std::string(message);                       \
  |  |   89|      0|      ABSL_INTERNAL_LOG(FATAL, death_message);                     \
  |  |  ------------------
  |  |  |  |   76|      0|  do {                                                                    \
  |  |  |  |   77|      0|    constexpr const char* absl_raw_log_internal_filename = __FILE__;      \
  |  |  |  |   78|      0|    ::absl::raw_log_internal::internal_log_function(                      \
  |  |  |  |   79|      0|        ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \
  |  |  |  |   80|      0|        __LINE__, message);                                               \
  |  |  |  |   81|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                   \
  |  |  |  |   82|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (82:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|    }                                                              \
  |  |   91|  1.24k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (91:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  252|  1.24k|      STLStringResizeUninitialized(&result, static_cast<size_t>(result_size));
  253|       |
  254|       |      // Joins strings
  255|  1.24k|      char* result_buf = &*result.begin();
  256|       |
  257|  1.24k|      memcpy(result_buf, start_value.data(), start_value.size());
  258|  1.24k|      result_buf += start_value.size();
  259|  13.6M|      for (Iterator it = start; ++it != end;) {
  ------------------
  |  Branch (259:33): [True: 13.6M, False: 1.24k]
  ------------------
  260|  13.6M|        memcpy(result_buf, s.data(), s.size());
  261|  13.6M|        result_buf += s.size();
  262|  13.6M|        auto&& value = *it;
  263|  13.6M|        memcpy(result_buf, value.data(), value.size());
  264|  13.6M|        result_buf += value.size();
  265|  13.6M|      }
  266|  1.24k|    }
  267|  1.24k|  }
  268|       |
  269|  1.24k|  return result;
  270|  1.24k|}

_ZN4absl16strings_internal23ConvertibleToStringViewC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
   66|  1.24k|      : value_(s) {}
_ZNK4absl16strings_internal23ConvertibleToStringView5valueEv:
   72|  1.24k|  absl::string_view value() const { return value_; }
_ZN4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEEC2ES4_S2_S3_:
  289|  1.24k|        predicate_(std::move(p)) {}
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEEcvT_INSt3__16vectorINS8_12basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEENSD_ISF_EEEELDn0EEEv:
  320|  1.24k|  operator Container() const {
  321|  1.24k|    return ConvertToContainer<Container, typename Container::value_type,
  322|  1.24k|                              HasMappedType<Container>::value>()(*this);
  323|  1.24k|  }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEE18ConvertToContainerINSt3__16vectorINS7_12basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEENSC_ISE_EEEESE_Lb0EEclERKS5_:
  423|  1.24k|    std::vector<std::string, A> operator()(const Splitter& splitter) const {
  424|  1.24k|      const std::vector<absl::string_view> v = splitter;
  425|  1.24k|      return std::vector<std::string, A>(v.begin(), v.end());
  426|  1.24k|    }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEEcvT_INSt3__16vectorIS4_NS8_9allocatorIS4_EEEELDn0EEEv:
  320|  1.24k|  operator Container() const {
  321|  1.24k|    return ConvertToContainer<Container, typename Container::value_type,
  322|  1.24k|                              HasMappedType<Container>::value>()(*this);
  323|  1.24k|  }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEE18ConvertToContainerINSt3__16vectorIS4_NS7_9allocatorIS4_EEEES4_Lb0EEclERKS5_:
  389|  1.24k|        const Splitter& splitter) const {
  390|  1.24k|      struct raw_view {
  391|  1.24k|        const char* data;
  392|  1.24k|        size_t size;
  393|  1.24k|        operator absl::string_view() const {  // NOLINT(runtime/explicit)
  394|  1.24k|          return {data, size};
  395|  1.24k|        }
  396|  1.24k|      };
  397|  1.24k|      std::vector<absl::string_view, A> v;
  398|  1.24k|      std::array<raw_view, 16> ar;
  399|   852k|      for (auto it = splitter.begin(); !it.at_end();) {
  ------------------
  |  Branch (399:40): [True: 851k, False: 1.24k]
  ------------------
  400|   851k|        size_t index = 0;
  401|  13.6M|        do {
  402|  13.6M|          ar[index].data = it->data();
  403|  13.6M|          ar[index].size = it->size();
  404|  13.6M|          ++it;
  405|  13.6M|        } while (++index != ar.size() && !it.at_end());
  ------------------
  |  Branch (405:18): [True: 12.7M, False: 850k]
  |  Branch (405:42): [True: 12.7M, False: 1.20k]
  ------------------
  406|       |        // We static_cast index to a signed type to work around overzealous
  407|       |        // compiler warnings about signedness.
  408|   851k|        v.insert(v.end(), ar.begin(),
  409|   851k|                 ar.begin() + static_cast<ptrdiff_t>(index));
  410|   851k|      }
  411|  1.24k|      return v;
  412|  1.24k|    }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEE5beginEv:
  298|  1.24k|  const_iterator begin() const { return {const_iterator::kInitState, this}; }
_ZN4absl16strings_internal13SplitIteratorINS0_8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEEEEC2ENS7_5StateEPKS6_:
   99|  1.24k|        predicate_(splitter->predicate()) {
  100|       |    // Hack to maintain backward compatibility. This one block makes it so an
  101|       |    // empty absl::string_view whose .data() happens to be nullptr behaves
  102|       |    // *differently* from an otherwise empty absl::string_view whose .data() is
  103|       |    // not nullptr. This is an undesirable difference in general, but this
  104|       |    // behavior is maintained to avoid breaking existing code that happens to
  105|       |    // depend on this old behavior/bug. Perhaps it will be fixed one day. The
  106|       |    // difference in behavior is as follows:
  107|       |    //   Split(absl::string_view(""), '-');  // {""}
  108|       |    //   Split(absl::string_view(), '-');    // {}
  109|  1.24k|    if (splitter_->text().data() == nullptr) {
  ------------------
  |  Branch (109:9): [True: 0, False: 1.24k]
  ------------------
  110|      0|      state_ = kEndState;
  111|      0|      pos_ = splitter_->text().size();
  112|      0|      return;
  113|      0|    }
  114|       |
  115|  1.24k|    if (state_ == kEndState) {
  ------------------
  |  Branch (115:9): [True: 0, False: 1.24k]
  ------------------
  116|      0|      pos_ = splitter_->text().size();
  117|  1.24k|    } else {
  118|  1.24k|      ++(*this);
  119|  1.24k|    }
  120|  1.24k|  }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEE9delimiterEv:
  292|  1.24k|  const Delimiter& delimiter() const { return delimiter_; }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEE9predicateEv:
  293|  1.24k|  const Predicate& predicate() const { return predicate_; }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEE4textEv:
  291|  13.6M|  absl::string_view text() const { return text_; }
_ZNK4absl16strings_internal13SplitIteratorINS0_8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEEEE6at_endEv:
  122|  13.6M|  bool at_end() const { return state_ == kEndState; }
_ZNK4absl16strings_internal13SplitIteratorINS0_8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEEEEptEv:
  125|  27.2M|  pointer operator->() const { return &curr_; }
_ZN4absl16strings_internal13SplitIteratorINS0_8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEEEEppEv:
  127|  13.6M|  SplitIterator& operator++() {
  128|  13.6M|    do {
  129|  13.6M|      if (state_ == kLastState) {
  ------------------
  |  Branch (129:11): [True: 1.24k, False: 13.6M]
  ------------------
  130|  1.24k|        state_ = kEndState;
  131|  1.24k|        return *this;
  132|  1.24k|      }
  133|  13.6M|      const absl::string_view text = splitter_->text();
  134|  13.6M|      const absl::string_view d = delimiter_.Find(text, pos_);
  135|  13.6M|      if (d.data() == text.data() + text.size()) state_ = kLastState;
  ------------------
  |  Branch (135:11): [True: 1.24k, False: 13.6M]
  ------------------
  136|  13.6M|      curr_ = text.substr(pos_,
  137|  13.6M|                          static_cast<size_t>(d.data() - (text.data() + pos_)));
  138|  13.6M|      pos_ += curr_.size() + d.size();
  139|  13.6M|    } while (!predicate_(curr_));
  ------------------
  |  Branch (139:14): [True: 0, False: 13.6M]
  ------------------
  140|  13.6M|    return *this;
  141|  13.6M|  }
_ZZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENS_11string_viewEE18ConvertToContainerINSt3__16vectorIS4_NS7_9allocatorIS4_EEEES4_Lb0EEclERKS5_ENK8raw_viewcvS4_Ev:
  393|  13.6M|        operator absl::string_view() const {  // NOLINT(runtime/explicit)
  394|  13.6M|          return {data, size};
  395|  13.6M|        }

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

_ZN4absl10SimpleAtofENS_11string_viewEPf:
   49|  1.24k|bool SimpleAtof(absl::string_view str, absl::Nonnull<float*> out) {
   50|  1.24k|  *out = 0.0;
   51|  1.24k|  str = StripAsciiWhitespace(str);
   52|       |  // std::from_chars doesn't accept an initial +, but SimpleAtof does, so if one
   53|       |  // is present, skip it, while avoiding accepting "+-0" as valid.
   54|  1.24k|  if (!str.empty() && str[0] == '+') {
  ------------------
  |  Branch (54:7): [True: 1.24k, False: 0]
  |  Branch (54:23): [True: 0, False: 1.24k]
  ------------------
   55|      0|    str.remove_prefix(1);
   56|      0|    if (!str.empty() && str[0] == '-') {
  ------------------
  |  Branch (56:9): [True: 0, False: 0]
  |  Branch (56:25): [True: 0, False: 0]
  ------------------
   57|      0|      return false;
   58|      0|    }
   59|      0|  }
   60|  1.24k|  auto result = absl::from_chars(str.data(), str.data() + str.size(), *out);
   61|  1.24k|  if (result.ec == std::errc::invalid_argument) {
  ------------------
  |  Branch (61:7): [True: 0, False: 1.24k]
  ------------------
   62|      0|    return false;
   63|      0|  }
   64|  1.24k|  if (result.ptr != str.data() + str.size()) {
  ------------------
  |  Branch (64:7): [True: 0, False: 1.24k]
  ------------------
   65|       |    // not all non-whitespace characters consumed
   66|      0|    return false;
   67|      0|  }
   68|       |  // from_chars() with DR 3081's current wording will return max() on
   69|       |  // overflow.  SimpleAtof returns infinity instead.
   70|  1.24k|  if (result.ec == std::errc::result_out_of_range) {
  ------------------
  |  Branch (70:7): [True: 0, False: 1.24k]
  ------------------
   71|      0|    if (*out > 1.0) {
  ------------------
  |  Branch (71:9): [True: 0, False: 0]
  ------------------
   72|      0|      *out = std::numeric_limits<float>::infinity();
   73|      0|    } else if (*out < -1.0) {
  ------------------
  |  Branch (73:16): [True: 0, False: 0]
  ------------------
   74|      0|      *out = -std::numeric_limits<float>::infinity();
   75|      0|    }
   76|      0|  }
   77|  1.24k|  return true;
   78|  1.24k|}
_ZN4absl10SimpleAtodENS_11string_viewEPd:
   80|  1.24k|bool SimpleAtod(absl::string_view str, absl::Nonnull<double*> out) {
   81|  1.24k|  *out = 0.0;
   82|  1.24k|  str = StripAsciiWhitespace(str);
   83|       |  // std::from_chars doesn't accept an initial +, but SimpleAtod does, so if one
   84|       |  // is present, skip it, while avoiding accepting "+-0" as valid.
   85|  1.24k|  if (!str.empty() && str[0] == '+') {
  ------------------
  |  Branch (85:7): [True: 1.24k, False: 0]
  |  Branch (85:23): [True: 0, False: 1.24k]
  ------------------
   86|      0|    str.remove_prefix(1);
   87|      0|    if (!str.empty() && str[0] == '-') {
  ------------------
  |  Branch (87:9): [True: 0, False: 0]
  |  Branch (87:25): [True: 0, False: 0]
  ------------------
   88|      0|      return false;
   89|      0|    }
   90|      0|  }
   91|  1.24k|  auto result = absl::from_chars(str.data(), str.data() + str.size(), *out);
   92|  1.24k|  if (result.ec == std::errc::invalid_argument) {
  ------------------
  |  Branch (92:7): [True: 0, False: 1.24k]
  ------------------
   93|      0|    return false;
   94|      0|  }
   95|  1.24k|  if (result.ptr != str.data() + str.size()) {
  ------------------
  |  Branch (95:7): [True: 0, False: 1.24k]
  ------------------
   96|       |    // not all non-whitespace characters consumed
   97|      0|    return false;
   98|      0|  }
   99|       |  // from_chars() with DR 3081's current wording will return max() on
  100|       |  // overflow.  SimpleAtod returns infinity instead.
  101|  1.24k|  if (result.ec == std::errc::result_out_of_range) {
  ------------------
  |  Branch (101:7): [True: 0, False: 1.24k]
  ------------------
  102|      0|    if (*out > 1.0) {
  ------------------
  |  Branch (102:9): [True: 0, False: 0]
  ------------------
  103|      0|      *out = std::numeric_limits<double>::infinity();
  104|      0|    } else if (*out < -1.0) {
  ------------------
  |  Branch (104:16): [True: 0, False: 0]
  ------------------
  105|      0|      *out = -std::numeric_limits<double>::infinity();
  106|      0|    }
  107|      0|  }
  108|  1.24k|  return true;
  109|  1.24k|}
_ZN4absl10SimpleAtobENS_11string_viewEPb:
  111|  1.24k|bool SimpleAtob(absl::string_view str, absl::Nonnull<bool*> out) {
  112|  1.24k|  ABSL_RAW_CHECK(out != nullptr, "Output pointer must not be nullptr.");
  ------------------
  |  |   60|  1.24k|  do {                                                                 \
  |  |   61|  1.24k|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|  1.24k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 1.24k]
  |  |  |  |  |  Branch (189:49): [Folded - Ignored]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 1.24k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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.24k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  113|  1.24k|  if (EqualsIgnoreCase(str, "true") || EqualsIgnoreCase(str, "t") ||
  ------------------
  |  Branch (113:7): [True: 0, False: 1.24k]
  |  Branch (113:7): [True: 189, False: 1.05k]
  |  Branch (113:40): [True: 0, False: 1.24k]
  ------------------
  114|  1.24k|      EqualsIgnoreCase(str, "yes") || EqualsIgnoreCase(str, "y") ||
  ------------------
  |  Branch (114:7): [True: 0, False: 1.24k]
  |  Branch (114:39): [True: 0, False: 1.24k]
  ------------------
  115|  1.24k|      EqualsIgnoreCase(str, "1")) {
  ------------------
  |  Branch (115:7): [True: 189, False: 1.05k]
  ------------------
  116|    189|    *out = true;
  117|    189|    return true;
  118|    189|  }
  119|  1.05k|  if (EqualsIgnoreCase(str, "false") || EqualsIgnoreCase(str, "f") ||
  ------------------
  |  Branch (119:7): [True: 0, False: 1.05k]
  |  Branch (119:7): [True: 1.05k, False: 0]
  |  Branch (119:41): [True: 0, False: 1.05k]
  ------------------
  120|  1.05k|      EqualsIgnoreCase(str, "no") || EqualsIgnoreCase(str, "n") ||
  ------------------
  |  Branch (120:7): [True: 0, False: 1.05k]
  |  Branch (120:38): [True: 0, False: 1.05k]
  ------------------
  121|  1.05k|      EqualsIgnoreCase(str, "0")) {
  ------------------
  |  Branch (121:7): [True: 1.05k, False: 0]
  ------------------
  122|  1.05k|    *out = false;
  123|  1.05k|    return true;
  124|  1.05k|  }
  125|      0|  return false;
  126|  1.05k|}
_ZN4absl16numbers_internal12PutTwoDigitsEjPc:
  286|  9.78k|void numbers_internal::PutTwoDigits(uint32_t i, absl::Nonnull<char*> buf) {
  287|  9.78k|  assert(i < 100);
  288|  9.78k|  uint32_t base = kTwoZeroBytes;
  289|  9.78k|  uint32_t div10 = (i * kDivisionBy10Mul) / kDivisionBy10Div;
  290|  9.78k|  uint32_t mod10 = i - 10u * div10;
  291|  9.78k|  base += div10 + (mod10 << 8);
  292|  9.78k|  little_endian::Store16(buf, static_cast<uint16_t>(base));
  293|  9.78k|}
_ZN4absl16numbers_internal15FastIntToBufferEiPc:
  303|  4.96k|    int32_t i, absl::Nonnull<char*> buffer) {
  304|  4.96k|  uint32_t u = static_cast<uint32_t>(i);
  305|  4.96k|  if (i < 0) {
  ------------------
  |  Branch (305:7): [True: 2.21k, False: 2.74k]
  ------------------
  306|  2.21k|    *buffer++ = '-';
  307|       |    // We need to do the negation in modular (i.e., "unsigned")
  308|       |    // arithmetic; MSVC++ apparently warns for plain "-u", so
  309|       |    // we write the equivalent expression "0 - u" instead.
  310|  2.21k|    u = 0 - u;
  311|  2.21k|  }
  312|  4.96k|  buffer = EncodeFullU32(u, buffer);
  313|  4.96k|  *buffer = '\0';
  314|  4.96k|  return buffer;
  315|  4.96k|}
_ZN4absl16numbers_internal17SixDigitsToBufferEdPc:
  547|  2.48k|                                           absl::Nonnull<char*> const buffer) {
  548|  2.48k|  static_assert(std::numeric_limits<float>::is_iec559,
  549|  2.48k|                "IEEE-754/IEC-559 support only");
  550|       |
  551|  2.48k|  char* out = buffer;  // we write data to out, incrementing as we go, but
  552|       |                       // FloatToBuffer always returns the address of the buffer
  553|       |                       // passed in.
  554|       |
  555|  2.48k|  if (std::isnan(d)) {
  ------------------
  |  Branch (555:7): [True: 0, False: 2.48k]
  ------------------
  556|      0|    strcpy(out, "nan");  // NOLINT(runtime/printf)
  557|      0|    return 3;
  558|      0|  }
  559|  2.48k|  if (d == 0) {  // +0 and -0 are handled here
  ------------------
  |  Branch (559:7): [True: 37, False: 2.44k]
  ------------------
  560|     37|    if (std::signbit(d)) *out++ = '-';
  ------------------
  |  Branch (560:9): [True: 0, False: 37]
  ------------------
  561|     37|    *out++ = '0';
  562|     37|    *out = 0;
  563|     37|    return static_cast<size_t>(out - buffer);
  564|     37|  }
  565|  2.44k|  if (d < 0) {
  ------------------
  |  Branch (565:7): [True: 1.57k, False: 873]
  ------------------
  566|  1.57k|    *out++ = '-';
  567|  1.57k|    d = -d;
  568|  1.57k|  }
  569|  2.44k|  if (d > std::numeric_limits<double>::max()) {
  ------------------
  |  Branch (569:7): [True: 0, False: 2.44k]
  ------------------
  570|      0|    strcpy(out, "inf");  // NOLINT(runtime/printf)
  571|      0|    return static_cast<size_t>(out + 3 - buffer);
  572|      0|  }
  573|       |
  574|  2.44k|  auto exp_dig = SplitToSix(d);
  575|  2.44k|  int exp = exp_dig.exponent;
  576|  2.44k|  const char* digits = exp_dig.digits;
  577|  2.44k|  out[0] = '0';
  578|  2.44k|  out[1] = '.';
  579|  2.44k|  switch (exp) {
  ------------------
  |  Branch (579:11): [True: 2.44k, False: 0]
  ------------------
  580|      0|    case 5:
  ------------------
  |  Branch (580:5): [True: 0, False: 2.44k]
  ------------------
  581|      0|      memcpy(out, &digits[0], 6), out += 6;
  582|      0|      *out = 0;
  583|      0|      return static_cast<size_t>(out - buffer);
  584|      0|    case 4:
  ------------------
  |  Branch (584:5): [True: 0, False: 2.44k]
  ------------------
  585|      0|      memcpy(out, &digits[0], 5), out += 5;
  586|      0|      if (digits[5] != '0') {
  ------------------
  |  Branch (586:11): [True: 0, False: 0]
  ------------------
  587|      0|        *out++ = '.';
  588|      0|        *out++ = digits[5];
  589|      0|      }
  590|      0|      *out = 0;
  591|      0|      return static_cast<size_t>(out - buffer);
  592|      0|    case 3:
  ------------------
  |  Branch (592:5): [True: 0, False: 2.44k]
  ------------------
  593|      0|      memcpy(out, &digits[0], 4), out += 4;
  594|      0|      if ((digits[5] | digits[4]) != '0') {
  ------------------
  |  Branch (594:11): [True: 0, False: 0]
  ------------------
  595|      0|        *out++ = '.';
  596|      0|        *out++ = digits[4];
  597|      0|        if (digits[5] != '0') *out++ = digits[5];
  ------------------
  |  Branch (597:13): [True: 0, False: 0]
  ------------------
  598|      0|      }
  599|      0|      *out = 0;
  600|      0|      return static_cast<size_t>(out - buffer);
  601|      0|    case 2:
  ------------------
  |  Branch (601:5): [True: 0, False: 2.44k]
  ------------------
  602|      0|      memcpy(out, &digits[0], 3), out += 3;
  603|      0|      *out++ = '.';
  604|      0|      memcpy(out, &digits[3], 3);
  605|      0|      out += 3;
  606|      0|      while (out[-1] == '0') --out;
  ------------------
  |  Branch (606:14): [True: 0, False: 0]
  ------------------
  607|      0|      if (out[-1] == '.') --out;
  ------------------
  |  Branch (607:11): [True: 0, False: 0]
  ------------------
  608|      0|      *out = 0;
  609|      0|      return static_cast<size_t>(out - buffer);
  610|      0|    case 1:
  ------------------
  |  Branch (610:5): [True: 0, False: 2.44k]
  ------------------
  611|      0|      memcpy(out, &digits[0], 2), out += 2;
  612|      0|      *out++ = '.';
  613|      0|      memcpy(out, &digits[2], 4);
  614|      0|      out += 4;
  615|      0|      while (out[-1] == '0') --out;
  ------------------
  |  Branch (615:14): [True: 0, False: 0]
  ------------------
  616|      0|      if (out[-1] == '.') --out;
  ------------------
  |  Branch (616:11): [True: 0, False: 0]
  ------------------
  617|      0|      *out = 0;
  618|      0|      return static_cast<size_t>(out - buffer);
  619|      0|    case 0:
  ------------------
  |  Branch (619:5): [True: 0, False: 2.44k]
  ------------------
  620|      0|      memcpy(out, &digits[0], 1), out += 1;
  621|      0|      *out++ = '.';
  622|      0|      memcpy(out, &digits[1], 5);
  623|      0|      out += 5;
  624|      0|      while (out[-1] == '0') --out;
  ------------------
  |  Branch (624:14): [True: 0, False: 0]
  ------------------
  625|      0|      if (out[-1] == '.') --out;
  ------------------
  |  Branch (625:11): [True: 0, False: 0]
  ------------------
  626|      0|      *out = 0;
  627|      0|      return static_cast<size_t>(out - buffer);
  628|      0|    case -4:
  ------------------
  |  Branch (628:5): [True: 0, False: 2.44k]
  ------------------
  629|      0|      out[2] = '0';
  630|      0|      ++out;
  631|      0|      ABSL_FALLTHROUGH_INTENDED;
  ------------------
  |  |  649|      0|#define ABSL_FALLTHROUGH_INTENDED [[fallthrough]]
  ------------------
  632|      0|    case -3:
  ------------------
  |  Branch (632:5): [True: 0, False: 2.44k]
  ------------------
  633|      0|      out[2] = '0';
  634|      0|      ++out;
  635|      0|      ABSL_FALLTHROUGH_INTENDED;
  ------------------
  |  |  649|      0|#define ABSL_FALLTHROUGH_INTENDED [[fallthrough]]
  ------------------
  636|      0|    case -2:
  ------------------
  |  Branch (636:5): [True: 0, False: 2.44k]
  ------------------
  637|      0|      out[2] = '0';
  638|      0|      ++out;
  639|      0|      ABSL_FALLTHROUGH_INTENDED;
  ------------------
  |  |  649|      0|#define ABSL_FALLTHROUGH_INTENDED [[fallthrough]]
  ------------------
  640|      0|    case -1:
  ------------------
  |  Branch (640:5): [True: 0, False: 2.44k]
  ------------------
  641|      0|      out += 2;
  642|      0|      memcpy(out, &digits[0], 6);
  643|      0|      out += 6;
  644|      0|      while (out[-1] == '0') --out;
  ------------------
  |  Branch (644:14): [True: 0, False: 0]
  ------------------
  645|      0|      *out = 0;
  646|      0|      return static_cast<size_t>(out - buffer);
  647|  2.44k|  }
  648|  2.44k|  assert(exp < -4 || exp >= 6);
  649|  2.44k|  out[0] = digits[0];
  650|  2.44k|  assert(out[1] == '.');
  651|  2.44k|  out += 2;
  652|  2.44k|  memcpy(out, &digits[1], 5), out += 5;
  653|  3.63k|  while (out[-1] == '0') --out;
  ------------------
  |  Branch (653:10): [True: 1.19k, False: 2.44k]
  ------------------
  654|  2.44k|  if (out[-1] == '.') --out;
  ------------------
  |  Branch (654:7): [True: 171, False: 2.27k]
  ------------------
  655|  2.44k|  *out++ = 'e';
  656|  2.44k|  if (exp > 0) {
  ------------------
  |  Branch (656:7): [True: 2.44k, False: 0]
  ------------------
  657|  2.44k|    *out++ = '+';
  658|  2.44k|  } else {
  659|      0|    *out++ = '-';
  660|      0|    exp = -exp;
  661|      0|  }
  662|  2.44k|  if (exp > 99) {
  ------------------
  |  Branch (662:7): [True: 1.22k, False: 1.21k]
  ------------------
  663|  1.22k|    int dig1 = exp / 100;
  664|  1.22k|    exp -= dig1 * 100;
  665|  1.22k|    *out++ = '0' + static_cast<char>(dig1);
  666|  1.22k|  }
  667|  2.44k|  PutTwoDigits(static_cast<uint32_t>(exp), out);
  668|  2.44k|  out += 2;
  669|  2.44k|  *out = 0;
  670|  2.44k|  return static_cast<size_t>(out - buffer);
  671|  2.44k|}
_ZN4absl16numbers_internal17safe_strto32_baseENS_11string_viewEPii:
 1114|  1.24k|                       int base) {
 1115|  1.24k|  return safe_int_internal<int32_t>(text, value, base);
 1116|  1.24k|}
numbers.cc:_ZN4absl12_GLOBAL__N_113EncodeFullU32EjPc:
  237|  4.96k|    uint32_t n, absl::Nonnull<char*> out_str) {
  238|  4.96k|  if (n < 10) {
  ------------------
  |  Branch (238:7): [True: 2.49k, False: 2.46k]
  ------------------
  239|  2.49k|    *out_str = static_cast<char>('0' + n);
  240|  2.49k|    return out_str + 1;
  241|  2.49k|  }
  242|  2.46k|  if (n < 100'000'000) {
  ------------------
  |  Branch (242:7): [True: 156, False: 2.31k]
  ------------------
  243|    156|    uint64_t bottom = PrepareEightDigits(n);
  244|    156|    ABSL_ASSUME(bottom != 0);
  ------------------
  |  |  268|    156|#define ABSL_ASSUME(cond) assert(cond)
  ------------------
  245|       |    // 0 minus 8 to make MSVC happy.
  246|    156|    uint32_t zeroes =
  247|    156|        static_cast<uint32_t>(absl::countr_zero(bottom)) & (0 - 8u);
  248|    156|    little_endian::Store64(out_str, (bottom + kEightZeroBytes) >> zeroes);
  249|    156|    return out_str + sizeof(bottom) - zeroes / 8;
  250|    156|  }
  251|  2.31k|  uint32_t div08 = n / 100'000'000;
  252|  2.31k|  uint32_t mod08 = n % 100'000'000;
  253|  2.31k|  uint64_t bottom = PrepareEightDigits(mod08) + kEightZeroBytes;
  254|  2.31k|  out_str = EncodeHundred(div08, out_str);
  255|  2.31k|  little_endian::Store64(out_str, bottom);
  256|  2.31k|  return out_str + sizeof(bottom);
  257|  2.46k|}
numbers.cc:_ZN4absl12_GLOBAL__N_118PrepareEightDigitsEj:
  220|  2.46k|inline uint64_t PrepareEightDigits(uint32_t i) {
  221|  2.46k|  ABSL_ASSUME(i < 10000'0000);
  ------------------
  |  |  268|  2.46k|#define ABSL_ASSUME(cond) assert(cond)
  ------------------
  222|       |  // Prepare 2 blocks of 4 digits "in parallel".
  223|  2.46k|  uint32_t hi = i / 10000;
  224|  2.46k|  uint32_t lo = i % 10000;
  225|  2.46k|  uint64_t merged = hi | (uint64_t{lo} << 32);
  226|  2.46k|  uint64_t div100 = ((merged * kDivisionBy100Mul) / kDivisionBy100Div) &
  227|  2.46k|                    ((0x7Full << 32) | 0x7Full);
  228|  2.46k|  uint64_t mod100 = merged - 100ull * div100;
  229|  2.46k|  uint64_t hundreds = (mod100 << 16) + div100;
  230|  2.46k|  uint64_t tens = (hundreds * kDivisionBy10Mul) / kDivisionBy10Div;
  231|  2.46k|  tens &= (0xFull << 48) | (0xFull << 32) | (0xFull << 16) | 0xFull;
  232|  2.46k|  tens += (hundreds - 10ull * tens) << 8;
  233|  2.46k|  return tens;
  234|  2.46k|}
numbers.cc:_ZN4absl12_GLOBAL__N_113EncodeHundredEjPc:
  170|  2.31k|inline char* EncodeHundred(uint32_t n, absl::Nonnull<char*> out_str) {
  171|  2.31k|  int num_digits = static_cast<int>(n - 10) >> 8;
  172|  2.31k|  uint32_t div10 = (n * kDivisionBy10Mul) / kDivisionBy10Div;
  173|  2.31k|  uint32_t mod10 = n - 10u * div10;
  174|  2.31k|  uint32_t base = kTwoZeroBytes + div10 + (mod10 << 8);
  175|  2.31k|  base >>= num_digits & 8;
  176|  2.31k|  little_endian::Store16(out_str, static_cast<uint16_t>(base));
  177|  2.31k|  return out_str + 2 + num_digits;
  178|  2.31k|}
numbers.cc:_ZN4abslL10SplitToSixEd:
  426|  2.44k|static ExpDigits SplitToSix(const double value) {
  427|  2.44k|  ExpDigits exp_dig;
  428|  2.44k|  int exp = 5;
  429|  2.44k|  double d = value;
  430|       |  // First step: calculate a close approximation of the output, where the
  431|       |  // value d will be between 100,000 and 999,999, representing the digits
  432|       |  // in the output ASCII array, and exp is the base-10 exponent.  It would be
  433|       |  // faster to use a table here, and to look up the base-2 exponent of value,
  434|       |  // however value is an IEEE-754 64-bit number, so the table would have 2,000
  435|       |  // entries, which is not cache-friendly.
  436|  2.44k|  if (d >= 999999.5) {
  ------------------
  |  Branch (436:7): [True: 2.44k, False: 0]
  ------------------
  437|  2.44k|    if (d >= 1e+261) exp += 256, d *= 1e-256;
  ------------------
  |  Branch (437:9): [True: 1.22k, False: 1.21k]
  ------------------
  438|  2.44k|    if (d >= 1e+133) exp += 128, d *= 1e-128;
  ------------------
  |  Branch (438:9): [True: 0, False: 2.44k]
  ------------------
  439|  2.44k|    if (d >= 1e+69) exp += 64, d *= 1e-64;
  ------------------
  |  Branch (439:9): [True: 0, False: 2.44k]
  ------------------
  440|  2.44k|    if (d >= 1e+37) exp += 32, d *= 1e-32;
  ------------------
  |  Branch (440:9): [True: 2.12k, False: 320]
  ------------------
  441|  2.44k|    if (d >= 1e+21) exp += 16, d *= 1e-16;
  ------------------
  |  Branch (441:9): [True: 320, False: 2.12k]
  ------------------
  442|  2.44k|    if (d >= 1e+13) exp += 8, d *= 1e-8;
  ------------------
  |  Branch (442:9): [True: 1.36k, False: 1.08k]
  ------------------
  443|  2.44k|    if (d >= 1e+9) exp += 4, d *= 1e-4;
  ------------------
  |  Branch (443:9): [True: 1.26k, False: 1.18k]
  ------------------
  444|  2.44k|    if (d >= 1e+7) exp += 2, d *= 1e-2;
  ------------------
  |  Branch (444:9): [True: 1.24k, False: 1.19k]
  ------------------
  445|  2.44k|    if (d >= 1e+6) exp += 1, d *= 1e-1;
  ------------------
  |  Branch (445:9): [True: 1.62k, False: 818]
  ------------------
  446|  2.44k|  } else {
  447|      0|    if (d < 1e-250) exp -= 256, d *= 1e256;
  ------------------
  |  Branch (447:9): [True: 0, False: 0]
  ------------------
  448|      0|    if (d < 1e-122) exp -= 128, d *= 1e128;
  ------------------
  |  Branch (448:9): [True: 0, False: 0]
  ------------------
  449|      0|    if (d < 1e-58) exp -= 64, d *= 1e64;
  ------------------
  |  Branch (449:9): [True: 0, False: 0]
  ------------------
  450|      0|    if (d < 1e-26) exp -= 32, d *= 1e32;
  ------------------
  |  Branch (450:9): [True: 0, False: 0]
  ------------------
  451|      0|    if (d < 1e-10) exp -= 16, d *= 1e16;
  ------------------
  |  Branch (451:9): [True: 0, False: 0]
  ------------------
  452|      0|    if (d < 1e-2) exp -= 8, d *= 1e8;
  ------------------
  |  Branch (452:9): [True: 0, False: 0]
  ------------------
  453|      0|    if (d < 1e+2) exp -= 4, d *= 1e4;
  ------------------
  |  Branch (453:9): [True: 0, False: 0]
  ------------------
  454|      0|    if (d < 1e+4) exp -= 2, d *= 1e2;
  ------------------
  |  Branch (454:9): [True: 0, False: 0]
  ------------------
  455|      0|    if (d < 1e+5) exp -= 1, d *= 1e1;
  ------------------
  |  Branch (455:9): [True: 0, False: 0]
  ------------------
  456|      0|  }
  457|       |  // At this point, d is in the range [99999.5..999999.5) and exp is in the
  458|       |  // range [-324..308]. Since we need to round d up, we want to add a half
  459|       |  // and truncate.
  460|       |  // However, the technique above may have lost some precision, due to its
  461|       |  // repeated multiplication by constants that each may be off by half a bit
  462|       |  // of precision.  This only matters if we're close to the edge though.
  463|       |  // Since we'd like to know if the fractional part of d is close to a half,
  464|       |  // we multiply it by 65536 and see if the fractional part is close to 32768.
  465|       |  // (The number doesn't have to be a power of two,but powers of two are faster)
  466|  2.44k|  uint64_t d64k = d * 65536;
  467|  2.44k|  uint32_t dddddd;  // A 6-digit decimal integer.
  468|  2.44k|  if ((d64k % 65536) == 32767 || (d64k % 65536) == 32768) {
  ------------------
  |  Branch (468:7): [True: 0, False: 2.44k]
  |  Branch (468:34): [True: 0, False: 2.44k]
  ------------------
  469|       |    // OK, it's fairly likely that precision was lost above, which is
  470|       |    // not a surprise given only 52 mantissa bits are available.  Therefore
  471|       |    // redo the calculation using 128-bit numbers.  (64 bits are not enough).
  472|       |
  473|       |    // Start out with digits rounded down; maybe add one below.
  474|      0|    dddddd = static_cast<uint32_t>(d64k / 65536);
  475|       |
  476|       |    // mantissa is a 64-bit integer representing M.mmm... * 2^63.  The actual
  477|       |    // value we're representing, of course, is M.mmm... * 2^exp2.
  478|      0|    int exp2;
  479|      0|    double m = std::frexp(value, &exp2);
  480|      0|    uint64_t mantissa = m * (32768.0 * 65536.0 * 65536.0 * 65536.0);
  481|       |    // std::frexp returns an m value in the range [0.5, 1.0), however we
  482|       |    // can't multiply it by 2^64 and convert to an integer because some FPUs
  483|       |    // throw an exception when converting an number higher than 2^63 into an
  484|       |    // integer - even an unsigned 64-bit integer!  Fortunately it doesn't matter
  485|       |    // since m only has 52 significant bits anyway.
  486|      0|    mantissa <<= 1;
  487|      0|    exp2 -= 64;  // not needed, but nice for debugging
  488|       |
  489|       |    // OK, we are here to compare:
  490|       |    //     (dddddd + 0.5) * 10^(exp-5)  vs.  mantissa * 2^exp2
  491|       |    // so we can round up dddddd if appropriate.  Those values span the full
  492|       |    // range of 600 orders of magnitude of IEE 64-bit floating-point.
  493|       |    // Fortunately, we already know they are very close, so we don't need to
  494|       |    // track the base-2 exponent of both sides.  This greatly simplifies the
  495|       |    // the math since the 2^exp2 calculation is unnecessary and the power-of-10
  496|       |    // calculation can become a power-of-5 instead.
  497|       |
  498|      0|    std::pair<uint64_t, uint64_t> edge, val;
  499|      0|    if (exp >= 6) {
  ------------------
  |  Branch (499:9): [True: 0, False: 0]
  ------------------
  500|       |      // Compare (dddddd + 0.5) * 5 ^ (exp - 5) to mantissa
  501|       |      // Since we're tossing powers of two, 2 * dddddd + 1 is the
  502|       |      // same as dddddd + 0.5
  503|      0|      edge = PowFive(2 * dddddd + 1, exp - 5);
  504|       |
  505|      0|      val.first = mantissa;
  506|      0|      val.second = 0;
  507|      0|    } else {
  508|       |      // We can't compare (dddddd + 0.5) * 5 ^ (exp - 5) to mantissa as we did
  509|       |      // above because (exp - 5) is negative.  So we compare (dddddd + 0.5) to
  510|       |      // mantissa * 5 ^ (5 - exp)
  511|      0|      edge = PowFive(2 * dddddd + 1, 0);
  512|       |
  513|      0|      val = PowFive(mantissa, 5 - exp);
  514|      0|    }
  515|       |    // printf("exp=%d %016lx %016lx vs %016lx %016lx\n", exp, val.first,
  516|       |    //        val.second, edge.first, edge.second);
  517|      0|    if (val > edge) {
  ------------------
  |  Branch (517:9): [True: 0, False: 0]
  ------------------
  518|      0|      dddddd++;
  519|      0|    } else if (val == edge) {
  ------------------
  |  Branch (519:16): [True: 0, False: 0]
  ------------------
  520|      0|      dddddd += (dddddd & 1);
  521|      0|    }
  522|  2.44k|  } else {
  523|       |    // Here, we are not close to the edge.
  524|  2.44k|    dddddd = static_cast<uint32_t>((d64k + 32768) / 65536);
  525|  2.44k|  }
  526|  2.44k|  if (dddddd == 1000000) {
  ------------------
  |  Branch (526:7): [True: 77, False: 2.36k]
  ------------------
  527|     77|    dddddd = 100000;
  528|     77|    exp += 1;
  529|     77|  }
  530|  2.44k|  exp_dig.exponent = exp;
  531|       |
  532|  2.44k|  uint32_t two_digits = dddddd / 10000;
  533|  2.44k|  dddddd -= two_digits * 10000;
  534|  2.44k|  numbers_internal::PutTwoDigits(two_digits, &exp_dig.digits[0]);
  535|       |
  536|  2.44k|  two_digits = dddddd / 100;
  537|  2.44k|  dddddd -= two_digits * 100;
  538|  2.44k|  numbers_internal::PutTwoDigits(two_digits, &exp_dig.digits[2]);
  539|       |
  540|  2.44k|  numbers_internal::PutTwoDigits(dddddd, &exp_dig.digits[4]);
  541|  2.44k|  return exp_dig;
  542|  2.44k|}
numbers.cc:_ZN4absl12_GLOBAL__N_117safe_int_internalIiEEbNS_11string_viewEPT_i:
 1064|  1.24k|                              absl::Nonnull<IntType*> value_p, int base) {
 1065|  1.24k|  *value_p = 0;
 1066|  1.24k|  bool negative;
 1067|  1.24k|  if (!safe_parse_sign_and_base(&text, &base, &negative)) {
  ------------------
  |  Branch (1067:7): [True: 0, False: 1.24k]
  ------------------
 1068|      0|    return false;
 1069|      0|  }
 1070|  1.24k|  if (!negative) {
  ------------------
  |  Branch (1070:7): [True: 133, False: 1.10k]
  ------------------
 1071|    133|    return safe_parse_positive_int(text, base, value_p);
 1072|  1.10k|  } else {
 1073|  1.10k|    return safe_parse_negative_int(text, base, value_p);
 1074|  1.10k|  }
 1075|  1.24k|}
numbers.cc:_ZN4absl12_GLOBAL__N_124safe_parse_sign_and_baseEPNS_11string_viewEPiPb:
  697|  1.24k|    absl::Nonnull<bool*> negative_ptr /*output*/) {
  698|  1.24k|  if (text->data() == nullptr) {
  ------------------
  |  Branch (698:7): [True: 0, False: 1.24k]
  ------------------
  699|      0|    return false;
  700|      0|  }
  701|       |
  702|  1.24k|  const char* start = text->data();
  703|  1.24k|  const char* end = start + text->size();
  704|  1.24k|  int base = *base_ptr;
  705|       |
  706|       |  // Consume whitespace.
  707|  1.24k|  while (start < end &&
  ------------------
  |  Branch (707:10): [True: 1.24k, False: 0]
  ------------------
  708|  1.24k|         absl::ascii_isspace(static_cast<unsigned char>(start[0]))) {
  ------------------
  |  Branch (708:10): [True: 0, False: 1.24k]
  ------------------
  709|      0|    ++start;
  710|      0|  }
  711|  1.24k|  while (start < end &&
  ------------------
  |  Branch (711:10): [True: 1.24k, False: 0]
  ------------------
  712|  1.24k|         absl::ascii_isspace(static_cast<unsigned char>(end[-1]))) {
  ------------------
  |  Branch (712:10): [True: 0, False: 1.24k]
  ------------------
  713|      0|    --end;
  714|      0|  }
  715|  1.24k|  if (start >= end) {
  ------------------
  |  Branch (715:7): [True: 0, False: 1.24k]
  ------------------
  716|      0|    return false;
  717|      0|  }
  718|       |
  719|       |  // Consume sign.
  720|  1.24k|  *negative_ptr = (start[0] == '-');
  721|  1.24k|  if (*negative_ptr || start[0] == '+') {
  ------------------
  |  Branch (721:7): [True: 1.10k, False: 133]
  |  Branch (721:24): [True: 0, False: 133]
  ------------------
  722|  1.10k|    ++start;
  723|  1.10k|    if (start >= end) {
  ------------------
  |  Branch (723:9): [True: 0, False: 1.10k]
  ------------------
  724|      0|      return false;
  725|      0|    }
  726|  1.10k|  }
  727|       |
  728|       |  // Consume base-dependent prefix.
  729|       |  //  base 0: "0x" -> base 16, "0" -> base 8, default -> base 10
  730|       |  //  base 16: "0x" -> base 16
  731|       |  // Also validate the base.
  732|  1.24k|  if (base == 0) {
  ------------------
  |  Branch (732:7): [True: 0, False: 1.24k]
  ------------------
  733|      0|    if (end - start >= 2 && start[0] == '0' &&
  ------------------
  |  Branch (733:9): [True: 0, False: 0]
  |  Branch (733:29): [True: 0, False: 0]
  ------------------
  734|      0|        (start[1] == 'x' || start[1] == 'X')) {
  ------------------
  |  Branch (734:10): [True: 0, False: 0]
  |  Branch (734:29): [True: 0, False: 0]
  ------------------
  735|      0|      base = 16;
  736|      0|      start += 2;
  737|      0|      if (start >= end) {
  ------------------
  |  Branch (737:11): [True: 0, False: 0]
  ------------------
  738|       |        // "0x" with no digits after is invalid.
  739|      0|        return false;
  740|      0|      }
  741|      0|    } else if (end - start >= 1 && start[0] == '0') {
  ------------------
  |  Branch (741:16): [True: 0, False: 0]
  |  Branch (741:36): [True: 0, False: 0]
  ------------------
  742|      0|      base = 8;
  743|      0|      start += 1;
  744|      0|    } else {
  745|      0|      base = 10;
  746|      0|    }
  747|  1.24k|  } else if (base == 16) {
  ------------------
  |  Branch (747:14): [True: 0, False: 1.24k]
  ------------------
  748|      0|    if (end - start >= 2 && start[0] == '0' &&
  ------------------
  |  Branch (748:9): [True: 0, False: 0]
  |  Branch (748:29): [True: 0, False: 0]
  ------------------
  749|      0|        (start[1] == 'x' || start[1] == 'X')) {
  ------------------
  |  Branch (749:10): [True: 0, False: 0]
  |  Branch (749:29): [True: 0, False: 0]
  ------------------
  750|      0|      start += 2;
  751|      0|      if (start >= end) {
  ------------------
  |  Branch (751:11): [True: 0, False: 0]
  ------------------
  752|       |        // "0x" with no digits after is invalid.
  753|      0|        return false;
  754|      0|      }
  755|      0|    }
  756|  1.24k|  } else if (base >= 2 && base <= 36) {
  ------------------
  |  Branch (756:14): [True: 1.24k, False: 0]
  |  Branch (756:27): [True: 1.24k, False: 0]
  ------------------
  757|       |    // okay
  758|  1.24k|  } else {
  759|      0|    return false;
  760|      0|  }
  761|  1.24k|  *text = absl::string_view(start, static_cast<size_t>(end - start));
  762|  1.24k|  *base_ptr = base;
  763|  1.24k|  return true;
  764|  1.24k|}
numbers.cc:_ZN4absl12_GLOBAL__N_123safe_parse_positive_intIiEEbNS_11string_viewEiPT_:
  982|    133|                                    absl::Nonnull<IntType*> value_p) {
  983|    133|  IntType value = 0;
  984|    133|  const IntType vmax = std::numeric_limits<IntType>::max();
  985|    133|  assert(vmax > 0);
  986|    133|  assert(base >= 0);
  987|    133|  const IntType base_inttype = static_cast<IntType>(base);
  988|    133|  assert(vmax >= base_inttype);
  989|    133|  const IntType vmax_over_base = LookupTables<IntType>::kVmaxOverBase[base];
  990|    133|  assert(base < 2 ||
  991|    133|         std::numeric_limits<IntType>::max() / base_inttype == vmax_over_base);
  992|    133|  const char* start = text.data();
  993|    133|  const char* end = start + text.size();
  994|       |  // loop over digits
  995|  1.33k|  for (; start < end; ++start) {
  ------------------
  |  Branch (995:10): [True: 1.20k, False: 133]
  ------------------
  996|  1.20k|    unsigned char c = static_cast<unsigned char>(start[0]);
  997|  1.20k|    IntType digit = static_cast<IntType>(kAsciiToInt[c]);
  998|  1.20k|    if (digit >= base_inttype) {
  ------------------
  |  Branch (998:9): [True: 0, False: 1.20k]
  ------------------
  999|      0|      *value_p = value;
 1000|      0|      return false;
 1001|      0|    }
 1002|  1.20k|    if (value > vmax_over_base) {
  ------------------
  |  Branch (1002:9): [True: 0, False: 1.20k]
  ------------------
 1003|      0|      *value_p = vmax;
 1004|      0|      return false;
 1005|      0|    }
 1006|  1.20k|    value *= base_inttype;
 1007|  1.20k|    if (value > vmax - digit) {
  ------------------
  |  Branch (1007:9): [True: 0, False: 1.20k]
  ------------------
 1008|      0|      *value_p = vmax;
 1009|      0|      return false;
 1010|      0|    }
 1011|  1.20k|    value += digit;
 1012|  1.20k|  }
 1013|    133|  *value_p = value;
 1014|    133|  return true;
 1015|    133|}
numbers.cc:_ZN4absl12_GLOBAL__N_123safe_parse_negative_intIiEEbNS_11string_viewEiPT_:
 1019|  1.10k|                                    absl::Nonnull<IntType*> value_p) {
 1020|  1.10k|  IntType value = 0;
 1021|  1.10k|  const IntType vmin = std::numeric_limits<IntType>::min();
 1022|  1.10k|  assert(vmin < 0);
 1023|  1.10k|  assert(vmin <= 0 - base);
 1024|  1.10k|  IntType vmin_over_base = LookupTables<IntType>::kVminOverBase[base];
 1025|  1.10k|  assert(base < 2 ||
 1026|  1.10k|         std::numeric_limits<IntType>::min() / base == vmin_over_base);
 1027|       |  // 2003 c++ standard [expr.mul]
 1028|       |  // "... the sign of the remainder is implementation-defined."
 1029|       |  // Although (vmin/base)*base + vmin%base is always vmin.
 1030|       |  // 2011 c++ standard tightens the spec but we cannot rely on it.
 1031|       |  // TODO(junyer): Handle this in the lookup table generation.
 1032|  1.10k|  if (vmin % base > 0) {
  ------------------
  |  Branch (1032:7): [True: 0, False: 1.10k]
  ------------------
 1033|      0|    vmin_over_base += 1;
 1034|      0|  }
 1035|  1.10k|  const char* start = text.data();
 1036|  1.10k|  const char* end = start + text.size();
 1037|       |  // loop over digits
 1038|  11.8k|  for (; start < end; ++start) {
  ------------------
  |  Branch (1038:10): [True: 10.7k, False: 1.10k]
  ------------------
 1039|  10.7k|    unsigned char c = static_cast<unsigned char>(start[0]);
 1040|  10.7k|    int digit = kAsciiToInt[c];
 1041|  10.7k|    if (digit >= base) {
  ------------------
  |  Branch (1041:9): [True: 0, False: 10.7k]
  ------------------
 1042|      0|      *value_p = value;
 1043|      0|      return false;
 1044|      0|    }
 1045|  10.7k|    if (value < vmin_over_base) {
  ------------------
  |  Branch (1045:9): [True: 0, False: 10.7k]
  ------------------
 1046|      0|      *value_p = vmin;
 1047|      0|      return false;
 1048|      0|    }
 1049|  10.7k|    value *= base;
 1050|  10.7k|    if (value < vmin + digit) {
  ------------------
  |  Branch (1050:9): [True: 0, False: 10.7k]
  ------------------
 1051|      0|      *value_p = vmin;
 1052|      0|      return false;
 1053|      0|    }
 1054|  10.7k|    value -= digit;
 1055|  10.7k|  }
 1056|  1.10k|  *value_p = value;
 1057|  1.10k|  return true;
 1058|  1.10k|}

_ZN4absl10SimpleAtoiIiEEbNS_11string_viewEPT_:
  284|  1.24k|                                     absl::Nonnull<int_type*> out) {
  285|  1.24k|  return numbers_internal::safe_strtoi_base(str, out, 10);
  286|  1.24k|}
_ZN4absl16numbers_internal16safe_strtoi_baseIiEEbNS_11string_viewEPT_i:
  215|  1.24k|                                           int base) {
  216|  1.24k|  static_assert(sizeof(*out) == 4 || sizeof(*out) == 8,
  217|  1.24k|                "SimpleAtoi works only with 32-bit or 64-bit integers.");
  218|  1.24k|  static_assert(!std::is_floating_point<int_type>::value,
  219|  1.24k|                "Use SimpleAtof or SimpleAtod instead.");
  220|  1.24k|  bool parsed;
  221|       |  // TODO(jorg): This signed-ness check is used because it works correctly
  222|       |  // with enums, and it also serves to check that int_type is not a pointer.
  223|       |  // If one day something like std::is_signed<enum E> works, switch to it.
  224|       |  // These conditions are constexpr bools to suppress MSVC warning C4127.
  225|  1.24k|  constexpr bool kIsSigned = static_cast<int_type>(1) - 2 < 0;
  226|  1.24k|  constexpr bool kUse64Bit = sizeof(*out) == 64 / 8;
  227|  1.24k|  if (kIsSigned) {
  ------------------
  |  Branch (227:7): [Folded - Ignored]
  ------------------
  228|  1.24k|    if (kUse64Bit) {
  ------------------
  |  Branch (228:9): [Folded - Ignored]
  ------------------
  229|      0|      int64_t val;
  230|      0|      parsed = numbers_internal::safe_strto64_base(s, &val, base);
  231|      0|      *out = static_cast<int_type>(val);
  232|  1.24k|    } else {
  233|  1.24k|      int32_t val;
  234|  1.24k|      parsed = numbers_internal::safe_strto32_base(s, &val, base);
  235|  1.24k|      *out = static_cast<int_type>(val);
  236|  1.24k|    }
  237|  1.24k|  } else {
  238|      0|    if (kUse64Bit) {
  ------------------
  |  Branch (238:9): [Folded - Ignored]
  ------------------
  239|      0|      uint64_t val;
  240|      0|      parsed = numbers_internal::safe_strtou64_base(s, &val, base);
  241|      0|      *out = static_cast<int_type>(val);
  242|      0|    } else {
  243|      0|      uint32_t val;
  244|      0|      parsed = numbers_internal::safe_strtou32_base(s, &val, base);
  245|      0|      *out = static_cast<int_type>(val);
  246|      0|    }
  247|      0|  }
  248|  1.24k|  return parsed;
  249|  1.24k|}

_ZN4absl16strings_internal9CatPiecesESt16initializer_listINS_11string_viewEE:
  127|  1.24k|std::string CatPieces(std::initializer_list<absl::string_view> pieces) {
  128|  1.24k|  std::string result;
  129|       |  // Use uint64_t to prevent size_t overflow. We assume it is not possible for
  130|       |  // in memory strings to overflow a uint64_t.
  131|  1.24k|  constexpr uint64_t kMaxSize = uint64_t{std::numeric_limits<size_t>::max()};
  132|  1.24k|  uint64_t total_size = 0;
  133|  6.20k|  for (absl::string_view piece : pieces) {
  ------------------
  |  Branch (133:32): [True: 6.20k, False: 1.24k]
  ------------------
  134|  6.20k|    total_size += piece.size();
  135|  6.20k|  }
  136|  1.24k|  ABSL_INTERNAL_CHECK(total_size <= kMaxSize, "size_t overflow");
  ------------------
  |  |   85|  1.24k|  do {                                                             \
  |  |   86|  1.24k|    if (ABSL_PREDICT_FALSE(!(condition))) {                        \
  |  |  ------------------
  |  |  |  |  189|  1.24k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 1.24k]
  |  |  |  |  |  Branch (189:49): [Folded - Ignored]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 1.24k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   87|      0|      std::string death_message = "Check " #condition " failed: "; \
  |  |   88|      0|      death_message += std::string(message);                       \
  |  |   89|      0|      ABSL_INTERNAL_LOG(FATAL, death_message);                     \
  |  |  ------------------
  |  |  |  |   76|      0|  do {                                                                    \
  |  |  |  |   77|      0|    constexpr const char* absl_raw_log_internal_filename = __FILE__;      \
  |  |  |  |   78|      0|    ::absl::raw_log_internal::internal_log_function(                      \
  |  |  |  |   79|      0|        ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \
  |  |  |  |   80|      0|        __LINE__, message);                                               \
  |  |  |  |   81|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                   \
  |  |  |  |   82|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (82:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|    }                                                              \
  |  |   91|  1.24k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (91:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  137|  1.24k|  strings_internal::STLStringResizeUninitialized(
  138|  1.24k|      &result, static_cast<size_t>(total_size));
  139|       |
  140|  1.24k|  char* const begin = &result[0];
  141|  1.24k|  char* out = begin;
  142|  6.20k|  for (absl::string_view piece : pieces) {
  ------------------
  |  Branch (142:32): [True: 6.20k, False: 1.24k]
  ------------------
  143|  6.20k|    const size_t this_size = piece.size();
  144|  6.20k|    if (this_size != 0) {
  ------------------
  |  Branch (144:9): [True: 5.64k, False: 557]
  ------------------
  145|  5.64k|      memcpy(out, piece.data(), this_size);
  146|  5.64k|      out += this_size;
  147|  5.64k|    }
  148|  6.20k|  }
  149|  1.24k|  assert(out == begin + result.size());
  150|  1.24k|  return result;
  151|  1.24k|}
_ZN4absl9StrAppendEPNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEERKNS_8AlphaNumE:
  186|  1.24k|void StrAppend(absl::Nonnull<std::string*> dest, const AlphaNum& a) {
  187|  1.24k|  ASSERT_NO_OVERLAP(*dest, a);
  ------------------
  |  |  159|  1.24k|  assert(((src).size() == 0) ||      \
  |  |  160|  1.24k|         (uintptr_t((src).data() - (dest).data()) > uintptr_t((dest).size())))
  ------------------
  188|  1.24k|  std::string::size_type old_size = dest->size();
  189|  1.24k|  STLStringAppendUninitializedAmortized(dest, a.size());
  190|  1.24k|  char* const begin = &(*dest)[0];
  191|  1.24k|  char* out = begin + old_size;
  192|  1.24k|  out = Append(out, a);
  193|  1.24k|  assert(out == begin + dest->size());
  194|  1.24k|}
str_cat.cc:_ZN4absl12_GLOBAL__N_16AppendEPcRKNS_8AlphaNumE:
   46|  1.24k|                                   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.24k|  char* after = out + x.size();
   50|  1.24k|  if (x.size() != 0) {
  ------------------
  |  Branch (50:7): [True: 252, False: 989]
  ------------------
   51|    252|    memcpy(out, x.data(), x.size());
   52|    252|  }
   53|  1.24k|  return after;
   54|  1.24k|}
str_cat.cc:_ZN4absl12_GLOBAL__N_137STLStringAppendUninitializedAmortizedEPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEm:
   57|  1.24k|                                                  size_t to_append) {
   58|  1.24k|  strings_internal::AppendUninitializedTraits<std::string>::Append(dest,
   59|  1.24k|                                                                   to_append);
   60|  1.24k|}

_ZN4absl8AlphaNumC2Ef:
  347|  1.24k|      : piece_(digits_, numbers_internal::SixDigitsToBuffer(f, digits_)) {}
_ZN4absl8AlphaNumC2Ed:
  349|  1.24k|      : piece_(digits_, numbers_internal::SixDigitsToBuffer(f, digits_)) {}
_ZN4absl8AlphaNumC2Ei:
  324|  2.48k|                            &digits_[0])) {}
_ZN4absl8AlphaNumC2INSt3__19allocatorIcEEEERKNS2_12basic_stringIcNS2_11char_traitsIcEET_EE:
  375|  2.48k|      : piece_(str) {}
_ZN4absl6StrCatIJEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_8AlphaNumESA_SA_SA_SA_DpRKT_:
  551|  1.24k|    const AlphaNum& e, const AV&... args) {
  552|  1.24k|  return strings_internal::CatPieces(
  553|  1.24k|      {a.Piece(), b.Piece(), c.Piece(), d.Piece(), e.Piece(),
  554|  1.24k|       static_cast<const AlphaNum&>(args).Piece()...});
  555|  1.24k|}
_ZNK4absl8AlphaNum5PieceEv:
  385|  6.20k|  absl::string_view Piece() const { return piece_; }
_ZNK4absl8AlphaNum4sizeEv:
  383|  5.21k|  absl::string_view::size_type size() const { return piece_.size(); }
_ZNK4absl8AlphaNum4dataEv:
  384|    504|  absl::Nullable<const char*> data() const { return piece_.data(); }

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

_ZN4absl7StrJoinINSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEEEES8_RKT_NS_11string_viewE:
  276|  1.24k|std::string StrJoin(const Range& range, absl::string_view separator) {
  277|  1.24k|  return strings_internal::JoinRange(range, separator);
  278|  1.24k|}

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

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

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

_ZN4absl11string_viewC2EPKcm:
  205|  40.8M|      : ptr_(data), length_(CheckLengthInternal(len)) {}
_ZN4absl11string_view19CheckLengthInternalEm:
  669|  40.8M|  static constexpr size_type CheckLengthInternal(size_type len) {
  670|  40.8M|    return ABSL_HARDENING_ASSERT(len <= kMaxSize), len;
  ------------------
  |  |  129|  40.8M|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |   99|  40.8M|  (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  190|  40.8M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (190:30): [True: 40.8M, False: 0]
  |  |  |  |  |  |  |  Branch (190:48): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (190:57): [True: 40.8M, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  100|  40.8M|                             : [] { assert(false && #expr); }())  // NOLINT
  |  |  ------------------
  ------------------
  671|  40.8M|  }
_ZN4absl11string_viewC2EPKc:
  201|  20.1k|      : ptr_(str), length_(str ? StrlenInternal(str) : 0) {}
_ZN4absl11string_view14StrlenInternalEPKc:
  673|  20.1k|  static constexpr size_type StrlenInternal(absl::Nonnull<const char*> str) {
  674|       |#if defined(_MSC_VER) && !defined(__clang__)
  675|       |    // MSVC 2017+ can evaluate this at compile-time.
  676|       |    const char* begin = str;
  677|       |    while (*str != '\0') ++str;
  678|       |    return str - begin;
  679|       |#elif ABSL_HAVE_BUILTIN(__builtin_strlen) || \
  680|       |    (defined(__GNUC__) && !defined(__clang__))
  681|       |    // GCC has __builtin_strlen according to
  682|       |    // https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html, but
  683|       |    // ABSL_HAVE_BUILTIN doesn't detect that, so we use the extra checks above.
  684|       |    // __builtin_strlen is constexpr.
  685|  20.1k|    return __builtin_strlen(str);
  686|       |#else
  687|       |    return str ? strlen(str) : 0;
  688|       |#endif
  689|  20.1k|  }
_ZN4absl11string_viewC2INSt3__19allocatorIcEEEERKNS2_12basic_stringIcNS2_11char_traitsIcEET_EE:
  193|  9.91k|      : string_view(str.data(), str.size(), SkipCheckLengthTag{}) {}
_ZN4absl11string_viewC2EPKcmNS0_18SkipCheckLengthTagE:
  664|  9.91k|      : ptr_(data), length_(len) {}
_ZNK4absl11string_view4dataEv:
  333|   108M|  constexpr const_pointer data() const noexcept { return ptr_; }
_ZNK4absl11string_view4sizeEv:
  274|   108M|  constexpr size_type size() const noexcept { return length_; }
_ZN4absl11string_viewC2Ev:
  181|  2.46k|  constexpr string_view() noexcept : ptr_(nullptr), length_(0) {}
_ZNK4absl11string_view6substrEmm:
  396|  27.2M|  constexpr string_view substr(size_type pos = 0, size_type n = npos) const {
  397|  27.2M|    return ABSL_PREDICT_FALSE(pos > length_)
  ------------------
  |  |  189|  27.2M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 27.2M]
  |  |  |  Branch (189:49): [Folded - Ignored]
  |  |  |  Branch (189:58): [True: 0, False: 27.2M]
  |  |  ------------------
  ------------------
  398|  27.2M|               ? (base_internal::ThrowStdOutOfRange(
  399|      0|                      "absl::string_view::substr"),
  400|      0|                  string_view())
  401|  27.2M|               : string_view(ptr_ + pos, Min(n, length_ - pos));
  402|  27.2M|  }
_ZN4absl11string_view3MinEmm:
  691|  27.2M|  static constexpr size_t Min(size_type length_a, size_type length_b) {
  692|  27.2M|    return length_a < length_b ? length_a : length_b;
  ------------------
  |  Branch (692:12): [True: 27.2M, False: 6.20k]
  ------------------
  693|  27.2M|  }
_ZNK4absl11string_viewcvNSt3__112basic_stringIcNS1_11char_traitsIcEET_EEINS1_9allocatorIcEEEEv:
  369|  13.6M|  explicit operator std::basic_string<char, traits_type, A>() const {
  370|  13.6M|    if (!data()) return {};
  ------------------
  |  Branch (370:9): [True: 0, False: 13.6M]
  ------------------
  371|  13.6M|    return std::basic_string<char, traits_type, A>(data(), size());
  372|  13.6M|  }
_ZNK4absl11string_view5beginEv:
  217|  9.92k|  constexpr const_iterator begin() const noexcept { return ptr_; }
_ZNK4absl11string_view3endEv:
  224|  4.96k|  constexpr const_iterator end() const noexcept { return ptr_ + length_; }
_ZNK4absl11string_view6rbeginEv:
  243|  2.48k|  const_reverse_iterator rbegin() const noexcept {
  244|  2.48k|    return const_reverse_iterator(end());
  245|  2.48k|  }
_ZNK4absl11string_view4rendEv:
  252|  4.96k|  const_reverse_iterator rend() const noexcept {
  253|  4.96k|    return const_reverse_iterator(begin());
  254|  4.96k|  }
_ZNK4absl11string_view5emptyEv:
  289|  13.6M|  constexpr bool empty() const noexcept { return length_ == 0; }
_ZNK4absl11string_viewixEm:
  295|  2.48k|  constexpr const_reference operator[](size_type i) const {
  296|  2.48k|    return ABSL_HARDENING_ASSERT(i < size()), ptr_[i];
  ------------------
  |  |  129|  2.48k|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |   99|  2.48k|  (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  190|  2.48k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (190:30): [True: 2.48k, False: 0]
  |  |  |  |  |  |  |  Branch (190:48): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (190:57): [True: 2.48k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  100|  2.48k|                             : [] { assert(false && #expr); }())  // NOLINT
  |  |  ------------------
  ------------------
  297|  2.48k|  }

_ZN4absl4SpanIKNS_19str_format_internal13FormatArgImplEEC2IS3_S3_EESt16initializer_listIS2_E:
  274|  4.96k|      : Span(v.begin(), v.size()) {}
_ZN4absl4SpanIKNS_19str_format_internal13FormatArgImplEEC2EPS3_m:
  194|  4.96k|      : ptr_(array), len_(length) {}
_ZNK4absl4SpanIKNS_19str_format_internal13FormatArgImplEE4sizeEv:
  287|  9.92k|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl4SpanIKNS_19str_format_internal13FormatArgImplEEixEm:
  302|  4.96k|  constexpr reference operator[](size_type i) const noexcept {
  303|  4.96k|    return ABSL_HARDENING_ASSERT(i < size()), ptr_[i];
  ------------------
  |  |  129|  4.96k|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |   99|  4.96k|  (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  190|  4.96k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (190:30): [True: 4.96k, False: 0]
  |  |  |  |  |  |  |  Branch (190:48): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (190:57): [True: 4.96k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  100|  4.96k|                             : [] { assert(false && #expr); }())  // NOLINT
  |  |  ------------------
  ------------------
  304|  4.96k|  }

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