_ZN4absl8bit_castIdmTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3stdE23is_trivially_copyable_vIS4_Esr3stdE23is_trivially_copyable_vIS3_EEiE4typeELi0EEES3_RKS4_:
  189|  1.57k|inline constexpr Dest bit_cast(const Source& source) {
  190|  1.57k|  return __builtin_bit_cast(Dest, source);
  191|  1.57k|}
_ZN4absl8bit_castIfjTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3stdE23is_trivially_copyable_vIS4_Esr3stdE23is_trivially_copyable_vIS3_EEiE4typeELi0EEES3_RKS4_:
  189|  1.56k|inline constexpr Dest bit_cast(const Source& source) {
  190|  1.56k|  return __builtin_bit_cast(Dest, source);
  191|  1.56k|}

_ZN4absl13little_endian10FromHost16Et:
  103|  15.5k|inline uint16_t FromHost16(uint16_t x) { return x; }
_ZN4absl13little_endian10FromHost64Em:
  109|  13.9k|inline uint64_t FromHost64(uint64_t x) { return x; }
_ZN4absl13little_endian7Store16EPvt:
  164|  15.5k|inline void Store16(void* absl_nonnull p, uint16_t v) {
  165|  15.5k|  ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
  ------------------
  |  |   81|  15.5k|  (absl::base_internal::UnalignedStore16(_p, _val))
  ------------------
  166|  15.5k|}
_ZN4absl13little_endian7Store64EPvm:
  180|  13.9k|inline void Store64(void* absl_nonnull p, uint64_t v) {
  181|  13.9k|  ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
  ------------------
  |  |   85|  13.9k|  (absl::base_internal::UnalignedStore64(_p, _val))
  ------------------
  182|  13.9k|}

_ZN4absl13base_internal17HardeningAssertLTImmEEvT_T0_:
   92|  3.83M|constexpr void HardeningAssertLT(T1 val1, T2 val2) {
   93|  3.83M|  ABSL_ASSERT(val1 < val2);
  ------------------
  |  |  131|  3.83M|  (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
  |  |  ------------------
  |  |  |  |  191|  3.83M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (191:30): [True: 3.83M, False: 0]
  |  |  |  |  |  Branch (191:48): [Folded, False: 3.83M]
  |  |  |  |  |  Branch (191:57): [True: 3.83M, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  132|  3.83M|                             : assert(false && #expr))  // NOLINT
  ------------------
  |  Branch (93:3): [Folded, False: 0]
  |  Branch (93:3): [True: 0, Folded]
  |  Branch (93:3): [Folded, False: 0]
  ------------------
   94|       |#if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)
   95|       |  if (!ABSL_PREDICT_TRUE(val1 < val2)) {
   96|       |    ABSL_INTERNAL_HARDENING_ABORT();
   97|       |  }
   98|       |#endif
   99|  3.83M|}
_ZN4absl13base_internal17HardeningAssertGEImmEEvT_T0_:
   82|  1.59k|constexpr void HardeningAssertGE(T1 val1, T2 val2) {
   83|  1.59k|  ABSL_ASSERT(val1 >= val2);
  ------------------
  |  |  131|  1.59k|  (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
  |  |  ------------------
  |  |  |  |  191|  1.59k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (191:30): [True: 1.59k, False: 0]
  |  |  |  |  |  Branch (191:48): [Folded, False: 1.59k]
  |  |  |  |  |  Branch (191:57): [True: 1.59k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  132|  1.59k|                             : assert(false && #expr))  // NOLINT
  ------------------
  |  Branch (83:3): [Folded, False: 0]
  |  Branch (83:3): [True: 0, Folded]
  |  Branch (83:3): [Folded, False: 0]
  ------------------
   84|       |#if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)
   85|       |  if (!ABSL_PREDICT_TRUE(val1 >= val2)) {
   86|       |    ABSL_INTERNAL_HARDENING_ABORT();
   87|       |  }
   88|       |#endif
   89|  1.59k|}
_ZN4absl13base_internal17HardeningAssertLEImmEEvT_T0_:
  102|  1.59k|constexpr void HardeningAssertLE(T1 val1, T2 val2) {
  103|  1.59k|  ABSL_ASSERT(val1 <= val2);
  ------------------
  |  |  131|  1.59k|  (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
  |  |  ------------------
  |  |  |  |  191|  1.59k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (191:30): [True: 1.59k, False: 0]
  |  |  |  |  |  Branch (191:48): [Folded, False: 1.59k]
  |  |  |  |  |  Branch (191:57): [True: 1.59k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  132|  1.59k|                             : assert(false && #expr))  // NOLINT
  ------------------
  |  Branch (103:3): [Folded, False: 0]
  |  Branch (103:3): [True: 0, Folded]
  |  Branch (103:3): [Folded, False: 0]
  ------------------
  104|       |#if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)
  105|       |  if (!ABSL_PREDICT_TRUE(val1 <= val2)) {
  106|       |    ABSL_INTERNAL_HARDENING_ABORT();
  107|       |  }
  108|       |#endif
  109|  1.59k|}

_ZN4absl13base_internal16UnalignedStore16EPvt:
   57|  15.5k|inline void UnalignedStore16(void* absl_nonnull p, uint16_t v) {
   58|  15.5k|  memcpy(p, &v, sizeof v);
   59|  15.5k|}
_ZN4absl13base_internal16UnalignedStore64EPvm:
   65|  13.9k|inline void UnalignedStore64(void* absl_nonnull p, uint64_t v) {
   66|  13.9k|  memcpy(p, &v, sizeof v);
   67|  13.9k|}

_ZNK4absl11FunctionRefIFvNS_4SpanIjEEEEclES2_:
  164|  3.14k|  R operator()(Args... args) const {
  165|  3.14k|    return invoker_(ptr_, std::forward<Args>(args)...);
  166|  3.14k|  }
float_conversion.cc:_ZN4absl11FunctionRefIFvNS_4SpanIjEEEEC2IZNS_19str_format_internal12_GLOBAL__N_115BinaryToDecimal13RunConversionENS_7uint128EiNS0_IFvS8_EEEEUlS2_E_vEEOT_:
  112|  3.14k|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
float_conversion.cc:_ZN4absl11FunctionRefIFvNS_4SpanIjEEEEC2IZNS_19str_format_internal12_GLOBAL__N_115BinaryToDecimal13RunConversionENS_7uint128EiNS0_IFvS8_EEEEUlS2_E_EENSt3__110in_place_tEOT_:
  100|  3.14k|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|  3.14k|    absl::functional_internal::AssertNonNull(f);
  102|  3.14k|    ptr_.obj = &f;
  103|  3.14k|  }
float_conversion.cc:_ZNK4absl11FunctionRefIFvNS_19str_format_internal12_GLOBAL__N_115BinaryToDecimalEEEclES3_:
  164|  3.14k|  R operator()(Args... args) const {
  165|  3.14k|    return invoker_(ptr_, std::forward<Args>(args)...);
  166|  3.14k|  }
float_conversion.cc:_ZN4absl11FunctionRefIFvNS_19str_format_internal12_GLOBAL__N_115BinaryToDecimalEEEC2IZNS2_22FormatEPositiveExpSlowENS_7uint128EibRKNS2_11FormatStateEmE3$_0vEEOT_:
  112|  1.57k|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
float_conversion.cc:_ZN4absl11FunctionRefIFvNS_19str_format_internal12_GLOBAL__N_115BinaryToDecimalEEEC2IZNS2_22FormatEPositiveExpSlowENS_7uint128EibRKNS2_11FormatStateEmE3$_0EENSt3__110in_place_tEOT_:
  100|  1.57k|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|  1.57k|    absl::functional_internal::AssertNonNull(f);
  102|  1.57k|    ptr_.obj = &f;
  103|  1.57k|  }
float_conversion.cc:_ZN4absl11FunctionRefIFvNS_19str_format_internal12_GLOBAL__N_115BinaryToDecimalEEEC2IZNS2_22FormatGPositiveExpSlowImEEvT_ibRKNS2_11FormatStateEEUlS3_E_vEEOS8_:
  112|  1.57k|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
float_conversion.cc:_ZN4absl11FunctionRefIFvNS_19str_format_internal12_GLOBAL__N_115BinaryToDecimalEEEC2IZNS2_22FormatGPositiveExpSlowImEEvT_ibRKNS2_11FormatStateEEUlS3_E_EENSt3__110in_place_tEOS8_:
  100|  1.57k|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|  1.57k|    absl::functional_internal::AssertNonNull(f);
  102|  1.57k|    ptr_.obj = &f;
  103|  1.57k|  }

float_conversion.cc:_ZN4absl19functional_internal12InvokeObjectIRZNS_19str_format_internal12_GLOBAL__N_115BinaryToDecimal13RunConversionENS_7uint128EiNS_11FunctionRefIFvS4_EEEEUlNS_4SpanIjEEE_vJSA_EEET0_NS0_7VoidPtrEDpNS0_8ForwardTIT1_E4typeE:
   72|  3.14k|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   73|  3.14k|  using T = std::remove_reference_t<Obj>;
   74|  3.14k|  return static_cast<R>(std::invoke(
   75|  3.14k|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   76|  3.14k|      std::forward<typename ForwardT<Args>::type>(args)...));
   77|  3.14k|}
float_conversion.cc:_ZN4absl19functional_internal13AssertNonNullIZNS_19str_format_internal12_GLOBAL__N_115BinaryToDecimal13RunConversionENS_7uint128EiNS_11FunctionRefIFvS4_EEEEUlNS_4SpanIjEEE_EEvRKT_:
  134|  3.14k|void AssertNonNull(const F&) {}
float_conversion.cc:_ZN4absl19functional_internal12InvokeObjectIRZNS_19str_format_internal12_GLOBAL__N_122FormatEPositiveExpSlowENS_7uint128EibRKNS3_11FormatStateEmE3$_0vJNS3_15BinaryToDecimalEEEET0_NS0_7VoidPtrEDpNS0_8ForwardTIT1_E4typeE:
   72|  1.57k|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   73|  1.57k|  using T = std::remove_reference_t<Obj>;
   74|  1.57k|  return static_cast<R>(std::invoke(
   75|  1.57k|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   76|  1.57k|      std::forward<typename ForwardT<Args>::type>(args)...));
   77|  1.57k|}
float_conversion.cc:_ZN4absl19functional_internal13AssertNonNullIZNS_19str_format_internal12_GLOBAL__N_122FormatEPositiveExpSlowENS_7uint128EibRKNS3_11FormatStateEmE3$_0EEvRKT_:
  134|  1.57k|void AssertNonNull(const F&) {}
float_conversion.cc:_ZN4absl19functional_internal12InvokeObjectIRZNS_19str_format_internal12_GLOBAL__N_122FormatGPositiveExpSlowImEEvT_ibRKNS3_11FormatStateEEUlNS3_15BinaryToDecimalEE_vJS9_EEET0_NS0_7VoidPtrEDpNS0_8ForwardTIT1_E4typeE:
   72|  1.57k|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   73|  1.57k|  using T = std::remove_reference_t<Obj>;
   74|  1.57k|  return static_cast<R>(std::invoke(
   75|  1.57k|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   76|  1.57k|      std::forward<typename ForwardT<Args>::type>(args)...));
   77|  1.57k|}
float_conversion.cc:_ZN4absl19functional_internal13AssertNonNullIZNS_19str_format_internal12_GLOBAL__N_122FormatGPositiveExpSlowImEEvT_ibRKNS3_11FormatStateEEUlNS3_15BinaryToDecimalEE_EEvRKS5_:
  134|  1.57k|void AssertNonNull(const F&) {}

_ZN4absl11countl_zeroImEENSt3__19enable_ifIXsr3stdE13is_unsigned_vIT_EEiE4typeES3_:
  105|  7.87k|countl_zero(T x) noexcept {
  106|  7.87k|  return numeric_internal::CountLeadingZeroes(x);
  107|  7.87k|}
_ZN4absl11countr_zeroImEENSt3__19enable_ifIXsr3stdE13is_unsigned_vIT_EEiE4typeES3_:
  118|  4.86k|countr_zero(T x) noexcept {
  119|  4.86k|  return numeric_internal::CountTrailingZeroes(x);
  120|  4.86k|}

_ZN4absl7uint128rSEi:
  631|  6.71k|inline uint128& uint128::operator>>=(int amount) {
  632|  6.71k|  *this = *this >> amount;
  633|  6.71k|  return *this;
  634|  6.71k|}
_ZN4absl7uint128pLES0_:
  636|     77|inline uint128& uint128::operator+=(uint128 other) {
  637|     77|  *this = *this + other;
  638|     77|  return *this;
  639|     77|}
_ZN4absl7uint128dVES0_:
  651|  1.56k|inline uint128& uint128::operator/=(uint128 other) {
  652|  1.56k|  *this = *this / other;
  653|  1.56k|  return *this;
  654|  1.56k|}
_ZN4absl12Uint128Low64ENS_7uint128E:
  661|  7.84k|constexpr uint64_t Uint128Low64(uint128 v) { return v.lo_; }
_ZN4absl13Uint128High64ENS_7uint128E:
  663|  11.2k|constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; }
_ZNK4absl7uint128cvbEv:
  737|  6.71k|constexpr uint128::operator bool() const { return lo_ || hi_; }
  ------------------
  |  Branch (737:51): [True: 3.56k, False: 3.14k]
  |  Branch (737:58): [True: 0, False: 3.14k]
  ------------------
_ZNK4absl7uint128cvjEv:
  770|  6.71k|constexpr uint128::operator unsigned int() const {
  771|  6.71k|  return static_cast<unsigned int>(lo_);
  772|  6.71k|}
_ZNK4absl7uint128cvoEv:
  794|  33.6k|constexpr uint128::operator unsigned __int128() const {
  795|  33.6k|  return (static_cast<unsigned __int128>(hi_) << 64) + lo_;
  796|  33.6k|}
_ZN4absleqENS_7uint128ES0_:
  820|  1.56k|constexpr bool operator==(uint128 lhs, uint128 rhs) {
  821|  1.56k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  822|  1.56k|  return static_cast<unsigned __int128>(lhs) ==
  823|  1.56k|         static_cast<unsigned __int128>(rhs);
  824|       |#else
  825|       |  return (Uint128Low64(lhs) == Uint128Low64(rhs) &&
  826|       |          Uint128High64(lhs) == Uint128High64(rhs));
  827|       |#endif
  828|  1.56k|}
_ZN4absllsENS_7uint128Ei:
  960|  4.70k|constexpr uint128 operator<<(uint128 lhs, int amount) {
  961|  4.70k|#ifdef ABSL_HAVE_INTRINSIC_INT128
  962|  4.70k|  return static_cast<unsigned __int128>(lhs) << amount;
  963|       |#else
  964|       |  // uint64_t shifts of >= 64 are undefined, so we will need some
  965|       |  // special-casing.
  966|       |  return amount >= 64  ? MakeUint128(Uint128Low64(lhs) << (amount - 64), 0)
  967|       |         : amount == 0 ? lhs
  968|       |                       : MakeUint128((Uint128High64(lhs) << amount) |
  969|       |                                         (Uint128Low64(lhs) >> (64 - amount)),
  970|       |                                     Uint128Low64(lhs) << amount);
  971|       |#endif
  972|  4.70k|}
_ZN4abslrsENS_7uint128Ei:
  974|  6.71k|constexpr uint128 operator>>(uint128 lhs, int amount) {
  975|  6.71k|#ifdef ABSL_HAVE_INTRINSIC_INT128
  976|  6.71k|  return static_cast<unsigned __int128>(lhs) >> amount;
  977|       |#else
  978|       |  // uint64_t shifts of >= 64 are undefined, so we will need some
  979|       |  // special-casing.
  980|       |  return amount >= 64  ? MakeUint128(0, Uint128High64(lhs) >> (amount - 64))
  981|       |         : amount == 0 ? lhs
  982|       |                       : MakeUint128(Uint128High64(lhs) >> amount,
  983|       |                                     (Uint128Low64(lhs) >> amount) |
  984|       |                                         (Uint128High64(lhs) << (64 - amount)));
  985|       |#endif
  986|  6.71k|}
_ZN4abslplENS_7uint128ES0_:
  999|     77|constexpr uint128 operator+(uint128 lhs, uint128 rhs) {
 1000|     77|#if defined(ABSL_HAVE_INTRINSIC_INT128)
 1001|     77|  return static_cast<unsigned __int128>(lhs) +
 1002|     77|         static_cast<unsigned __int128>(rhs);
 1003|       |#else
 1004|       |  return int128_internal::AddResult(
 1005|       |      MakeUint128(Uint128High64(lhs) + Uint128High64(rhs),
 1006|       |                  Uint128Low64(lhs) + Uint128Low64(rhs)),
 1007|       |      lhs);
 1008|       |#endif
 1009|     77|}
_ZN4abslmlENS_7uint128ES0_:
 1059|  3.21k|constexpr uint128 operator*(uint128 lhs, uint128 rhs) {
 1060|       |  // TODO(strel) Remove once alignment issues are resolved and unsigned __int128
 1061|       |  // can be used for uint128 storage.
 1062|  3.21k|  return static_cast<unsigned __int128>(lhs) *
 1063|  3.21k|         static_cast<unsigned __int128>(rhs);
 1064|  3.21k|}
_ZN4absldvENS_7uint128ES0_:
 1066|  3.12k|constexpr uint128 operator/(uint128 lhs, uint128 rhs) {
 1067|  3.12k|  return static_cast<unsigned __int128>(lhs) /
 1068|  3.12k|         static_cast<unsigned __int128>(rhs);
 1069|  3.12k|}
_ZN4abslrmENS_7uint128ES0_:
 1071|  3.12k|constexpr uint128 operator%(uint128 lhs, uint128 rhs) {
 1072|  3.12k|  return static_cast<unsigned __int128>(lhs) %
 1073|  3.12k|         static_cast<unsigned __int128>(rhs);
 1074|  3.12k|}
_ZN4absl7uint128C2Eo:
  692|  20.9k|    : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
  693|  20.9k|      hi_{static_cast<uint64_t>(v >> 64)} {}
_ZN4absl7uint128C2Ei:
  672|  1.56k|    : lo_{static_cast<uint64_t>(v)},
  673|  1.56k|      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {}
  ------------------
  |  Branch (673:11): [True: 0, False: 1.56k]
  ------------------
_ZN4absl7uint128C2Em:
  683|  17.4k|constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {}

_ZN4absl16numeric_internal20CountLeadingZeroes64Em:
  214|  7.87k|CountLeadingZeroes64(uint64_t x) {
  215|  7.87k|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clzll)
  216|       |  // Use __builtin_clzll, which uses the following instructions:
  217|       |  //  x86: bsr, lzcnt
  218|       |  //  ARM64: clz
  219|       |  //  PPC: cntlzd
  220|  7.87k|  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
  221|  7.87k|                "__builtin_clzll does not take 64-bit arg");
  222|       |
  223|       |  // Handle 0 as a special case because __builtin_clzll(0) is undefined.
  224|  7.87k|  return x == 0 ? 64 : __builtin_clzll(x);
  ------------------
  |  Branch (224:10): [True: 47, False: 7.83k]
  ------------------
  225|       |#elif defined(_MSC_VER) && !defined(__clang__) && \
  226|       |    (defined(_M_X64) || defined(_M_ARM64))
  227|       |  // MSVC does not have __buitin_clzll. Use _BitScanReverse64.
  228|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  229|       |  if (_BitScanReverse64(&result, x)) {
  230|       |    return 63 - result;
  231|       |  }
  232|       |  return 64;
  233|       |#elif defined(_MSC_VER) && !defined(__clang__)
  234|       |  // MSVC does not have __buitin_clzll. Compose two calls to _BitScanReverse
  235|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  236|       |  if ((x >> 32) &&
  237|       |      _BitScanReverse(&result, static_cast<unsigned long>(x >> 32))) {
  238|       |    return 31 - result;
  239|       |  }
  240|       |  if (_BitScanReverse(&result, static_cast<unsigned long>(x))) {
  241|       |    return 63 - result;
  242|       |  }
  243|       |  return 64;
  244|       |#else
  245|       |  int zeroes = 60;
  246|       |  if (x >> 32) {
  247|       |    zeroes -= 32;
  248|       |    x >>= 32;
  249|       |  }
  250|       |  if (x >> 16) {
  251|       |    zeroes -= 16;
  252|       |    x >>= 16;
  253|       |  }
  254|       |  if (x >> 8) {
  255|       |    zeroes -= 8;
  256|       |    x >>= 8;
  257|       |  }
  258|       |  if (x >> 4) {
  259|       |    zeroes -= 4;
  260|       |    x >>= 4;
  261|       |  }
  262|       |  return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[x] + zeroes;
  263|       |#endif
  264|  7.87k|}
_ZN4absl16numeric_internal28CountTrailingZeroesNonzero64Em:
  307|  4.86k|CountTrailingZeroesNonzero64(uint64_t x) {
  308|  4.86k|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctzll)
  309|  4.86k|  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
  310|  4.86k|                "__builtin_ctzll does not take 64-bit arg");
  311|  4.86k|  return __builtin_ctzll(x);
  312|       |#elif defined(_MSC_VER) && !defined(__clang__) && \
  313|       |    (defined(_M_X64) || defined(_M_ARM64))
  314|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  315|       |  _BitScanForward64(&result, x);
  316|       |  return result;
  317|       |#elif defined(_MSC_VER) && !defined(__clang__)
  318|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  319|       |  if (static_cast<uint32_t>(x) == 0) {
  320|       |    _BitScanForward(&result, static_cast<unsigned long>(x >> 32));
  321|       |    return result + 32;
  322|       |  }
  323|       |  _BitScanForward(&result, static_cast<unsigned long>(x));
  324|       |  return result;
  325|       |#else
  326|       |  int c = 63;
  327|       |  x &= ~x + 1;
  328|       |  if (x & 0x00000000FFFFFFFF) c -= 32;
  329|       |  if (x & 0x0000FFFF0000FFFF) c -= 16;
  330|       |  if (x & 0x00FF00FF00FF00FF) c -= 8;
  331|       |  if (x & 0x0F0F0F0F0F0F0F0F) c -= 4;
  332|       |  if (x & 0x3333333333333333) c -= 2;
  333|       |  if (x & 0x5555555555555555) c -= 1;
  334|       |  return c;
  335|       |#endif
  336|  4.86k|}
_ZN4absl16numeric_internal18CountLeadingZeroesImEEiT_:
  268|  7.87k|CountLeadingZeroes(T x) {
  269|  7.87k|  static_assert(std::is_unsigned_v<T>, "T must be unsigned");
  270|  7.87k|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  271|  7.87k|                "T must have a power-of-2 size");
  272|  7.87k|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  273|  7.87k|  return sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (273:10): [Folded, False: 7.87k]
  ------------------
  274|  7.87k|             ? CountLeadingZeroes16(static_cast<uint16_t>(x)) -
  275|      0|                   (std::numeric_limits<uint16_t>::digits -
  276|      0|                    std::numeric_limits<T>::digits)
  277|  7.87k|             : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (277:17): [Folded, False: 7.87k]
  ------------------
  278|  7.87k|                    ? CountLeadingZeroes32(static_cast<uint32_t>(x)) -
  279|      0|                          (std::numeric_limits<uint32_t>::digits -
  280|      0|                           std::numeric_limits<T>::digits)
  281|  7.87k|                    : CountLeadingZeroes64(x));
  282|  7.87k|}
_ZN4absl16numeric_internal19CountTrailingZeroesImEEiT_:
  353|  4.86k|CountTrailingZeroes(T x) noexcept {
  354|  4.86k|  static_assert(std::is_unsigned_v<T>, "T must be unsigned");
  355|  4.86k|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  356|  4.86k|                "T must have a power-of-2 size");
  357|  4.86k|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  358|  4.86k|  return x == 0 ? std::numeric_limits<T>::digits
  ------------------
  |  Branch (358:10): [True: 0, False: 4.86k]
  ------------------
  359|  4.86k|                : (sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (359:20): [Folded, False: 4.86k]
  ------------------
  360|  4.86k|                       ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x))
  361|  4.86k|                       : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (361:27): [Folded, False: 4.86k]
  ------------------
  362|  4.86k|                              ? CountTrailingZeroesNonzero32(
  363|      0|                                    static_cast<uint32_t>(x))
  364|  4.86k|                              : CountTrailingZeroesNonzero64(x)));
  365|  4.86k|}

_ZN4absl13ascii_isspaceEh:
  105|  9.54k|inline bool ascii_isspace(unsigned char c) {
  106|  9.54k|  return (ascii_internal::kPropertyBits[c] & 0x08) != 0;
  107|  9.54k|}
_ZN4absl27StripLeadingAsciiWhitespaceENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  244|  3.18k|    absl::string_view str ABSL_ATTRIBUTE_LIFETIME_BOUND) {
  245|  3.18k|  auto it = std::find_if_not(str.begin(), str.end(), absl::ascii_isspace);
  246|  3.18k|  return str.substr(static_cast<size_t>(it - str.begin()));
  247|  3.18k|}
_ZN4absl28StripTrailingAsciiWhitespaceENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  258|  3.18k|    absl::string_view str ABSL_ATTRIBUTE_LIFETIME_BOUND) {
  259|  3.18k|  auto it = std::find_if_not(str.rbegin(), str.rend(), absl::ascii_isspace);
  260|  3.18k|  return str.substr(0, static_cast<size_t>(str.rend() - it));
  261|  3.18k|}
_ZN4absl20StripAsciiWhitespaceENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  272|  3.18k|    absl::string_view str ABSL_ATTRIBUTE_LIFETIME_BOUND) {
  273|  3.18k|  return StripTrailingAsciiWhitespace(StripLeadingAsciiWhitespace(str));
  274|  3.18k|}

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

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

str_cat.cc:_ZN4absl16strings_internal24StringAppendAndOverwriteINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEZNS_9StrAppendEPS8_RKNS_8AlphaNumEE3$_0EEvRT_NSE_9size_typeET0_:
   48|  1.59k|                              Op append_op) {
   49|  1.59k|  if (ABSL_PREDICT_FALSE(append_n > str.max_size() - str.size())) {
  ------------------
  |  |  190|  1.59k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.59k]
  |  |  |  Branch (190:49): [Folded, False: 1.59k]
  |  |  |  Branch (190:58): [True: 0, False: 1.59k]
  |  |  ------------------
  ------------------
   50|      0|    ThrowStdLengthError("absl::strings_internal::StringAppendAndOverwrite");
   51|      0|  }
   52|       |
   53|  1.59k|  auto old_size = str.size();
   54|  1.59k|  auto resize = old_size + append_n;
   55|       |
   56|  1.59k|  if (resize > str.capacity()) {
  ------------------
  |  Branch (56:7): [True: 380, False: 1.21k]
  ------------------
   57|       |    // Make sure to always grow by at least a factor of 2x.
   58|    380|    const auto min_growth = str.capacity();
   59|    380|    if (ABSL_PREDICT_FALSE(str.capacity() > str.max_size() - min_growth)) {
  ------------------
  |  |  190|    380|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 380]
  |  |  |  Branch (190:49): [Folded, False: 380]
  |  |  |  Branch (190:58): [True: 0, False: 380]
  |  |  ------------------
  ------------------
   60|      0|      str.reserve(str.max_size());
   61|    380|    } else if (resize < str.capacity() + min_growth) {
  ------------------
  |  Branch (61:16): [True: 166, False: 214]
  ------------------
   62|    166|      str.reserve(str.capacity() + min_growth);
   63|    166|    }
   64|    380|  }
   65|       |
   66|       |  // Avoid calling StringResizeAndOverwrite() here since it does an MSAN
   67|       |  // verification on the entire string. StringResizeAndOverwriteImpl() is
   68|       |  // StringResizeAndOverwrite() without the MSAN verification.
   69|  1.59k|  StringResizeAndOverwriteImpl(
   70|  1.59k|      str, resize,
   71|  1.59k|      [old_size, append_n, do_append = std::move(append_op)](
   72|  1.59k|          typename T::value_type* data_ptr, typename T::size_type) mutable {
   73|  1.59k|        typename T::size_type num_appended = static_cast<typename T::size_type>(
   74|  1.59k|            std::move(do_append)(data_ptr + old_size, append_n));
   75|  1.59k|        absl::base_internal::HardeningAssertGE(num_appended,
   76|  1.59k|                                               typename T::size_type{0});
   77|  1.59k|        absl::base_internal::HardeningAssertLE(num_appended, append_n);
   78|  1.59k|        return old_size + num_appended;
   79|  1.59k|      });
   80|       |
   81|       |#if defined(ABSL_HAVE_MEMORY_SANITIZER)
   82|       |  // Only check the region appended to. Checking the entire string would cause
   83|       |  // pathological quadratic verfication on repeated small appends.
   84|       |  __msan_check_mem_is_initialized(str.data() + old_size, str.size() - old_size);
   85|       |#endif
   86|  1.59k|}
str_cat.cc:_ZZN4absl16strings_internal24StringAppendAndOverwriteINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEZNS_9StrAppendEPS8_RKNS_8AlphaNumEE3$_0EEvRT_NSE_9size_typeET0_ENUlPcmE_clESI_m:
   72|  1.59k|          typename T::value_type* data_ptr, typename T::size_type) mutable {
   73|  1.59k|        typename T::size_type num_appended = static_cast<typename T::size_type>(
   74|  1.59k|            std::move(do_append)(data_ptr + old_size, append_n));
   75|  1.59k|        absl::base_internal::HardeningAssertGE(num_appended,
   76|  1.59k|                                               typename T::size_type{0});
   77|  1.59k|        absl::base_internal::HardeningAssertLE(num_appended, append_n);
   78|  1.59k|        return old_size + num_appended;
   79|  1.59k|      });

_ZN4absl16strings_internal10ParseFloatILi10EEENS0_11ParsedFloatEPKcS4_NS_12chars_formatE:
  358|  3.18k|                                         chars_format format_flags) {
  359|  3.18k|  strings_internal::ParsedFloat result;
  360|       |
  361|       |  // Exit early if we're given an empty range.
  362|  3.18k|  if (begin == end) return result;
  ------------------
  |  Branch (362:7): [True: 0, False: 3.18k]
  ------------------
  363|       |
  364|       |  // Handle the infinity and NaN cases.
  365|  3.18k|  if (ParseInfinityOrNan(begin, end, &result)) {
  ------------------
  |  Branch (365:7): [True: 0, False: 3.18k]
  ------------------
  366|      0|    return result;
  367|      0|  }
  368|       |
  369|  3.18k|  const char* const mantissa_begin = begin;
  370|  3.22k|  while (begin < end && *begin == '0') {
  ------------------
  |  Branch (370:10): [True: 3.18k, False: 47]
  |  Branch (370:25): [True: 47, False: 3.13k]
  ------------------
  371|     47|    ++begin;  // skip leading zeros
  372|     47|  }
  373|  3.18k|  uint64_t mantissa = 0;
  374|       |
  375|  3.18k|  ptrdiff_t exponent_adjustment = 0;
  376|  3.18k|  bool mantissa_is_inexact = false;
  377|  3.18k|  ptrdiff_t pre_decimal_digits = ConsumeDigits<base>(
  378|  3.18k|      begin, end, MantissaDigitsMax<base>(), &mantissa, &mantissa_is_inexact);
  379|  3.18k|  begin += pre_decimal_digits;
  380|  3.18k|  ptrdiff_t digits_left;
  381|  3.18k|  if (pre_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (381:7): [True: 0, False: 3.18k]
  ------------------
  382|       |    // refuse to parse pathological inputs
  383|      0|    return result;
  384|  3.18k|  } else if (pre_decimal_digits > MantissaDigitsMax<base>()) {
  ------------------
  |  Branch (384:14): [True: 0, False: 3.18k]
  ------------------
  385|       |    // We dropped some non-fraction digits on the floor.  Adjust our exponent
  386|       |    // to compensate.
  387|      0|    exponent_adjustment = pre_decimal_digits - MantissaDigitsMax<base>();
  388|      0|    digits_left = 0;
  389|  3.18k|  } else {
  390|  3.18k|    digits_left = MantissaDigitsMax<base>() - pre_decimal_digits;
  391|  3.18k|  }
  392|  3.18k|  if (begin < end && *begin == '.') {
  ------------------
  |  Branch (392:7): [True: 3.13k, False: 47]
  |  Branch (392:22): [True: 2.96k, False: 173]
  ------------------
  393|  2.96k|    ++begin;
  394|  2.96k|    if (mantissa == 0) {
  ------------------
  |  Branch (394:9): [True: 0, False: 2.96k]
  ------------------
  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|      ptrdiff_t zeros_skipped = 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 -= zeros_skipped;
  407|      0|    }
  408|  2.96k|    ptrdiff_t post_decimal_digits = ConsumeDigits<base>(
  409|  2.96k|        begin, end, digits_left, &mantissa, &mantissa_is_inexact);
  410|  2.96k|    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.96k|    if (post_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (416:9): [True: 0, False: 2.96k]
  ------------------
  417|       |      // refuse to parse pathological inputs
  418|      0|      return result;
  419|  2.96k|    } else if (post_decimal_digits > digits_left) {
  ------------------
  |  Branch (419:16): [True: 0, False: 2.96k]
  ------------------
  420|      0|      exponent_adjustment -= digits_left;
  421|  2.96k|    } else {
  422|  2.96k|      exponent_adjustment -= post_decimal_digits;
  423|  2.96k|    }
  424|  2.96k|  }
  425|       |  // If we've found no mantissa whatsoever, this isn't a number.
  426|  3.18k|  if (mantissa_begin == begin) {
  ------------------
  |  Branch (426:7): [True: 0, False: 3.18k]
  ------------------
  427|      0|    return result;
  428|      0|  }
  429|       |  // A bare "." doesn't count as a mantissa either.
  430|  3.18k|  if (begin - mantissa_begin == 1 && *mantissa_begin == '.') {
  ------------------
  |  Branch (430:7): [True: 220, False: 2.96k]
  |  Branch (430:38): [True: 0, False: 220]
  ------------------
  431|      0|    return result;
  432|      0|  }
  433|       |
  434|  3.18k|  if (mantissa_is_inexact) {
  ------------------
  |  Branch (434:7): [True: 0, False: 3.18k]
  ------------------
  435|       |    // We dropped significant digits on the floor.  Handle this appropriately.
  436|      0|    if (base == 10) {
  ------------------
  |  Branch (436:9): [True: 0, Folded]
  ------------------
  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, False: 0]
  ------------------
  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|  3.18k|  result.mantissa = mantissa;
  448|       |
  449|  3.18k|  const char* const exponent_begin = begin;
  450|  3.18k|  result.literal_exponent = 0;
  451|  3.18k|  bool found_exponent = false;
  452|  3.18k|  if (AllowExponent(format_flags) && begin < end &&
  ------------------
  |  Branch (452:7): [True: 3.18k, False: 0]
  |  Branch (452:38): [True: 3.13k, False: 47]
  ------------------
  453|  3.13k|      IsExponentCharacter<base>(*begin)) {
  ------------------
  |  Branch (453:7): [True: 3.13k, False: 0]
  ------------------
  454|  3.13k|    bool negative_exponent = false;
  455|  3.13k|    ++begin;
  456|  3.13k|    if (begin < end && *begin == '-') {
  ------------------
  |  Branch (456:9): [True: 3.13k, False: 0]
  |  Branch (456:24): [True: 0, False: 3.13k]
  ------------------
  457|      0|      negative_exponent = true;
  458|      0|      ++begin;
  459|  3.13k|    } else if (begin < end && *begin == '+') {
  ------------------
  |  Branch (459:16): [True: 3.13k, False: 0]
  |  Branch (459:31): [True: 3.13k, False: 0]
  ------------------
  460|  3.13k|      ++begin;
  461|  3.13k|    }
  462|  3.13k|    const char* const exponent_digits_begin = begin;
  463|       |    // Exponent is always expressed in decimal, even for hexadecimal floats.
  464|  3.13k|    begin += ConsumeDigits<10>(begin, end, kDecimalExponentDigitsMax,
  465|  3.13k|                               &result.literal_exponent, nullptr);
  466|  3.13k|    if (begin == exponent_digits_begin) {
  ------------------
  |  Branch (466:9): [True: 0, False: 3.13k]
  ------------------
  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|  3.13k|    } else {
  472|  3.13k|      found_exponent = true;
  473|  3.13k|      if (negative_exponent) {
  ------------------
  |  Branch (473:11): [True: 0, False: 3.13k]
  ------------------
  474|      0|        result.literal_exponent = -result.literal_exponent;
  475|      0|      }
  476|  3.13k|    }
  477|  3.13k|  }
  478|       |
  479|  3.18k|  if (!found_exponent && RequireExponent(format_flags)) {
  ------------------
  |  Branch (479:7): [True: 47, False: 3.13k]
  |  Branch (479:26): [True: 0, False: 47]
  ------------------
  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|  3.18k|  if (result.mantissa > 0) {
  ------------------
  |  Branch (485:7): [True: 3.13k, False: 47]
  ------------------
  486|  3.13k|    const ptrdiff_t exponent = result.literal_exponent +
  487|  3.13k|                               (DigitMagnitude<base>() * exponent_adjustment);
  488|       |
  489|  3.13k|    if (exponent < (std::numeric_limits<int>::min)() ||
  ------------------
  |  Branch (489:9): [True: 0, False: 3.13k]
  ------------------
  490|  3.13k|        exponent > (std::numeric_limits<int>::max)()) {
  ------------------
  |  Branch (490:9): [True: 0, False: 3.13k]
  ------------------
  491|       |      // We cannot store the exponent in int. Fail by returning a result with
  492|       |      // end default-initialized to nullptr.
  493|      0|      return result;
  494|      0|    }
  495|       |
  496|  3.13k|    result.exponent = static_cast<int>(exponent);
  497|  3.13k|  } else {
  498|     47|    result.exponent = 0;
  499|     47|  }
  500|  3.18k|  result.end = begin;
  501|       |
  502|       |  // Success!
  503|  3.18k|  result.type = strings_internal::FloatType::kNumber;
  504|       |
  505|  3.18k|  return result;
  506|  3.18k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_113AllowExponentENS_12chars_formatE:
  123|  3.18k|bool AllowExponent(chars_format flags) {
  124|  3.18k|  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
  125|  3.18k|  bool scientific =
  126|  3.18k|      (flags & chars_format::scientific) == chars_format::scientific;
  127|  3.18k|  return scientific || !fixed;
  ------------------
  |  Branch (127:10): [True: 3.18k, False: 0]
  |  Branch (127:24): [True: 0, False: 0]
  ------------------
  128|  3.18k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_115RequireExponentENS_12chars_formatE:
  131|     47|bool RequireExponent(chars_format flags) {
  132|     47|  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
  133|     47|  bool scientific =
  134|     47|      (flags & chars_format::scientific) == chars_format::scientific;
  135|     47|  return scientific && !fixed;
  ------------------
  |  Branch (135:10): [True: 47, False: 0]
  |  Branch (135:24): [True: 0, False: 47]
  ------------------
  136|     47|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_119IsExponentCharacterILi10EEEbc:
  202|  3.13k|bool IsExponentCharacter<10>(char ch) {
  203|  3.13k|  return ch == 'e' || ch == 'E';
  ------------------
  |  Branch (203:10): [True: 3.13k, False: 0]
  |  Branch (203:23): [True: 0, False: 0]
  ------------------
  204|  3.13k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_117MantissaDigitsMaxILi10EEEiv:
  212|  9.54k|constexpr int MantissaDigitsMax<10>() {
  213|  9.54k|  return kDecimalMantissaDigitsMax;
  214|  9.54k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_110DigitLimitILi10EEEiv:
  221|  6.14k|constexpr int DigitLimit<10>() {
  222|  6.14k|  return kDecimalDigitLimit;
  223|  6.14k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_114DigitMagnitudeILi10EEEiv:
  230|  3.13k|constexpr int DigitMagnitude<10>() {
  231|  3.13k|  return 1;
  232|  3.13k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_118ParseInfinityOrNanEPKcS2_PNS_16strings_internal11ParsedFloatE:
  300|  3.18k|                        strings_internal::ParsedFloat* out) {
  301|  3.18k|  if (end - begin < 3) {
  ------------------
  |  Branch (301:7): [True: 47, False: 3.13k]
  ------------------
  302|     47|    return false;
  303|     47|  }
  304|  3.13k|  switch (*begin) {
  305|      0|    case 'i':
  ------------------
  |  Branch (305:5): [True: 0, False: 3.13k]
  ------------------
  306|      0|    case 'I': {
  ------------------
  |  Branch (306:5): [True: 0, False: 3.13k]
  ------------------
  307|       |      // An infinity string consists of the characters "inf" or "infinity",
  308|       |      // case insensitive.
  309|      0|      if (strings_internal::memcasecmp(begin + 1, "nf", 2) != 0) {
  ------------------
  |  Branch (309:11): [True: 0, False: 0]
  ------------------
  310|      0|        return false;
  311|      0|      }
  312|      0|      out->type = strings_internal::FloatType::kInfinity;
  313|      0|      if (end - begin >= 8 &&
  ------------------
  |  Branch (313:11): [True: 0, False: 0]
  ------------------
  314|      0|          strings_internal::memcasecmp(begin + 3, "inity", 5) == 0) {
  ------------------
  |  Branch (314:11): [True: 0, False: 0]
  ------------------
  315|      0|        out->end = begin + 8;
  316|      0|      } else {
  317|      0|        out->end = begin + 3;
  318|      0|      }
  319|      0|      return true;
  320|      0|    }
  321|      0|    case 'n':
  ------------------
  |  Branch (321:5): [True: 0, False: 3.13k]
  ------------------
  322|      0|    case 'N': {
  ------------------
  |  Branch (322:5): [True: 0, False: 3.13k]
  ------------------
  323|       |      // A NaN consists of the characters "nan", case insensitive, optionally
  324|       |      // followed by a parenthesized sequence of zero or more alphanumeric
  325|       |      // characters and/or underscores.
  326|      0|      if (strings_internal::memcasecmp(begin + 1, "an", 2) != 0) {
  ------------------
  |  Branch (326:11): [True: 0, False: 0]
  ------------------
  327|      0|        return false;
  328|      0|      }
  329|      0|      out->type = strings_internal::FloatType::kNan;
  330|      0|      out->end = begin + 3;
  331|       |      // NaN is allowed to be followed by a parenthesized string, consisting of
  332|       |      // only the characters [a-zA-Z0-9_].  Match that if it's present.
  333|      0|      begin += 3;
  334|      0|      if (begin < end && *begin == '(') {
  ------------------
  |  Branch (334:11): [True: 0, False: 0]
  |  Branch (334:26): [True: 0, False: 0]
  ------------------
  335|      0|        const char* nan_begin = begin + 1;
  336|      0|        while (nan_begin < end && IsNanChar(*nan_begin)) {
  ------------------
  |  Branch (336:16): [True: 0, False: 0]
  |  Branch (336:35): [True: 0, False: 0]
  ------------------
  337|      0|          ++nan_begin;
  338|      0|        }
  339|      0|        if (nan_begin < end && *nan_begin == ')') {
  ------------------
  |  Branch (339:13): [True: 0, False: 0]
  |  Branch (339:32): [True: 0, False: 0]
  ------------------
  340|       |          // We found an extra NaN specifier range
  341|      0|          out->subrange_begin = begin + 1;
  342|      0|          out->subrange_end = nan_begin;
  343|      0|          out->end = nan_begin + 1;
  344|      0|        }
  345|      0|      }
  346|      0|      return true;
  347|      0|    }
  348|  3.13k|    default:
  ------------------
  |  Branch (348:5): [True: 3.13k, False: 0]
  ------------------
  349|  3.13k|      return false;
  350|  3.13k|  }
  351|  3.13k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_113ConsumeDigitsILi10EmEElPKcS3_lPT0_Pb:
  252|  6.14k|                        bool* dropped_nonzero_digit) {
  253|  6.14k|  if (base == 10) {
  ------------------
  |  Branch (253:7): [True: 6.14k, Folded]
  ------------------
  254|  6.14k|    assert(max_digits <= std::numeric_limits<T>::digits10);
  ------------------
  |  Branch (254:5): [True: 6.14k, False: 0]
  ------------------
  255|  6.14k|  } else if (base == 16) {
  ------------------
  |  Branch (255:14): [Folded, False: 0]
  ------------------
  256|      0|    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
  ------------------
  |  Branch (256:5): [True: 0, False: 0]
  ------------------
  257|      0|  }
  258|  6.14k|  const char* const original_begin = begin;
  259|       |
  260|       |  // Skip leading zeros, but only if *out is zero.
  261|       |  // They don't cause an overflow so we don't have to count them for
  262|       |  // `max_digits`.
  263|  6.14k|  while (!*out && end != begin && *begin == '0') ++begin;
  ------------------
  |  Branch (263:10): [True: 3.18k, False: 2.96k]
  |  Branch (263:19): [True: 3.13k, False: 47]
  |  Branch (263:35): [True: 0, False: 3.13k]
  ------------------
  264|       |
  265|  6.14k|  T accumulator = *out;
  266|  6.14k|  const char* significant_digits_end =
  267|  6.14k|      (end - begin > max_digits) ? begin + max_digits : end;
  ------------------
  |  Branch (267:7): [True: 0, False: 6.14k]
  ------------------
  268|  23.6k|  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (268:10): [True: 23.5k, False: 47]
  |  Branch (268:44): [True: 17.4k, False: 6.09k]
  ------------------
  269|       |    // Do not guard against *out overflow; max_digits was chosen to avoid this.
  270|       |    // Do assert against it, to detect problems in debug builds.
  271|  17.4k|    auto digit = static_cast<T>(ToDigit<base>(*begin));
  272|  17.4k|    assert(accumulator * base >= accumulator);
  ------------------
  |  Branch (272:5): [True: 17.4k, False: 0]
  ------------------
  273|  17.4k|    accumulator *= base;
  274|  17.4k|    assert(accumulator + digit >= accumulator);
  ------------------
  |  Branch (274:5): [True: 17.4k, False: 0]
  ------------------
  275|  17.4k|    accumulator += digit;
  276|  17.4k|    ++begin;
  277|  17.4k|  }
  278|  6.14k|  bool dropped_nonzero = false;
  279|  6.14k|  while (begin < end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (279:10): [True: 6.09k, False: 47]
  |  Branch (279:25): [True: 0, False: 6.09k]
  ------------------
  280|      0|    dropped_nonzero = dropped_nonzero || (*begin != '0');
  ------------------
  |  Branch (280:23): [True: 0, False: 0]
  |  Branch (280:42): [True: 0, False: 0]
  ------------------
  281|      0|    ++begin;
  282|      0|  }
  283|  6.14k|  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
  ------------------
  |  Branch (283:7): [True: 0, False: 6.14k]
  |  Branch (283:26): [True: 0, False: 0]
  ------------------
  284|      0|    *dropped_nonzero_digit = true;
  285|      0|  }
  286|  6.14k|  *out = accumulator;
  287|  6.14k|  return begin - original_begin;
  288|  6.14k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_17IsDigitILi10EEEbc:
  184|  37.5k|bool IsDigit<10>(char ch) {
  185|  37.5k|  return ch >= '0' && ch <= '9';
  ------------------
  |  Branch (185:10): [True: 31.6k, False: 5.92k]
  |  Branch (185:23): [True: 25.3k, False: 6.27k]
  ------------------
  186|  37.5k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_17ToDigitILi10EEEjc:
  193|  25.3k|unsigned ToDigit<10>(char ch) {
  194|  25.3k|  return static_cast<unsigned>(ch - '0');
  195|  25.3k|}
charconv_parse.cc:_ZN4absl12_GLOBAL__N_113ConsumeDigitsILi10EiEElPKcS3_lPT0_Pb:
  252|  3.13k|                        bool* dropped_nonzero_digit) {
  253|  3.13k|  if (base == 10) {
  ------------------
  |  Branch (253:7): [True: 3.13k, Folded]
  ------------------
  254|  3.13k|    assert(max_digits <= std::numeric_limits<T>::digits10);
  ------------------
  |  Branch (254:5): [True: 3.13k, False: 0]
  ------------------
  255|  3.13k|  } else if (base == 16) {
  ------------------
  |  Branch (255:14): [Folded, False: 0]
  ------------------
  256|      0|    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
  ------------------
  |  Branch (256:5): [True: 0, False: 0]
  ------------------
  257|      0|  }
  258|  3.13k|  const char* const original_begin = begin;
  259|       |
  260|       |  // Skip leading zeros, but only if *out is zero.
  261|       |  // They don't cause an overflow so we don't have to count them for
  262|       |  // `max_digits`.
  263|  3.13k|  while (!*out && end != begin && *begin == '0') ++begin;
  ------------------
  |  Branch (263:10): [True: 3.13k, False: 0]
  |  Branch (263:19): [True: 3.13k, False: 0]
  |  Branch (263:35): [True: 0, False: 3.13k]
  ------------------
  264|       |
  265|  3.13k|  T accumulator = *out;
  266|  3.13k|  const char* significant_digits_end =
  267|  3.13k|      (end - begin > max_digits) ? begin + max_digits : end;
  ------------------
  |  Branch (267:7): [True: 0, False: 3.13k]
  ------------------
  268|  10.9k|  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (268:10): [True: 7.84k, False: 3.13k]
  |  Branch (268:44): [True: 7.84k, False: 0]
  ------------------
  269|       |    // Do not guard against *out overflow; max_digits was chosen to avoid this.
  270|       |    // Do assert against it, to detect problems in debug builds.
  271|  7.84k|    auto digit = static_cast<T>(ToDigit<base>(*begin));
  272|  7.84k|    assert(accumulator * base >= accumulator);
  ------------------
  |  Branch (272:5): [True: 7.84k, False: 0]
  ------------------
  273|  7.84k|    accumulator *= base;
  274|  7.84k|    assert(accumulator + digit >= accumulator);
  ------------------
  |  Branch (274:5): [True: 7.84k, False: 0]
  ------------------
  275|  7.84k|    accumulator += digit;
  276|  7.84k|    ++begin;
  277|  7.84k|  }
  278|  3.13k|  bool dropped_nonzero = false;
  279|  3.13k|  while (begin < end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (279:10): [True: 0, False: 3.13k]
  |  Branch (279:25): [True: 0, False: 0]
  ------------------
  280|      0|    dropped_nonzero = dropped_nonzero || (*begin != '0');
  ------------------
  |  Branch (280:23): [True: 0, False: 0]
  |  Branch (280:42): [True: 0, False: 0]
  ------------------
  281|      0|    ++begin;
  282|      0|  }
  283|  3.13k|  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
  ------------------
  |  Branch (283:7): [True: 0, False: 3.13k]
  |  Branch (283:26): [True: 0, False: 0]
  ------------------
  284|      0|    *dropped_nonzero_digit = true;
  285|      0|  }
  286|  3.13k|  *out = accumulator;
  287|  3.13k|  return begin - original_begin;
  288|  3.13k|}

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

_ZN4absl19str_format_internal13ConvertIntArgIiEEbT_NS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  369|  3.18k|bool ConvertIntArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
  370|  3.18k|  using U = typename MakeUnsigned<T>::type;
  371|  3.18k|  IntDigits as_digits;
  372|       |
  373|       |  // This odd casting is due to a bug in -Wswitch behavior in gcc49 which causes
  374|       |  // it to complain about a switch/case type mismatch, even though both are
  375|       |  // FormatConversionChar.  Likely this is because at this point
  376|       |  // FormatConversionChar is declared, but not defined.
  377|  3.18k|  switch (static_cast<uint8_t>(conv.conversion_char())) {
  378|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::c):
  ------------------
  |  Branch (378:5): [True: 0, False: 3.18k]
  ------------------
  379|      0|      return (std::is_same_v<T, wchar_t> || (conv.length_mod() == LengthMod::l))
  ------------------
  |  Branch (379:15): [Folded, False: 0]
  |  Branch (379:45): [True: 0, False: 0]
  ------------------
  380|      0|                 ? ConvertWCharTImpl(static_cast<wchar_t>(v), conv, sink)
  381|      0|                 : ConvertCharImpl(static_cast<char>(v), conv, sink);
  382|       |
  383|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::o):
  ------------------
  |  Branch (383:5): [True: 0, False: 3.18k]
  ------------------
  384|      0|      as_digits.PrintAsOct(static_cast<U>(v));
  385|      0|      break;
  386|       |
  387|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::x):
  ------------------
  |  Branch (387:5): [True: 0, False: 3.18k]
  ------------------
  388|      0|      as_digits.PrintAsHexLower(static_cast<U>(v));
  389|      0|      break;
  390|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::X):
  ------------------
  |  Branch (390:5): [True: 0, False: 3.18k]
  ------------------
  391|      0|      as_digits.PrintAsHexUpper(static_cast<U>(v));
  392|      0|      break;
  393|       |
  394|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::u):
  ------------------
  |  Branch (394:5): [True: 0, False: 3.18k]
  ------------------
  395|      0|      as_digits.PrintAsDec(static_cast<U>(v));
  396|      0|      break;
  397|       |
  398|  3.18k|    case static_cast<uint8_t>(FormatConversionCharInternal::d):
  ------------------
  |  Branch (398:5): [True: 3.18k, False: 0]
  ------------------
  399|  3.18k|    case static_cast<uint8_t>(FormatConversionCharInternal::i):
  ------------------
  |  Branch (399:5): [True: 0, False: 3.18k]
  ------------------
  400|  3.18k|    case static_cast<uint8_t>(FormatConversionCharInternal::v):
  ------------------
  |  Branch (400:5): [True: 0, False: 3.18k]
  ------------------
  401|  3.18k|      as_digits.PrintAsDec(v);
  402|  3.18k|      break;
  403|       |
  404|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::a):
  ------------------
  |  Branch (404:5): [True: 0, False: 3.18k]
  ------------------
  405|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::e):
  ------------------
  |  Branch (405:5): [True: 0, False: 3.18k]
  ------------------
  406|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::f):
  ------------------
  |  Branch (406:5): [True: 0, False: 3.18k]
  ------------------
  407|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::g):
  ------------------
  |  Branch (407:5): [True: 0, False: 3.18k]
  ------------------
  408|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::A):
  ------------------
  |  Branch (408:5): [True: 0, False: 3.18k]
  ------------------
  409|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::E):
  ------------------
  |  Branch (409:5): [True: 0, False: 3.18k]
  ------------------
  410|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::F):
  ------------------
  |  Branch (410:5): [True: 0, False: 3.18k]
  ------------------
  411|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::G):
  ------------------
  |  Branch (411:5): [True: 0, False: 3.18k]
  ------------------
  412|      0|      return ConvertFloatImpl(static_cast<double>(v), conv, sink);
  413|       |
  414|      0|    default:
  ------------------
  |  Branch (414:5): [True: 0, False: 3.18k]
  ------------------
  415|      0|      ABSL_ASSUME(false);
  ------------------
  |  |  270|      0|  (ABSL_PREDICT_TRUE((cond)) ? void() : assert(false && #cond))  // NOLINT
  |  |  ------------------
  |  |  |  |  191|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (191:30): [Folded, False: 0]
  |  |  |  |  |  Branch (191:48): [Folded, False: 0]
  |  |  |  |  |  Branch (191:57): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (415:7): [Folded, False: 0]
  |  Branch (415:7): [True: 0, Folded]
  |  Branch (415:7): [Folded, False: 0]
  ------------------
  416|  3.18k|  }
  417|       |
  418|  3.18k|  if (conv.is_basic()) {
  ------------------
  |  Branch (418:7): [True: 3.18k, False: 0]
  ------------------
  419|  3.18k|    sink->Append(as_digits.with_neg_and_zero());
  420|  3.18k|    return true;
  421|  3.18k|  }
  422|      0|  return ConvertIntImplInnerSlow(as_digits, conv, sink);
  423|  3.18k|}
_ZN4absl19str_format_internal17FormatConvertImplEfNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  540|  1.59k|                                        FormatSinkImpl *sink) {
  541|  1.59k|  return {ConvertFloatArg(v, conv, sink)};
  542|  1.59k|}
_ZN4absl19str_format_internal17FormatConvertImplEdNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  545|  1.59k|                                        FormatSinkImpl *sink) {
  546|  1.59k|  return {ConvertFloatArg(v, conv, sink)};
  547|  1.59k|}
_ZN4absl19str_format_internal17FormatConvertImplEiNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  588|  3.18k|                                        FormatSinkImpl *sink) {
  589|  3.18k|  return {ConvertIntArg(v, conv, sink)};
  590|  3.18k|}
arg.cc:_ZNK4absl19str_format_internal12_GLOBAL__N_19IntDigits17with_neg_and_zeroEv:
  175|  3.18k|  string_view with_neg_and_zero() const { return {start_, size_}; }
arg.cc:_ZN4absl19str_format_internal12_GLOBAL__N_19IntDigits10PrintAsDecIiEEvT_:
   98|  3.18k|  void PrintAsDec(T v) {
   99|  3.18k|    static_assert(std::is_integral_v<T>, "");
  100|  3.18k|    start_ = storage_;
  101|  3.18k|    size_ = static_cast<size_t>(numbers_internal::FastIntToBuffer(v, storage_) -
  102|  3.18k|                                storage_);
  103|  3.18k|  }
arg.cc:_ZN4absl19str_format_internal12_GLOBAL__N_115ConvertFloatArgIfEEbT_NS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  294|  1.59k|bool ConvertFloatArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
  295|  1.59k|  if (conv.conversion_char() == FormatConversionCharInternal::v) {
  ------------------
  |  Branch (295:7): [True: 0, False: 1.59k]
  ------------------
  296|      0|    conv.set_conversion_char(FormatConversionCharInternal::g);
  297|      0|  }
  298|       |
  299|  1.59k|  return FormatConversionCharIsFloat(conv.conversion_char()) &&
  ------------------
  |  Branch (299:10): [True: 1.59k, False: 0]
  ------------------
  300|  1.59k|         ConvertFloatImpl(v, conv, sink);
  ------------------
  |  Branch (300:10): [True: 1.59k, False: 0]
  ------------------
  301|  1.59k|}
arg.cc:_ZN4absl19str_format_internal12_GLOBAL__N_115ConvertFloatArgIdEEbT_NS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  294|  1.59k|bool ConvertFloatArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
  295|  1.59k|  if (conv.conversion_char() == FormatConversionCharInternal::v) {
  ------------------
  |  Branch (295:7): [True: 0, False: 1.59k]
  ------------------
  296|      0|    conv.set_conversion_char(FormatConversionCharInternal::g);
  297|      0|  }
  298|       |
  299|  1.59k|  return FormatConversionCharIsFloat(conv.conversion_char()) &&
  ------------------
  |  Branch (299:10): [True: 1.59k, False: 0]
  ------------------
  300|  1.59k|         ConvertFloatImpl(v, conv, sink);
  ------------------
  |  Branch (300:10): [True: 1.59k, False: 0]
  ------------------
  301|  1.59k|}

_ZN4absl19str_format_internal13FormatArgImplC2IfEERKT_:
  490|  1.59k|  explicit FormatArgImpl(const T& value) {
  491|  1.59k|    using D = typename DecayType<T>::type;
  492|  1.59k|    static_assert(
  493|  1.59k|        std::is_same_v<D, const T&> || storage_policy<D>::value == ByValue,
  494|  1.59k|        "Decayed types must be stored by value");
  495|  1.59k|    Init(static_cast<D>(value));
  496|  1.59k|  }
_ZN4absl19str_format_internal13FormatArgImpl4InitIfEEvRKT_:
  543|  1.59k|  void Init(const T& value) {
  544|  1.59k|    data_ = Manager<T>::SetValue(value);
  545|  1.59k|    dispatcher_ = &Dispatch<T>;
  546|  1.59k|  }
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIfLNS1_13StoragePolicyE2EE8SetValueERKf:
  529|  1.59k|    static Data SetValue(const T& value) {
  530|  1.59k|      Data data;
  531|  1.59k|      memcpy(data.buf, &value, sizeof(value));
  532|  1.59k|      return data;
  533|  1.59k|    }
_ZN4absl19str_format_internal13FormatArgImpl8DispatchIfEEbNS1_4DataENS0_24FormatConversionSpecImplEPv:
  584|  1.59k|  static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) {
  585|       |    // A `none` conv indicates that we want the `int` conversion.
  586|  1.59k|    if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
  ------------------
  |  |  190|  1.59k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.59k]
  |  |  |  Branch (190:49): [Folded, False: 1.59k]
  |  |  |  Branch (190:58): [True: 0, False: 1.59k]
  |  |  ------------------
  ------------------
  587|  1.59k|                           FormatConversionCharInternal::kNone)) {
  588|      0|      return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
  589|      0|                      std::is_enum<T>());
  590|      0|    }
  591|  1.59k|    if (ABSL_PREDICT_FALSE(
  ------------------
  |  |  190|  1.59k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.59k]
  |  |  |  Branch (190:49): [Folded, False: 1.59k]
  |  |  |  Branch (190:58): [True: 0, False: 1.59k]
  |  |  ------------------
  ------------------
  592|  1.59k|            !Contains(ArgumentToConv<T>(), spec.conversion_char()))) {
  593|      0|      return false;
  594|      0|    }
  595|  1.59k|    return str_format_internal::FormatConvertImpl(
  596|  1.59k|               Manager<T>::Value(arg), spec, static_cast<FormatSinkImpl*>(out))
  597|  1.59k|        .value;
  598|  1.59k|  }
_ZN4absl19str_format_internal14ArgumentToConvIfEENS_23FormatConversionCharSetEv:
  418|  1.59k|constexpr FormatConversionCharSet ArgumentToConv() {
  419|  1.59k|  using ConvResult = decltype(str_format_internal::FormatConvertImpl(
  420|  1.59k|      std::declval<const Arg&>(),
  421|  1.59k|      std::declval<const FormatConversionSpecImpl&>(),
  422|  1.59k|      std::declval<FormatSinkImpl*>()));
  423|  1.59k|  return absl::str_format_internal::ExtractCharSet(ConvResult{});
  424|  1.59k|}
_ZN4absl19str_format_internal14ExtractCharSetILNS_23FormatConversionCharSetE654848EEES2_NS0_16ArgConvertResultIXT_EEE:
  205|  3.18k|constexpr FormatConversionCharSet ExtractCharSet(ArgConvertResult<C>) {
  206|  3.18k|  return C;
  207|  3.18k|}
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIfLNS1_13StoragePolicyE2EE5ValueENS1_4DataE:
  535|  1.59k|    static T Value(Data arg) {
  536|  1.59k|      T value;
  537|  1.59k|      memcpy(&value, arg.buf, sizeof(T));
  538|  1.59k|      return value;
  539|  1.59k|    }
_ZN4absl19str_format_internal13FormatArgImplC2IdEERKT_:
  490|  1.59k|  explicit FormatArgImpl(const T& value) {
  491|  1.59k|    using D = typename DecayType<T>::type;
  492|  1.59k|    static_assert(
  493|  1.59k|        std::is_same_v<D, const T&> || storage_policy<D>::value == ByValue,
  494|  1.59k|        "Decayed types must be stored by value");
  495|  1.59k|    Init(static_cast<D>(value));
  496|  1.59k|  }
_ZN4absl19str_format_internal13FormatArgImpl4InitIdEEvRKT_:
  543|  1.59k|  void Init(const T& value) {
  544|  1.59k|    data_ = Manager<T>::SetValue(value);
  545|  1.59k|    dispatcher_ = &Dispatch<T>;
  546|  1.59k|  }
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIdLNS1_13StoragePolicyE2EE8SetValueERKd:
  529|  1.59k|    static Data SetValue(const T& value) {
  530|  1.59k|      Data data;
  531|  1.59k|      memcpy(data.buf, &value, sizeof(value));
  532|  1.59k|      return data;
  533|  1.59k|    }
_ZN4absl19str_format_internal13FormatArgImpl8DispatchIdEEbNS1_4DataENS0_24FormatConversionSpecImplEPv:
  584|  1.59k|  static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) {
  585|       |    // A `none` conv indicates that we want the `int` conversion.
  586|  1.59k|    if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
  ------------------
  |  |  190|  1.59k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.59k]
  |  |  |  Branch (190:49): [Folded, False: 1.59k]
  |  |  |  Branch (190:58): [True: 0, False: 1.59k]
  |  |  ------------------
  ------------------
  587|  1.59k|                           FormatConversionCharInternal::kNone)) {
  588|      0|      return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
  589|      0|                      std::is_enum<T>());
  590|      0|    }
  591|  1.59k|    if (ABSL_PREDICT_FALSE(
  ------------------
  |  |  190|  1.59k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.59k]
  |  |  |  Branch (190:49): [Folded, False: 1.59k]
  |  |  |  Branch (190:58): [True: 0, False: 1.59k]
  |  |  ------------------
  ------------------
  592|  1.59k|            !Contains(ArgumentToConv<T>(), spec.conversion_char()))) {
  593|      0|      return false;
  594|      0|    }
  595|  1.59k|    return str_format_internal::FormatConvertImpl(
  596|  1.59k|               Manager<T>::Value(arg), spec, static_cast<FormatSinkImpl*>(out))
  597|  1.59k|        .value;
  598|  1.59k|  }
_ZN4absl19str_format_internal14ArgumentToConvIdEENS_23FormatConversionCharSetEv:
  418|  1.59k|constexpr FormatConversionCharSet ArgumentToConv() {
  419|  1.59k|  using ConvResult = decltype(str_format_internal::FormatConvertImpl(
  420|  1.59k|      std::declval<const Arg&>(),
  421|  1.59k|      std::declval<const FormatConversionSpecImpl&>(),
  422|  1.59k|      std::declval<FormatSinkImpl*>()));
  423|  1.59k|  return absl::str_format_internal::ExtractCharSet(ConvResult{});
  424|  1.59k|}
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIdLNS1_13StoragePolicyE2EE5ValueENS1_4DataE:
  535|  1.59k|    static T Value(Data arg) {
  536|  1.59k|      T value;
  537|  1.59k|      memcpy(&value, arg.buf, sizeof(T));
  538|  1.59k|      return value;
  539|  1.59k|    }
_ZN4absl19str_format_internal13FormatArgImplC2IiEERKT_:
  490|  1.59k|  explicit FormatArgImpl(const T& value) {
  491|  1.59k|    using D = typename DecayType<T>::type;
  492|  1.59k|    static_assert(
  493|  1.59k|        std::is_same_v<D, const T&> || storage_policy<D>::value == ByValue,
  494|  1.59k|        "Decayed types must be stored by value");
  495|  1.59k|    Init(static_cast<D>(value));
  496|  1.59k|  }
_ZN4absl19str_format_internal13FormatArgImpl4InitIiEEvRKT_:
  543|  1.59k|  void Init(const T& value) {
  544|  1.59k|    data_ = Manager<T>::SetValue(value);
  545|  1.59k|    dispatcher_ = &Dispatch<T>;
  546|  1.59k|  }
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIiLNS1_13StoragePolicyE2EE8SetValueERKi:
  529|  1.59k|    static Data SetValue(const T& value) {
  530|  1.59k|      Data data;
  531|  1.59k|      memcpy(data.buf, &value, sizeof(value));
  532|  1.59k|      return data;
  533|  1.59k|    }
_ZN4absl19str_format_internal13FormatArgImpl8DispatchIiEEbNS1_4DataENS0_24FormatConversionSpecImplEPv:
  584|  1.59k|  static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) {
  585|       |    // A `none` conv indicates that we want the `int` conversion.
  586|  1.59k|    if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
  ------------------
  |  |  190|  1.59k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.59k]
  |  |  |  Branch (190:49): [Folded, False: 1.59k]
  |  |  |  Branch (190:58): [True: 0, False: 1.59k]
  |  |  ------------------
  ------------------
  587|  1.59k|                           FormatConversionCharInternal::kNone)) {
  588|      0|      return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
  589|      0|                      std::is_enum<T>());
  590|      0|    }
  591|  1.59k|    if (ABSL_PREDICT_FALSE(
  ------------------
  |  |  190|  1.59k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.59k]
  |  |  |  Branch (190:49): [Folded, False: 1.59k]
  |  |  |  Branch (190:58): [True: 0, False: 1.59k]
  |  |  ------------------
  ------------------
  592|  1.59k|            !Contains(ArgumentToConv<T>(), spec.conversion_char()))) {
  593|      0|      return false;
  594|      0|    }
  595|  1.59k|    return str_format_internal::FormatConvertImpl(
  596|  1.59k|               Manager<T>::Value(arg), spec, static_cast<FormatSinkImpl*>(out))
  597|  1.59k|        .value;
  598|  1.59k|  }
_ZN4absl19str_format_internal14ArgumentToConvIiEENS_23FormatConversionCharSetEv:
  418|  1.59k|constexpr FormatConversionCharSet ArgumentToConv() {
  419|  1.59k|  using ConvResult = decltype(str_format_internal::FormatConvertImpl(
  420|  1.59k|      std::declval<const Arg&>(),
  421|  1.59k|      std::declval<const FormatConversionSpecImpl&>(),
  422|  1.59k|      std::declval<FormatSinkImpl*>()));
  423|  1.59k|  return absl::str_format_internal::ExtractCharSet(ConvResult{});
  424|  1.59k|}
_ZN4absl19str_format_internal14ExtractCharSetILNS_23FormatConversionCharSetE655355EEES2_NS0_16ArgConvertResultIXT_EEE:
  205|  3.18k|constexpr FormatConversionCharSet ExtractCharSet(ArgConvertResult<C>) {
  206|  3.18k|  return C;
  207|  3.18k|}
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIiLNS1_13StoragePolicyE2EE5ValueENS1_4DataE:
  535|  1.59k|    static T Value(Data arg) {
  536|  1.59k|      T value;
  537|  1.59k|      memcpy(&value, arg.buf, sizeof(T));
  538|  1.59k|      return value;
  539|  1.59k|    }
_ZN4absl19str_format_internal13FormatArgImplC2IbEERKT_:
  490|  1.59k|  explicit FormatArgImpl(const T& value) {
  491|  1.59k|    using D = typename DecayType<T>::type;
  492|  1.59k|    static_assert(
  493|  1.59k|        std::is_same_v<D, const T&> || storage_policy<D>::value == ByValue,
  494|  1.59k|        "Decayed types must be stored by value");
  495|  1.59k|    Init(static_cast<D>(value));
  496|  1.59k|  }
_ZN4absl19str_format_internal13FormatArgImpl4InitIbEEvRKT_:
  543|  1.59k|  void Init(const T& value) {
  544|  1.59k|    data_ = Manager<T>::SetValue(value);
  545|  1.59k|    dispatcher_ = &Dispatch<T>;
  546|  1.59k|  }
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIbLNS1_13StoragePolicyE2EE8SetValueERKb:
  529|  1.59k|    static Data SetValue(const T& value) {
  530|  1.59k|      Data data;
  531|  1.59k|      memcpy(data.buf, &value, sizeof(value));
  532|  1.59k|      return data;
  533|  1.59k|    }
_ZN4absl19str_format_internal13FormatArgImpl8DispatchIbEEbNS1_4DataENS0_24FormatConversionSpecImplEPv:
  584|  1.59k|  static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) {
  585|       |    // A `none` conv indicates that we want the `int` conversion.
  586|  1.59k|    if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
  ------------------
  |  |  190|  1.59k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.59k]
  |  |  |  Branch (190:49): [Folded, False: 1.59k]
  |  |  |  Branch (190:58): [True: 0, False: 1.59k]
  |  |  ------------------
  ------------------
  587|  1.59k|                           FormatConversionCharInternal::kNone)) {
  588|      0|      return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
  589|      0|                      std::is_enum<T>());
  590|      0|    }
  591|  1.59k|    if (ABSL_PREDICT_FALSE(
  ------------------
  |  |  190|  1.59k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.59k]
  |  |  |  Branch (190:49): [Folded, False: 1.59k]
  |  |  |  Branch (190:58): [True: 0, False: 1.59k]
  |  |  ------------------
  ------------------
  592|  1.59k|            !Contains(ArgumentToConv<T>(), spec.conversion_char()))) {
  593|      0|      return false;
  594|      0|    }
  595|  1.59k|    return str_format_internal::FormatConvertImpl(
  596|  1.59k|               Manager<T>::Value(arg), spec, static_cast<FormatSinkImpl*>(out))
  597|  1.59k|        .value;
  598|  1.59k|  }
_ZN4absl19str_format_internal14ArgumentToConvIbEENS_23FormatConversionCharSetEv:
  418|  1.59k|constexpr FormatConversionCharSet ArgumentToConv() {
  419|  1.59k|  using ConvResult = decltype(str_format_internal::FormatConvertImpl(
  420|  1.59k|      std::declval<const Arg&>(),
  421|  1.59k|      std::declval<const FormatConversionSpecImpl&>(),
  422|  1.59k|      std::declval<FormatSinkImpl*>()));
  423|  1.59k|  return absl::str_format_internal::ExtractCharSet(ConvResult{});
  424|  1.59k|}
_ZN4absl19str_format_internal17FormatConvertImplIbTnNSt3__19enable_ifIXsr3stdE9is_same_vIT_bEEiE4typeELi0EEENS0_16ArgConvertResultILNS_23FormatConversionCharSetE655355EEES4_NS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  344|  1.59k|                                        FormatSinkImpl* sink) {
  345|  1.59k|  if (conv.conversion_char() == FormatConversionCharInternal::v) {
  ------------------
  |  Branch (345:7): [True: 0, False: 1.59k]
  ------------------
  346|      0|    return {ConvertBoolArg(v, sink)};
  347|      0|  }
  348|       |
  349|  1.59k|  return FormatConvertImpl(static_cast<int>(v), conv, sink);
  350|  1.59k|}
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIbLNS1_13StoragePolicyE2EE5ValueENS1_4DataE:
  535|  1.59k|    static T Value(Data arg) {
  536|  1.59k|      T value;
  537|  1.59k|      memcpy(&value, arg.buf, sizeof(T));
  538|  1.59k|      return value;
  539|  1.59k|    }
_ZN4absl19str_format_internal19FormatArgImplFriend7ConvertINS0_13FormatArgImplEEEbT_NS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  407|  6.36k|                      FormatSinkImpl* out) {
  408|  6.36k|    return arg.dispatcher_(arg.data_, conv, out);
  409|  6.36k|  }

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

_ZN4absl19str_format_internal21UntypedFormatSpecImpl7ExtractINS0_18FormatSpecTemplateIJLNS_23FormatConversionCharSetE654848EEEEEERKS1_RKT_:
   73|  3.18k|  static const UntypedFormatSpecImpl& Extract(const T& s) {
   74|  3.18k|    return s.spec_;
   75|  3.18k|  }
_ZN4absl19str_format_internal18FormatSpecTemplateIJLNS_23FormatConversionCharSetE654848EEEC2EUa9enable_ifIXclL_ZNS0_15ValidFormatImplIJLS2_654848EEEEbNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEfL0p_EEEPKc:
  159|  3.18k|      : Base(s) {}
_ZN4absl19str_format_internal21UntypedFormatSpecImplC2ENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   56|  6.36k|      : data_(s.data()), size_(s.size()) {}
_ZN4absl19str_format_internal21UntypedFormatSpecImpl7ExtractINS0_18FormatSpecTemplateIJLNS_23FormatConversionCharSetE655355EEEEEERKS1_RKT_:
   73|  3.18k|  static const UntypedFormatSpecImpl& Extract(const T& s) {
   74|  3.18k|    return s.spec_;
   75|  3.18k|  }
_ZN4absl19str_format_internal18FormatSpecTemplateIJLNS_23FormatConversionCharSetE655355EEEC2EUa9enable_ifIXclL_ZNS0_15ValidFormatImplIJLS2_655355EEEEbNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEfL0p_EEEPKc:
  159|  3.18k|      : Base(s) {}
_ZNK4absl19str_format_internal15BoundConversion3argEv:
   43|  6.36k|  const FormatArgImpl* arg() const { return arg_; }
_ZN4absl19str_format_internal15BoundConversion7set_argEPKNS0_13FormatArgImplE:
   44|  6.36k|  void set_arg(const FormatArgImpl* a) { arg_ = a; }
_ZNK4absl19str_format_internal21UntypedFormatSpecImpl21has_parsed_conversionEv:
   61|  12.7k|  bool has_parsed_conversion() const { return size_ == ~size_t{}; }
_ZNK4absl19str_format_internal21UntypedFormatSpecImpl3strEv:
   63|  6.36k|  string_view str() const {
   64|  6.36k|    assert(!has_parsed_conversion());
  ------------------
  |  Branch (64:5): [True: 6.36k, False: 0]
  ------------------
   65|  6.36k|    return string_view(static_cast<const char*>(data_), size_);
   66|  6.36k|  }

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

_ZNK4absl19str_format_internal24FormatConversionSpecImpl15conversion_charEv:
  290|  30.2k|  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|  30.2k|    static_assert(offsetof(FormatConversionSpecImpl, conv_) == 0, "");
  294|  30.2k|    return conv_;
  295|  30.2k|  }
_ZN4absl19str_format_internal8ContainsENS_23FormatConversionCharSetENS_20FormatConversionCharE:
  442|  6.36k|constexpr bool Contains(FormatConversionCharSet set, FormatConversionChar c) {
  443|  6.36k|  return (static_cast<uint64_t>(set) & FormatConversionCharToConvInt(c)) != 0;
  444|  6.36k|}
_ZN4absl19str_format_internal29FormatConversionCharToConvIntENS_20FormatConversionCharE:
  360|  6.36k|constexpr uint64_t FormatConversionCharToConvInt(FormatConversionChar c) {
  361|  6.36k|  return uint64_t{1} << (1 + static_cast<uint8_t>(c));
  362|  6.36k|}
_ZN4absl19str_format_internal17FormatRawSinkImpl5WriteENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   48|  6.36k|  void Write(string_view s) { write_(sink_, s); }
_ZN4absl19str_format_internal14FormatSinkImplC2ENS0_17FormatRawSinkImplE:
   68|  6.36k|  explicit FormatSinkImpl(FormatRawSinkImpl raw) : raw_(raw) {}
_ZN4absl19str_format_internal14FormatSinkImplD2Ev:
   70|  6.36k|  ~FormatSinkImpl() { Flush(); }
_ZN4absl19str_format_internal14FormatSinkImpl5FlushEv:
   72|  6.36k|  void Flush() {
   73|  6.36k|    raw_.Write(string_view(buf_, static_cast<size_t>(pos_ - buf_)));
   74|  6.36k|    pos_ = buf_;
   75|  6.36k|  }
_ZN4absl19str_format_internal14FormatSinkImpl6AppendEmc:
   77|  19.8k|  void Append(size_t n, char c) {
   78|  19.8k|    if (n == 0) return;
  ------------------
  |  Branch (78:9): [True: 4.75k, False: 15.0k]
  ------------------
   79|  15.0k|    size_ += n;
   80|  15.0k|    auto raw_append = [&](size_t count) {
   81|  15.0k|      memset(pos_, c, count);
   82|  15.0k|      pos_ += count;
   83|  15.0k|    };
   84|  15.0k|    while (n > Avail()) {
  ------------------
  |  Branch (84:12): [True: 0, False: 15.0k]
  ------------------
   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|  15.0k|    raw_append(n);
   92|  15.0k|  }
_ZN4absl19str_format_internal14FormatSinkImpl6AppendENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   94|  14.3k|  void Append(string_view v) {
   95|  14.3k|    size_t n = v.size();
   96|  14.3k|    if (n == 0) return;
  ------------------
  |  Branch (96:9): [True: 6.41k, False: 7.92k]
  ------------------
   97|  7.92k|    size_ += n;
   98|  7.92k|    if (n >= Avail()) {
  ------------------
  |  Branch (98:9): [True: 0, False: 7.92k]
  ------------------
   99|      0|      Flush();
  100|      0|      raw_.Write(v);
  101|      0|      return;
  102|      0|    }
  103|  7.92k|    memcpy(pos_, v.data(), n);
  104|  7.92k|    pos_ += n;
  105|  7.92k|  }
_ZNK4absl19str_format_internal14FormatSinkImpl5AvailEv:
  123|  23.0k|  size_t Avail() const {
  124|  23.0k|    return static_cast<size_t>(buf_ + sizeof(buf_) - pos_);
  125|  23.0k|  }
_ZNK4absl19str_format_internal24FormatConversionSpecImpl8is_basicEv:
  277|  3.18k|  bool is_basic() const { return flags_ == Flags::kBasic; }
_ZNK4absl19str_format_internal24FormatConversionSpecImpl17has_show_pos_flagEv:
  279|  1.31k|  bool has_show_pos_flag() const {
  280|  1.31k|    return FlagsContains(flags_, Flags::kShowPos);
  281|  1.31k|  }
_ZNK4absl19str_format_internal24FormatConversionSpecImpl17has_sign_col_flagEv:
  282|  1.31k|  bool has_sign_col_flag() const {
  283|  1.31k|    return FlagsContains(flags_, Flags::kSignCol);
  284|  1.31k|  }
_ZNK4absl19str_format_internal24FormatConversionSpecImpl12has_alt_flagEv:
  285|  4.90k|  bool has_alt_flag() const { return FlagsContains(flags_, Flags::kAlt); }
_ZNK4absl19str_format_internal24FormatConversionSpecImpl5widthEv:
  301|  3.18k|  int width() const { return width_; }
_ZNK4absl19str_format_internal24FormatConversionSpecImpl9precisionEv:
  304|  3.18k|  int precision() const { return precision_; }
_ZN4absl19str_format_internal30FormatConversionSpecImplFriend8SetFlagsENS0_5FlagsEPNS0_24FormatConversionSpecImplE:
  321|  6.36k|  static void SetFlags(Flags f, FormatConversionSpecImpl* conv) {
  322|  6.36k|    conv->flags_ = f;
  323|  6.36k|  }
_ZN4absl19str_format_internal30FormatConversionSpecImplFriend17SetConversionCharENS_20FormatConversionCharEPNS0_24FormatConversionSpecImplE:
  328|  6.36k|                                FormatConversionSpecImpl* conv) {
  329|  6.36k|    conv->conv_ = c;
  330|  6.36k|  }
_ZN4absl19str_format_internal30FormatConversionSpecImplFriend8SetWidthEiPNS0_24FormatConversionSpecImplE:
  331|  6.36k|  static void SetWidth(int w, FormatConversionSpecImpl* conv) {
  332|  6.36k|    conv->width_ = w;
  333|  6.36k|  }
_ZN4absl19str_format_internal30FormatConversionSpecImplFriend12SetPrecisionEiPNS0_24FormatConversionSpecImplE:
  334|  6.36k|  static void SetPrecision(int p, FormatConversionSpecImpl* conv) {
  335|  6.36k|    conv->precision_ = p;
  336|  6.36k|  }
_ZN4absl19str_format_internal13FlagsContainsENS0_5FlagsES1_:
  150|  7.53k|constexpr bool FlagsContains(Flags haystack, Flags needle) {
  151|  7.53k|  return (static_cast<uint8_t>(haystack) & static_cast<uint8_t>(needle)) ==
  152|  7.53k|         static_cast<uint8_t>(needle);
  153|  7.53k|}
_ZN4absl19str_format_internal27FormatConversionCharIsUpperENS_20FormatConversionCharE:
  220|  3.18k|inline bool FormatConversionCharIsUpper(FormatConversionChar c) {
  221|  3.18k|  if (c == FormatConversionCharInternal::X ||
  ------------------
  |  Branch (221:7): [True: 0, False: 3.18k]
  ------------------
  222|  3.18k|      c == FormatConversionCharInternal::F ||
  ------------------
  |  Branch (222:7): [True: 0, False: 3.18k]
  ------------------
  223|  3.18k|      c == FormatConversionCharInternal::E ||
  ------------------
  |  Branch (223:7): [True: 0, False: 3.18k]
  ------------------
  224|  3.18k|      c == FormatConversionCharInternal::G ||
  ------------------
  |  Branch (224:7): [True: 0, False: 3.18k]
  ------------------
  225|  3.18k|      c == FormatConversionCharInternal::A) {
  ------------------
  |  Branch (225:7): [True: 0, False: 3.18k]
  ------------------
  226|      0|    return true;
  227|  3.18k|  } else {
  228|  3.18k|    return false;
  229|  3.18k|  }
  230|  3.18k|}
_ZN4absl19str_format_internal27FormatConversionCharIsFloatENS_20FormatConversionCharE:
  232|  3.18k|inline bool FormatConversionCharIsFloat(FormatConversionChar c) {
  233|  3.18k|  if (c == FormatConversionCharInternal::a ||
  ------------------
  |  Branch (233:7): [True: 0, False: 3.18k]
  ------------------
  234|  3.18k|      c == FormatConversionCharInternal::e ||
  ------------------
  |  Branch (234:7): [True: 0, False: 3.18k]
  ------------------
  235|  3.18k|      c == FormatConversionCharInternal::f ||
  ------------------
  |  Branch (235:7): [True: 0, False: 3.18k]
  ------------------
  236|  3.18k|      c == FormatConversionCharInternal::g ||
  ------------------
  |  Branch (236:7): [True: 3.18k, False: 0]
  ------------------
  237|      0|      c == FormatConversionCharInternal::A ||
  ------------------
  |  Branch (237:7): [True: 0, False: 0]
  ------------------
  238|      0|      c == FormatConversionCharInternal::E ||
  ------------------
  |  Branch (238:7): [True: 0, False: 0]
  ------------------
  239|      0|      c == FormatConversionCharInternal::F ||
  ------------------
  |  Branch (239:7): [True: 0, False: 0]
  ------------------
  240|  3.18k|      c == FormatConversionCharInternal::G) {
  ------------------
  |  Branch (240:7): [True: 0, False: 0]
  ------------------
  241|  3.18k|    return true;
  242|  3.18k|  } else {
  243|      0|    return false;
  244|      0|  }
  245|  3.18k|}
_ZZN4absl19str_format_internal14FormatSinkImpl6AppendEmcENKUlmE_clEm:
   80|  15.0k|    auto raw_append = [&](size_t count) {
   81|  15.0k|      memset(pos_, c, count);
   82|  15.0k|      pos_ += count;
   83|  15.0k|    };
_ZN4absl19str_format_internal17FormatRawSinkImplC2INSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETnPDTclsr19str_format_internalE11InvokeFlushclsr3stdE7declvalIPT_EEcvNS3_17basic_string_viewIcS6_EE_EEELPv0EEESB_:
   46|  6.36k|      : sink_(raw), write_(&FormatRawSinkImpl::Flush<T>) {}
_ZN4absl19str_format_internal17FormatRawSinkImpl5FlushINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvPvNS3_17basic_string_viewIcS6_EE:
   57|  6.36k|  static void Flush(void* r, string_view s) {
   58|  6.36k|    str_format_internal::InvokeFlush(static_cast<T*>(r), s);
   59|  6.36k|  }

_ZN4absl19str_format_internal16ConvertFloatImplEfRKNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
 2134|  1.59k|                      FormatSinkImpl *sink) {
 2135|  1.59k|  return FloatToSink(static_cast<double>(v), conv, sink);
 2136|  1.59k|}
_ZN4absl19str_format_internal16ConvertFloatImplEdRKNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
 2139|  1.59k|                      FormatSinkImpl *sink) {
 2140|  1.59k|  return FloatToSink(v, conv, sink);
 2141|  1.59k|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_115BinaryToDecimal13RunConversionENS_7uint128EiNS_11FunctionRefIFvS2_EEE:
  147|  3.14k|                            absl::FunctionRef<void(BinaryToDecimal)> f) {
  148|  3.14k|    assert(exp > 0);
  ------------------
  |  Branch (148:5): [True: 3.14k, False: 0]
  ------------------
  149|  3.14k|    assert(exp <= std::numeric_limits<MaxFloatType>::max_exponent);
  ------------------
  |  Branch (149:5): [True: 3.14k, False: 0]
  ------------------
  150|  3.14k|    static_assert(
  151|  3.14k|        StackArray::kMaxCapacity >=
  152|  3.14k|            ChunksNeeded(std::numeric_limits<MaxFloatType>::max_exponent),
  153|  3.14k|        "");
  154|       |
  155|  3.14k|    StackArray::RunWithCapacity(
  156|  3.14k|        ChunksNeeded(exp),
  157|  3.14k|        [=](absl::Span<uint32_t> input) { f(BinaryToDecimal(input, v, exp)); });
  158|  3.14k|  }
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_110StackArray15RunWithCapacityEmNS_11FunctionRefIFvNS_4SpanIjEEEEE:
   78|  3.14k|  static void RunWithCapacity(size_t capacity, Func f) {
   79|  3.14k|    assert(capacity <= kMaxCapacity);
  ------------------
  |  Branch (79:5): [True: 3.14k, False: 0]
  ------------------
   80|  3.14k|    const size_t step = (capacity + kStep - 1) / kStep;
   81|  3.14k|    assert(step <= kNumSteps);
  ------------------
  |  Branch (81:5): [True: 3.14k, False: 0]
  ------------------
   82|  3.14k|    switch (step) {
  ------------------
  |  Branch (82:13): [True: 3.14k, False: 0]
  ------------------
   83|  3.14k|      case 1:
  ------------------
  |  Branch (83:7): [True: 3.14k, False: 0]
  ------------------
   84|  3.14k|        return RunWithCapacityImpl<1>(f);
   85|      0|      case 2:
  ------------------
  |  Branch (85:7): [True: 0, False: 3.14k]
  ------------------
   86|      0|        return RunWithCapacityImpl<2>(f);
   87|      0|      case 3:
  ------------------
  |  Branch (87:7): [True: 0, False: 3.14k]
  ------------------
   88|      0|        return RunWithCapacityImpl<3>(f);
   89|      0|      case 4:
  ------------------
  |  Branch (89:7): [True: 0, False: 3.14k]
  ------------------
   90|      0|        return RunWithCapacityImpl<4>(f);
   91|      0|      case 5:
  ------------------
  |  Branch (91:7): [True: 0, False: 3.14k]
  ------------------
   92|      0|        return RunWithCapacityImpl<5>(f);
   93|  3.14k|    }
   94|       |
   95|  3.14k|    assert(false && "Invalid capacity");
  ------------------
  |  Branch (95:5): [Folded, False: 0]
  |  Branch (95:5): [True: 0, Folded]
  |  Branch (95:5): [Folded, False: 0]
  ------------------
   96|      0|  }
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_110StackArray19RunWithCapacityImplILm1EEEvNS_11FunctionRefIFvNS_4SpanIjEEEEE:
   70|  3.14k|  ABSL_ATTRIBUTE_NOINLINE static void RunWithCapacityImpl(Func f) {
   71|  3.14k|    uint32_t values[steps * kStep]{};
   72|  3.14k|    f(absl::MakeSpan(values));
   73|  3.14k|  }
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_115BinaryToDecimal12ChunksNeededEi:
  136|  6.29k|  static constexpr size_t ChunksNeeded(int exp) {
  137|       |    // We will left shift a uint128 by `exp` bits, so we need `128+exp` total
  138|       |    // bits. Round up to 32.
  139|       |    // See constructor for details about adding `10%` to the value.
  140|  6.29k|    return static_cast<size_t>(((128 + exp + 31) / 32 * 11 + 9) / 10);
  141|  6.29k|  }
float_conversion.cc:_ZZN4absl19str_format_internal12_GLOBAL__N_115BinaryToDecimal13RunConversionENS_7uint128EiNS_11FunctionRefIFvS2_EEEENKUlNS_4SpanIjEEE_clES8_:
  157|  3.14k|        [=](absl::Span<uint32_t> input) { f(BinaryToDecimal(input, v, exp)); });
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_115BinaryToDecimalC2ENS_4SpanIjEENS_7uint128Ei:
  183|  3.14k|  BinaryToDecimal(absl::Span<uint32_t> data, uint128 v, int exp) : data_(data) {
  184|       |    // We need to print the digits directly into the sink object without
  185|       |    // buffering them all first. To do this we need two things:
  186|       |    // - to know the total number of digits to do padding when necessary
  187|       |    // - to generate the decimal digits from the left.
  188|       |    //
  189|       |    // In order to do this, we do a two pass conversion.
  190|       |    // On the first pass we convert the binary representation of the value into
  191|       |    // a decimal representation in which each uint32_t chunk holds up to 9
  192|       |    // decimal digits.  In the second pass we take each decimal-holding-uint32_t
  193|       |    // value and generate the ascii decimal digits into `digits_`.
  194|       |    //
  195|       |    // The binary and decimal representations actually share the same memory
  196|       |    // region. As we go converting the chunks from binary to decimal we free
  197|       |    // them up and reuse them for the decimal representation. One caveat is that
  198|       |    // the decimal representation is around 7% less efficient in space than the
  199|       |    // binary one. We allocate an extra 10% memory to account for this. See
  200|       |    // ChunksNeeded for this calculation.
  201|  3.14k|    size_t after_chunk_index = static_cast<size_t>(exp / 32 + 1);
  202|  3.14k|    decimal_start_ = decimal_end_ = ChunksNeeded(exp);
  203|  3.14k|    const int offset = exp % 32;
  204|       |    // Left shift v by exp bits.
  205|  3.14k|    data_[after_chunk_index - 1] = static_cast<uint32_t>(v << offset);
  206|  6.71k|    for (v >>= (32 - offset); v; v >>= 32)
  ------------------
  |  Branch (206:31): [True: 3.56k, False: 3.14k]
  ------------------
  207|  3.56k|      data_[++after_chunk_index - 1] = static_cast<uint32_t>(v);
  208|       |
  209|   112k|    while (after_chunk_index > 0) {
  ------------------
  |  Branch (209:12): [True: 108k, False: 3.14k]
  ------------------
  210|       |      // While we have more than one chunk available, go in steps of 1e9.
  211|       |      // `data_[after_chunk_index - 1]` holds the highest non-zero binary chunk,
  212|       |      // so keep the variable updated.
  213|   108k|      uint32_t carry = 0;
  214|  1.90M|      for (size_t i = after_chunk_index; i > 0; --i) {
  ------------------
  |  Branch (214:42): [True: 1.80M, False: 108k]
  ------------------
  215|  1.80M|        uint64_t tmp = uint64_t{data_[i - 1]} + (uint64_t{carry} << 32);
  216|  1.80M|        data_[i - 1] = static_cast<uint32_t>(tmp / uint64_t{1000000000});
  217|  1.80M|        carry = static_cast<uint32_t>(tmp % uint64_t{1000000000});
  218|  1.80M|      }
  219|       |
  220|       |      // If the highest chunk is now empty, remove it from view.
  221|   108k|      if (data_[after_chunk_index - 1] == 0)
  ------------------
  |  Branch (221:11): [True: 100k, False: 8.78k]
  ------------------
  222|   100k|        --after_chunk_index;
  223|       |
  224|   108k|      --decimal_start_;
  225|   108k|      assert(decimal_start_ != after_chunk_index - 1);
  ------------------
  |  Branch (225:7): [True: 108k, False: 0]
  ------------------
  226|   108k|      data_[decimal_start_] = carry;
  227|   108k|    }
  228|       |
  229|       |    // Fill the first set of digits. The first chunk might not be complete, so
  230|       |    // handle differently.
  231|  13.9k|    for (uint32_t first = data_[decimal_start_++]; first != 0; first /= 10) {
  ------------------
  |  Branch (231:52): [True: 10.8k, False: 3.14k]
  ------------------
  232|  10.8k|      digits_[kDigitsPerChunk - ++size_] = first % 10 + '0';
  233|  10.8k|    }
  234|  3.14k|  }
float_conversion.cc:_ZNK4absl19str_format_internal12_GLOBAL__N_115BinaryToDecimal11TotalDigitsEv:
  160|  3.14k|  size_t TotalDigits() const {
  161|  3.14k|    return (decimal_end_ - decimal_start_) * kDigitsPerChunk +
  162|  3.14k|           CurrentDigits().size();
  163|  3.14k|  }
float_conversion.cc:_ZNK4absl19str_format_internal12_GLOBAL__N_111FormatState14ShouldPrintDotEv:
  539|     47|  bool ShouldPrintDot() const { return precision != 0 || conv.has_alt_flag(); }
  ------------------
  |  Branch (539:40): [True: 47, False: 0]
  |  Branch (539:58): [True: 0, False: 0]
  ------------------
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_119ExtraWidthToPaddingEmRKNS1_11FormatStateE:
  548|  1.57k|Padding ExtraWidthToPadding(size_t total_size, const FormatState &state) {
  549|  1.57k|  if (state.conv.width() < 0 ||
  ------------------
  |  Branch (549:7): [True: 1.57k, False: 0]
  ------------------
  550|  1.57k|      static_cast<size_t>(state.conv.width()) <= total_size) {
  ------------------
  |  Branch (550:7): [True: 0, False: 0]
  ------------------
  551|  1.57k|    return {0, 0, 0};
  552|  1.57k|  }
  553|      0|  size_t missing_chars = static_cast<size_t>(state.conv.width()) - total_size;
  554|      0|  if (state.conv.has_left_flag()) {
  ------------------
  |  Branch (554:7): [True: 0, False: 0]
  ------------------
  555|      0|    return {0, 0, missing_chars};
  556|      0|  } else if (state.conv.has_zero_flag()) {
  ------------------
  |  Branch (556:14): [True: 0, False: 0]
  ------------------
  557|      0|    return {0, missing_chars, 0};
  558|      0|  } else {
  559|      0|    return {missing_chars, 0, 0};
  560|      0|  }
  561|      0|}
float_conversion.cc:_ZNK4absl19str_format_internal12_GLOBAL__N_115BinaryToDecimal13CurrentDigitsEv:
  166|  9.25k|  absl::string_view CurrentDigits() const {
  167|  9.25k|    return absl::string_view(&digits_[kDigitsPerChunk - size_], size_);
  168|  9.25k|  }
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_115BinaryToDecimal13AdvanceDigitsEv:
  172|  2.95k|  bool AdvanceDigits() {
  173|  2.95k|    if (decimal_start_ >= decimal_end_) return false;
  ------------------
  |  Branch (173:9): [True: 0, False: 2.95k]
  ------------------
  174|       |
  175|  2.95k|    uint32_t w = data_[decimal_start_++];
  176|  29.5k|    for (size_ = 0; size_ < kDigitsPerChunk; w /= 10) {
  ------------------
  |  Branch (176:21): [True: 26.5k, False: 2.95k]
  ------------------
  177|  26.5k|      digits_[kDigitsPerChunk - ++size_] = w % 10 + '0';
  178|  26.5k|    }
  179|  2.95k|    return true;
  180|  2.95k|  }
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_17RoundUpEPc:
  354|    733|void RoundUp(char *p) {
  355|  1.27k|  while (*p == '9' || *p == '.') {
  ------------------
  |  Branch (355:10): [True: 545, False: 733]
  |  Branch (355:23): [True: 0, False: 733]
  ------------------
  356|    545|    if (*p == '9') *p = '0';
  ------------------
  |  Branch (356:9): [True: 545, False: 0]
  ------------------
  357|    545|    --p;
  358|    545|  }
  359|    733|  ++*p;
  360|    733|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_110FinalPrintERKNS1_11FormatStateENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEmmS9_:
  567|  1.60k|                absl::string_view data_postfix) {
  568|  1.60k|  if (state.conv.width() < 0) {
  ------------------
  |  Branch (568:7): [True: 1.60k, False: 0]
  ------------------
  569|       |    // No width specified. Fast-path.
  570|  1.60k|    if (state.sign_char != '\0') state.sink->Append(1, state.sign_char);
  ------------------
  |  Branch (570:9): [True: 902, False: 706]
  ------------------
  571|  1.60k|    state.sink->Append(data);
  572|  1.60k|    state.sink->Append(trailing_zeros, '0');
  573|  1.60k|    state.sink->Append(data_postfix);
  574|  1.60k|    return;
  575|  1.60k|  }
  576|       |
  577|      0|  auto padding =
  578|      0|      ExtraWidthToPadding((state.sign_char != '\0' ? 1 : 0) + data.size() +
  ------------------
  |  Branch (578:28): [True: 0, False: 0]
  ------------------
  579|      0|                              data_postfix.size() + trailing_zeros,
  580|      0|                          state);
  581|       |
  582|      0|  state.sink->Append(padding.left_spaces, ' ');
  583|      0|  if (state.sign_char != '\0') state.sink->Append(1, state.sign_char);
  ------------------
  |  Branch (583:7): [True: 0, False: 0]
  ------------------
  584|       |  // Padding in general needs to be inserted somewhere in the middle of `data`.
  585|      0|  state.sink->Append(data.substr(0, padding_offset));
  586|      0|  state.sink->Append(padding.zeros, '0');
  587|      0|  state.sink->Append(data.substr(padding_offset));
  588|      0|  state.sink->Append(trailing_zeros, '0');
  589|      0|  state.sink->Append(data_postfix);
  590|      0|  state.sink->Append(padding.right_spaces, ' ');
  591|      0|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_122FormatEPositiveExpSlowENS_7uint128EibRKNS1_11FormatStateEm:
 1549|  1.57k|                            size_t digits_to_trim = 0) {
 1550|  1.57k|  BinaryToDecimal::RunConversion(
 1551|  1.57k|      mantissa, exp, [&](BinaryToDecimal btd) {
 1552|  1.57k|        int scientific_exp = static_cast<int>(btd.TotalDigits() - 1);
 1553|  1.57k|        absl::string_view digits_view = btd.CurrentDigits();
 1554|       |
 1555|  1.57k|        size_t digits_to_go = state.precision + 1;
 1556|  1.57k|        auto [first_digit_opt, nines] = GetDigits(btd, digits_view);
 1557|  1.57k|        if (!first_digit_opt.has_value() && nines == 0) {
 1558|  1.57k|          return;
 1559|  1.57k|        }
 1560|       |
 1561|  1.57k|        int first_digit = first_digit_opt.value_or(9);
 1562|  1.57k|        if (!first_digit_opt) {
 1563|  1.57k|          --nines;
 1564|  1.57k|        }
 1565|       |
 1566|       |        // At this point we are guaranteed to have some sort of first digit
 1567|  1.57k|        bool change_to_zeros = false;
 1568|  1.57k|        if (nines + 1 >= digits_to_go) {
 1569|       |          // Everything we need to print is in the first DigitRun
 1570|  1.57k|          auto next_digit_opt = GetDigits(btd, digits_view).digit;
 1571|  1.57k|          if (nines == state.precision) {
 1572|  1.57k|            change_to_zeros = next_digit_opt.value_or(0) > 4;
 1573|  1.57k|          } else {
 1574|  1.57k|            change_to_zeros = true;
 1575|  1.57k|          }
 1576|  1.57k|          if (change_to_zeros) {
 1577|  1.57k|            if (first_digit != 9) {
 1578|  1.57k|              first_digit = first_digit + 1;
 1579|  1.57k|            } else {
 1580|  1.57k|              first_digit = 1;
 1581|  1.57k|              ++scientific_exp;
 1582|  1.57k|            }
 1583|  1.57k|          }
 1584|  1.57k|        }
 1585|       |
 1586|  1.57k|        char exp_buffer[numbers_internal::kFastToBufferSize];
 1587|  1.57k|        char* exp_buffer_end =
 1588|  1.57k|            numbers_internal::FastIntToBuffer(scientific_exp, exp_buffer);
 1589|  1.57k|        const bool print_dot =
 1590|  1.57k|            (state.precision > digits_to_trim) || state.conv.has_alt_flag();
 1591|  1.57k|        const size_t exp_size =
 1592|  1.57k|            static_cast<size_t>(exp_buffer_end - exp_buffer) + 2 +
 1593|  1.57k|            (scientific_exp < 10 ? 1 : 0);
 1594|  1.57k|        const size_t total_digits_out = 1 + (print_dot ? 1 : 0) +
 1595|  1.57k|                                        (state.precision - digits_to_trim) +
 1596|  1.57k|                                        exp_size;
 1597|       |
 1598|  1.57k|        const auto padding = ExtraWidthToPadding(
 1599|  1.57k|            total_digits_out + (state.sign_char != '\0' ? 1 : 0), state);
 1600|       |
 1601|  1.57k|        state.sink->Append(padding.left_spaces, ' ');
 1602|  1.57k|        if (state.sign_char != '\0') {
 1603|  1.57k|          state.sink->Append(1, state.sign_char);
 1604|  1.57k|        }
 1605|  1.57k|        state.sink->Append(1, static_cast<char>(first_digit + '0'));
 1606|  1.57k|        --digits_to_go;
 1607|  1.57k|        if (print_dot) {
 1608|  1.57k|          state.sink->Append(1, '.');
 1609|  1.57k|        }
 1610|       |
 1611|  1.57k|        size_t remaining_to_print = state.precision - digits_to_trim;
 1612|  1.57k|        auto append_with_trim = [&](size_t count, char c) {
 1613|  1.57k|          size_t to_append = std::min(count, remaining_to_print);
 1614|  1.57k|          if (to_append > 0) {
 1615|  1.57k|            state.sink->Append(to_append, c);
 1616|  1.57k|            remaining_to_print -= to_append;
 1617|  1.57k|          }
 1618|  1.57k|        };
 1619|       |
 1620|  1.57k|        size_t nines_to_append = std::min(digits_to_go, nines);
 1621|  1.57k|        append_with_trim(nines_to_append, change_to_zeros ? '0' : '9');
 1622|  1.57k|        digits_to_go -= nines_to_append;
 1623|       |
 1624|  1.57k|        while (digits_to_go > 0) {
 1625|  1.57k|          auto [digit_opt, curr_nines] = GetDigits(btd, digits_view);
 1626|  1.57k|          if (!digit_opt.has_value()) break;
 1627|  1.57k|          int digit = *digit_opt;
 1628|  1.57k|          if (curr_nines + 1 < digits_to_go) {
 1629|  1.57k|            append_with_trim(1, static_cast<char>(digit + '0'));
 1630|  1.57k|            append_with_trim(curr_nines, '9');
 1631|  1.57k|            digits_to_go -= curr_nines + 1;
 1632|  1.57k|          } else {
 1633|  1.57k|            bool need_round_up = false;
 1634|  1.57k|            auto next_digit_opt = GetDigits(btd, digits_view).digit;
 1635|  1.57k|            if (digits_to_go == 1) {
 1636|  1.57k|              need_round_up = curr_nines > 0 || next_digit_opt > 4;
 1637|  1.57k|            } else if (digits_to_go == curr_nines + 1) {
 1638|       |              // Only round if next digit is > 4
 1639|  1.57k|              need_round_up = next_digit_opt.value_or(0) > 4;
 1640|  1.57k|            } else {
 1641|       |              // we know we need to round since nine is after precision ends
 1642|  1.57k|              need_round_up = true;
 1643|  1.57k|            }
 1644|  1.57k|            append_with_trim(1, static_cast<char>(digit + need_round_up + '0'));
 1645|  1.57k|            append_with_trim(digits_to_go - 1, need_round_up ? '0' : '9');
 1646|  1.57k|            digits_to_go = 0;
 1647|  1.57k|          }
 1648|  1.57k|        }
 1649|       |
 1650|  1.57k|        if (digits_to_go > 0) {
 1651|  1.57k|          append_with_trim(digits_to_go, '0');
 1652|  1.57k|        }
 1653|       |
 1654|  1.57k|        state.sink->Append(1, uppercase ? 'E' : 'e');
 1655|  1.57k|        state.sink->Append(1, scientific_exp >= 0 ? '+' : '-');
 1656|  1.57k|        if (scientific_exp < 10) {
 1657|  1.57k|          state.sink->Append(1, '0');
 1658|  1.57k|        }
 1659|  1.57k|        state.sink->Append(absl::string_view(
 1660|  1.57k|            exp_buffer, static_cast<size_t>(exp_buffer_end - exp_buffer)));
 1661|  1.57k|        state.sink->Append(padding.right_spaces, ' ');
 1662|  1.57k|      });
 1663|  1.57k|}
float_conversion.cc:_ZZN4absl19str_format_internal12_GLOBAL__N_122FormatEPositiveExpSlowENS_7uint128EibRKNS1_11FormatStateEmENK3$_0clENS1_15BinaryToDecimalE:
 1551|  1.57k|      mantissa, exp, [&](BinaryToDecimal btd) {
 1552|  1.57k|        int scientific_exp = static_cast<int>(btd.TotalDigits() - 1);
 1553|  1.57k|        absl::string_view digits_view = btd.CurrentDigits();
 1554|       |
 1555|  1.57k|        size_t digits_to_go = state.precision + 1;
 1556|  1.57k|        auto [first_digit_opt, nines] = GetDigits(btd, digits_view);
 1557|  1.57k|        if (!first_digit_opt.has_value() && nines == 0) {
  ------------------
  |  Branch (1557:13): [True: 77, False: 1.49k]
  |  Branch (1557:45): [True: 0, False: 77]
  ------------------
 1558|      0|          return;
 1559|      0|        }
 1560|       |
 1561|  1.57k|        int first_digit = first_digit_opt.value_or(9);
 1562|  1.57k|        if (!first_digit_opt) {
  ------------------
  |  Branch (1562:13): [True: 77, False: 1.49k]
  ------------------
 1563|     77|          --nines;
 1564|     77|        }
 1565|       |
 1566|       |        // At this point we are guaranteed to have some sort of first digit
 1567|  1.57k|        bool change_to_zeros = false;
 1568|  1.57k|        if (nines + 1 >= digits_to_go) {
  ------------------
  |  Branch (1568:13): [True: 100, False: 1.47k]
  ------------------
 1569|       |          // Everything we need to print is in the first DigitRun
 1570|    100|          auto next_digit_opt = GetDigits(btd, digits_view).digit;
 1571|    100|          if (nines == state.precision) {
  ------------------
  |  Branch (1571:15): [True: 75, False: 25]
  ------------------
 1572|     75|            change_to_zeros = next_digit_opt.value_or(0) > 4;
 1573|     75|          } else {
 1574|     25|            change_to_zeros = true;
 1575|     25|          }
 1576|    100|          if (change_to_zeros) {
  ------------------
  |  Branch (1576:15): [True: 94, False: 6]
  ------------------
 1577|     94|            if (first_digit != 9) {
  ------------------
  |  Branch (1577:17): [True: 85, False: 9]
  ------------------
 1578|     85|              first_digit = first_digit + 1;
 1579|     85|            } else {
 1580|      9|              first_digit = 1;
 1581|      9|              ++scientific_exp;
 1582|      9|            }
 1583|     94|          }
 1584|    100|        }
 1585|       |
 1586|  1.57k|        char exp_buffer[numbers_internal::kFastToBufferSize];
 1587|  1.57k|        char* exp_buffer_end =
 1588|  1.57k|            numbers_internal::FastIntToBuffer(scientific_exp, exp_buffer);
 1589|  1.57k|        const bool print_dot =
 1590|  1.57k|            (state.precision > digits_to_trim) || state.conv.has_alt_flag();
  ------------------
  |  Branch (1590:13): [True: 1.47k, False: 103]
  |  Branch (1590:51): [True: 0, False: 103]
  ------------------
 1591|  1.57k|        const size_t exp_size =
 1592|  1.57k|            static_cast<size_t>(exp_buffer_end - exp_buffer) + 2 +
 1593|  1.57k|            (scientific_exp < 10 ? 1 : 0);
  ------------------
  |  Branch (1593:14): [True: 0, False: 1.57k]
  ------------------
 1594|  1.57k|        const size_t total_digits_out = 1 + (print_dot ? 1 : 0) +
  ------------------
  |  Branch (1594:46): [True: 1.47k, False: 103]
  ------------------
 1595|  1.57k|                                        (state.precision - digits_to_trim) +
 1596|  1.57k|                                        exp_size;
 1597|       |
 1598|  1.57k|        const auto padding = ExtraWidthToPadding(
 1599|  1.57k|            total_digits_out + (state.sign_char != '\0' ? 1 : 0), state);
  ------------------
  |  Branch (1599:33): [True: 967, False: 607]
  ------------------
 1600|       |
 1601|  1.57k|        state.sink->Append(padding.left_spaces, ' ');
 1602|  1.57k|        if (state.sign_char != '\0') {
  ------------------
  |  Branch (1602:13): [True: 967, False: 607]
  ------------------
 1603|    967|          state.sink->Append(1, state.sign_char);
 1604|    967|        }
 1605|  1.57k|        state.sink->Append(1, static_cast<char>(first_digit + '0'));
 1606|  1.57k|        --digits_to_go;
 1607|  1.57k|        if (print_dot) {
  ------------------
  |  Branch (1607:13): [True: 1.47k, False: 103]
  ------------------
 1608|  1.47k|          state.sink->Append(1, '.');
 1609|  1.47k|        }
 1610|       |
 1611|  1.57k|        size_t remaining_to_print = state.precision - digits_to_trim;
 1612|  1.57k|        auto append_with_trim = [&](size_t count, char c) {
 1613|  1.57k|          size_t to_append = std::min(count, remaining_to_print);
 1614|  1.57k|          if (to_append > 0) {
 1615|  1.57k|            state.sink->Append(to_append, c);
 1616|  1.57k|            remaining_to_print -= to_append;
 1617|  1.57k|          }
 1618|  1.57k|        };
 1619|       |
 1620|  1.57k|        size_t nines_to_append = std::min(digits_to_go, nines);
 1621|  1.57k|        append_with_trim(nines_to_append, change_to_zeros ? '0' : '9');
  ------------------
  |  Branch (1621:43): [True: 94, False: 1.48k]
  ------------------
 1622|  1.57k|        digits_to_go -= nines_to_append;
 1623|       |
 1624|  7.55k|        while (digits_to_go > 0) {
  ------------------
  |  Branch (1624:16): [True: 5.97k, False: 1.57k]
  ------------------
 1625|  5.97k|          auto [digit_opt, curr_nines] = GetDigits(btd, digits_view);
 1626|  5.97k|          if (!digit_opt.has_value()) break;
  ------------------
  |  Branch (1626:15): [True: 0, False: 5.97k]
  ------------------
 1627|  5.97k|          int digit = *digit_opt;
 1628|  5.97k|          if (curr_nines + 1 < digits_to_go) {
  ------------------
  |  Branch (1628:15): [True: 4.50k, False: 1.47k]
  ------------------
 1629|  4.50k|            append_with_trim(1, static_cast<char>(digit + '0'));
 1630|  4.50k|            append_with_trim(curr_nines, '9');
 1631|  4.50k|            digits_to_go -= curr_nines + 1;
 1632|  4.50k|          } else {
 1633|  1.47k|            bool need_round_up = false;
 1634|  1.47k|            auto next_digit_opt = GetDigits(btd, digits_view).digit;
 1635|  1.47k|            if (digits_to_go == 1) {
  ------------------
  |  Branch (1635:17): [True: 958, False: 516]
  ------------------
 1636|    958|              need_round_up = curr_nines > 0 || next_digit_opt > 4;
  ------------------
  |  Branch (1636:31): [True: 103, False: 855]
  |  Branch (1636:49): [True: 316, False: 539]
  ------------------
 1637|    958|            } else if (digits_to_go == curr_nines + 1) {
  ------------------
  |  Branch (1637:24): [True: 498, False: 18]
  ------------------
 1638|       |              // Only round if next digit is > 4
 1639|    498|              need_round_up = next_digit_opt.value_or(0) > 4;
 1640|    498|            } else {
 1641|       |              // we know we need to round since nine is after precision ends
 1642|     18|              need_round_up = true;
 1643|     18|            }
 1644|  1.47k|            append_with_trim(1, static_cast<char>(digit + need_round_up + '0'));
 1645|  1.47k|            append_with_trim(digits_to_go - 1, need_round_up ? '0' : '9');
  ------------------
  |  Branch (1645:48): [True: 487, False: 987]
  ------------------
 1646|  1.47k|            digits_to_go = 0;
 1647|  1.47k|          }
 1648|  5.97k|        }
 1649|       |
 1650|  1.57k|        if (digits_to_go > 0) {
  ------------------
  |  Branch (1650:13): [True: 0, False: 1.57k]
  ------------------
 1651|      0|          append_with_trim(digits_to_go, '0');
 1652|      0|        }
 1653|       |
 1654|  1.57k|        state.sink->Append(1, uppercase ? 'E' : 'e');
  ------------------
  |  Branch (1654:31): [True: 0, False: 1.57k]
  ------------------
 1655|  1.57k|        state.sink->Append(1, scientific_exp >= 0 ? '+' : '-');
  ------------------
  |  Branch (1655:31): [True: 1.57k, False: 0]
  ------------------
 1656|  1.57k|        if (scientific_exp < 10) {
  ------------------
  |  Branch (1656:13): [True: 0, False: 1.57k]
  ------------------
 1657|      0|          state.sink->Append(1, '0');
 1658|      0|        }
 1659|  1.57k|        state.sink->Append(absl::string_view(
 1660|  1.57k|            exp_buffer, static_cast<size_t>(exp_buffer_end - exp_buffer)));
 1661|  1.57k|        state.sink->Append(padding.right_spaces, ' ');
 1662|  1.57k|      });
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_19GetDigitsERNS1_15BinaryToDecimalERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
 1236|  18.2k|DigitRun GetDigits(BinaryToDecimal& btd, absl::string_view& digits_view) {
 1237|  18.2k|  auto peek_digit = [&]() -> std::optional<int> {
 1238|  18.2k|    if (digits_view.empty()) {
 1239|  18.2k|      if (!btd.AdvanceDigits()) return std::nullopt;
 1240|  18.2k|      digits_view = btd.CurrentDigits();
 1241|  18.2k|    }
 1242|  18.2k|    return digits_view.front() - '0';
 1243|  18.2k|  };
 1244|       |
 1245|  18.2k|  auto digit_before_nines = GetOneDigit(btd, digits_view);
 1246|  18.2k|  if (!digit_before_nines.has_value()) return {std::nullopt, 0};
  ------------------
  |  Branch (1246:7): [True: 0, False: 18.2k]
  ------------------
 1247|       |
 1248|  18.2k|  auto next_digit = peek_digit();
 1249|  18.2k|  size_t num_nines = 0;
 1250|  22.8k|  while (next_digit == 9) {
  ------------------
  |  Branch (1250:10): [True: 4.58k, False: 18.2k]
  ------------------
 1251|       |    // consume the 9
 1252|  4.58k|    GetOneDigit(btd, digits_view);
 1253|  4.58k|    ++num_nines;
 1254|  4.58k|    next_digit = peek_digit();
 1255|  4.58k|  }
 1256|  18.2k|  return digit_before_nines == 9 ? DigitRun{std::nullopt, num_nines + 1}
  ------------------
  |  Branch (1256:10): [True: 154, False: 18.0k]
  ------------------
 1257|  18.2k|                                 : DigitRun{digit_before_nines, num_nines};
 1258|  18.2k|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_111GetOneDigitERNS1_15BinaryToDecimalERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
 1222|  22.8k|                               absl::string_view& digits_view) {
 1223|  22.8k|  if (digits_view.empty() && !btd.AdvanceDigits()) {
  ------------------
  |  Branch (1223:7): [True: 0, False: 22.8k]
  |  Branch (1223:30): [True: 0, False: 0]
  ------------------
 1224|      0|    return std::nullopt;
 1225|      0|  }
 1226|  22.8k|  char d = digits_view.front();
 1227|  22.8k|  digits_view.remove_prefix(1);
 1228|  22.8k|  return d - '0';
 1229|  22.8k|}
float_conversion.cc:_ZZN4absl19str_format_internal12_GLOBAL__N_19GetDigitsERNS1_15BinaryToDecimalERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEENK3$_0clEv:
 1237|  22.8k|  auto peek_digit = [&]() -> std::optional<int> {
 1238|  22.8k|    if (digits_view.empty()) {
  ------------------
  |  Branch (1238:9): [True: 2.95k, False: 19.8k]
  ------------------
 1239|  2.95k|      if (!btd.AdvanceDigits()) return std::nullopt;
  ------------------
  |  Branch (1239:11): [True: 0, False: 2.95k]
  ------------------
 1240|  2.95k|      digits_view = btd.CurrentDigits();
 1241|  2.95k|    }
 1242|  22.8k|    return digits_view.front() - '0';
 1243|  22.8k|  };
float_conversion.cc:_ZZZN4absl19str_format_internal12_GLOBAL__N_122FormatEPositiveExpSlowENS_7uint128EibRKNS1_11FormatStateEmENK3$_0clENS1_15BinaryToDecimalEENKUlmcE_clEmc:
 1612|  13.5k|        auto append_with_trim = [&](size_t count, char c) {
 1613|  13.5k|          size_t to_append = std::min(count, remaining_to_print);
 1614|  13.5k|          if (to_append > 0) {
  ------------------
  |  Branch (1614:15): [True: 7.02k, False: 6.50k]
  ------------------
 1615|  7.02k|            state.sink->Append(to_append, c);
 1616|  7.02k|            remaining_to_print -= to_append;
 1617|  7.02k|          }
 1618|  13.5k|        };
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_111FloatToSinkIdEEbT_RKNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
 2050|  3.18k|                 FormatSinkImpl *sink) {
 2051|       |  // Print the sign or the sign column.
 2052|  3.18k|  Float abs_v = v;
 2053|  3.18k|  char sign_char = 0;
 2054|  3.18k|  if (std::signbit(abs_v)) {
  ------------------
  |  Branch (2054:7): [True: 1.86k, False: 1.31k]
  ------------------
 2055|  1.86k|    sign_char = '-';
 2056|  1.86k|    abs_v = -abs_v;
 2057|  1.86k|  } else if (conv.has_show_pos_flag()) {
  ------------------
  |  Branch (2057:14): [True: 0, False: 1.31k]
  ------------------
 2058|      0|    sign_char = '+';
 2059|  1.31k|  } else if (conv.has_sign_col_flag()) {
  ------------------
  |  Branch (2059:14): [True: 0, False: 1.31k]
  ------------------
 2060|      0|    sign_char = ' ';
 2061|      0|  }
 2062|       |
 2063|       |  // Print nan/inf.
 2064|  3.18k|  if (ConvertNonNumericFloats(sign_char, abs_v, conv, sink)) {
  ------------------
  |  Branch (2064:7): [True: 0, False: 3.18k]
  ------------------
 2065|      0|    return true;
 2066|      0|  }
 2067|       |
 2068|  3.18k|  size_t precision =
 2069|  3.18k|      conv.precision() < 0 ? 6 : static_cast<size_t>(conv.precision());
  ------------------
  |  Branch (2069:7): [True: 3.18k, False: 0]
  ------------------
 2070|       |
 2071|  3.18k|  auto decomposed = Decompose(abs_v);
 2072|       |
 2073|  3.18k|  FormatConversionChar c = conv.conversion_char();
 2074|       |
 2075|  3.18k|  if (c == FormatConversionCharInternal::f ||
  ------------------
  |  Branch (2075:7): [True: 0, False: 3.18k]
  ------------------
 2076|  3.18k|      c == FormatConversionCharInternal::F) {
  ------------------
  |  Branch (2076:7): [True: 0, False: 3.18k]
  ------------------
 2077|      0|    FormatF(decomposed.mantissa, decomposed.exponent,
 2078|      0|            {sign_char, precision, conv, sink});
 2079|      0|    return true;
 2080|  3.18k|  } else if (c == FormatConversionCharInternal::e ||
  ------------------
  |  Branch (2080:14): [True: 0, False: 3.18k]
  ------------------
 2081|  3.18k|             c == FormatConversionCharInternal::E) {
  ------------------
  |  Branch (2081:14): [True: 0, False: 3.18k]
  ------------------
 2082|      0|    FormatE(decomposed.mantissa, decomposed.exponent,
 2083|      0|            FormatConversionCharIsUpper(conv.conversion_char()),
 2084|      0|            {sign_char, precision, conv, sink});
 2085|      0|    return true;
 2086|  3.18k|  } else if (c == FormatConversionCharInternal::g ||
  ------------------
  |  Branch (2086:14): [True: 3.18k, False: 0]
  ------------------
 2087|  3.18k|             c == FormatConversionCharInternal::G) {
  ------------------
  |  Branch (2087:14): [True: 0, False: 0]
  ------------------
 2088|  3.18k|    precision = std::max(precision, size_t{1}) - 1;
 2089|  3.18k|    constexpr int input_bits = sizeof(decomposed.mantissa) * 8;
 2090|  3.18k|    const int total_bits =
 2091|  3.18k|        input_bits - LeadingZeros(decomposed.mantissa) + decomposed.exponent;
 2092|  3.18k|    if (decomposed.exponent >= 0 && total_bits > 128) {
  ------------------
  |  Branch (2092:9): [True: 3.13k, False: 47]
  |  Branch (2092:37): [True: 1.57k, False: 1.56k]
  ------------------
 2093|  1.57k|      FormatGPositiveExpSlow(
 2094|  1.57k|          decomposed.mantissa, decomposed.exponent,
 2095|  1.57k|          FormatConversionCharIsUpper(conv.conversion_char()),
 2096|  1.57k|          {sign_char, precision, conv, sink});
 2097|  1.57k|      return true;
 2098|  1.60k|    } else if (decomposed.exponent < -128) {
  ------------------
  |  Branch (2098:16): [True: 0, False: 1.60k]
  ------------------
 2099|      0|      FormatGNegativeExpSlow(
 2100|      0|          decomposed.mantissa, decomposed.exponent,
 2101|      0|          FormatConversionCharIsUpper(conv.conversion_char()),
 2102|      0|          {sign_char, precision, conv, sink});
 2103|      0|      return true;
 2104|      0|    }
 2105|  1.60k|    FormatGFast(decomposed.mantissa, decomposed.exponent,
 2106|  1.60k|                FormatConversionCharIsUpper(conv.conversion_char()),
 2107|  1.60k|                {sign_char, precision, conv, sink});
 2108|  1.60k|    return true;
 2109|  3.18k|  } else if (c == FormatConversionCharInternal::a ||
  ------------------
  |  Branch (2109:14): [True: 0, False: 0]
  ------------------
 2110|      0|             c == FormatConversionCharInternal::A) {
  ------------------
  |  Branch (2110:14): [True: 0, False: 0]
  ------------------
 2111|      0|    bool uppercase = (c == FormatConversionCharInternal::A);
 2112|      0|    FormatA(HexFloatTypeParams(Float{}), decomposed.mantissa,
 2113|      0|            decomposed.exponent, uppercase, {sign_char, precision, conv, sink});
 2114|      0|    return true;
 2115|      0|  } else {
 2116|      0|    return false;
 2117|      0|  }
 2118|  3.18k|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_123ConvertNonNumericFloatsIdEEbcT_RKNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
 1122|  3.18k|                             FormatSinkImpl *sink) {
 1123|  3.18k|  char text[4], *ptr = text;
 1124|  3.18k|  if (sign_char != '\0') *ptr++ = sign_char;
  ------------------
  |  Branch (1124:7): [True: 1.86k, False: 1.31k]
  ------------------
 1125|  3.18k|  if (std::isnan(v)) {
  ------------------
  |  Branch (1125:7): [True: 0, False: 3.18k]
  ------------------
 1126|      0|    ptr = std::copy_n(
 1127|      0|        FormatConversionCharIsUpper(conv.conversion_char()) ? "NAN" : "nan", 3,
  ------------------
  |  Branch (1127:9): [True: 0, False: 0]
  ------------------
 1128|      0|        ptr);
 1129|  3.18k|  } else if (std::isinf(v)) {
  ------------------
  |  Branch (1129:14): [True: 0, False: 3.18k]
  ------------------
 1130|      0|    ptr = std::copy_n(
 1131|      0|        FormatConversionCharIsUpper(conv.conversion_char()) ? "INF" : "inf", 3,
  ------------------
  |  Branch (1131:9): [True: 0, False: 0]
  ------------------
 1132|      0|        ptr);
 1133|  3.18k|  } else {
 1134|  3.18k|    return false;
 1135|  3.18k|  }
 1136|       |
 1137|      0|  return sink->PutPaddedString(
 1138|      0|      string_view(text, static_cast<size_t>(ptr - text)), conv.width(), -1,
 1139|      0|      conv.has_left_flag());
 1140|  3.18k|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_19DecomposeIdEENS1_10DecomposedIT_EES4_:
 1189|  3.18k|Decomposed<Float> Decompose(Float v) {
 1190|  3.18k|  int exp;
 1191|  3.18k|  Float m = std::frexp(v, &exp);
 1192|  3.18k|  m = std::ldexp(m, std::numeric_limits<Float>::digits);
 1193|  3.18k|  exp -= std::numeric_limits<Float>::digits;
 1194|       |
 1195|  3.18k|  return {static_cast<typename Decomposed<Float>::MantissaType>(m), exp};
 1196|  3.18k|}
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_112LeadingZerosEm:
  344|  4.74k|int LeadingZeros(uint64_t v) { return countl_zero(v); }
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_122FormatGPositiveExpSlowImEEvT_ibRKNS1_11FormatStateE:
 1961|  1.57k|                            const FormatState& state) {
 1962|  1.57k|  BinaryToDecimal::RunConversion(mantissa, exp, [&](BinaryToDecimal btd) {
 1963|  1.57k|    int scientific_exp = static_cast<int>(btd.TotalDigits()) - 1;
 1964|  1.57k|    absl::string_view digits = btd.CurrentDigits();
 1965|  1.57k|    size_t digits_to_go = state.precision + 1;
 1966|  1.57k|    auto [first_digit_opt, nines] = GetDigits(btd, digits);
 1967|  1.57k|    int first_digit = first_digit_opt.value_or(9);
 1968|  1.57k|    if (!first_digit_opt) {
 1969|  1.57k|      --nines;
 1970|  1.57k|    }
 1971|       |    // At this point we are guaranteed to have some sort of first digit
 1972|  1.57k|    bool change_to_zeros = false;
 1973|  1.57k|    size_t num_trailing_zeros = 0;
 1974|  1.57k|    if (nines + 1 >= digits_to_go) {
 1975|       |      // Everything we need to print is in the first DigitRun
 1976|  1.57k|      auto next_digit_opt = GetDigits(btd, digits).digit;
 1977|  1.57k|      if (nines == state.precision) {
 1978|  1.57k|        change_to_zeros = next_digit_opt.value_or(0) > 4;
 1979|  1.57k|      } else {
 1980|  1.57k|        change_to_zeros = true;
 1981|  1.57k|      }
 1982|  1.57k|      if (change_to_zeros) {
 1983|  1.57k|        if (first_digit != 9) {
 1984|  1.57k|          first_digit = first_digit + 1;
 1985|  1.57k|        } else {
 1986|  1.57k|          first_digit = 1;
 1987|  1.57k|          ++scientific_exp;
 1988|  1.57k|        }
 1989|  1.57k|        num_trailing_zeros = state.precision;
 1990|  1.57k|      }
 1991|  1.57k|    }
 1992|  1.57k|    if (state.conv.has_alt_flag()) {
 1993|  1.57k|      num_trailing_zeros = 0;
 1994|  1.57k|    }
 1995|       |    // At this point the number of trailing zeros is not covered by the first
 1996|       |    // DigitRun
 1997|  1.57k|    if (!state.conv.has_alt_flag() && !num_trailing_zeros) {
 1998|  1.57k|      num_trailing_zeros = first_digit == 0;
 1999|  1.57k|      digits_to_go -= std::min(digits_to_go, nines + 1);
 2000|  1.57k|      while (digits_to_go > 0) {
 2001|  1.57k|        auto [digit_opt, curr_nines] = GetDigits(btd, digits);
 2002|  1.57k|        if (!digit_opt.has_value()) {
 2003|  1.57k|          break;
 2004|  1.57k|        }
 2005|  1.57k|        if (curr_nines + 1 < digits_to_go) {
 2006|  1.57k|          int digit = *digit_opt;
 2007|       |          // If the previous one was a 0 we are too
 2008|  1.57k|          if (digit == 0 && curr_nines == 0) {
 2009|  1.57k|            ++num_trailing_zeros;
 2010|  1.57k|            --digits_to_go;
 2011|  1.57k|          } else {
 2012|  1.57k|            num_trailing_zeros = 0;
 2013|  1.57k|            --digits_to_go;
 2014|  1.57k|            digits_to_go -= std::min(digits_to_go, curr_nines);
 2015|  1.57k|          }
 2016|  1.57k|        } else {
 2017|  1.57k|          auto next_digit_opt = GetDigits(btd, digits).digit;
 2018|  1.57k|          if (digits_to_go == 1) {
 2019|  1.57k|            if (*digit_opt == 0) {
 2020|  1.57k|              if (curr_nines || next_digit_opt > 4) {
 2021|  1.57k|                num_trailing_zeros = 0;
 2022|  1.57k|              } else {
 2023|  1.57k|                ++num_trailing_zeros;
 2024|  1.57k|              }
 2025|  1.57k|            } else {
 2026|  1.57k|              num_trailing_zeros = 0;
 2027|  1.57k|            }
 2028|  1.57k|          } else if (digits_to_go == curr_nines + 1) {
 2029|  1.57k|            num_trailing_zeros = next_digit_opt > 4 ? digits_to_go - 1 : 0;
 2030|  1.57k|          } else {
 2031|  1.57k|            num_trailing_zeros = digits_to_go - 1;
 2032|  1.57k|          }
 2033|  1.57k|          digits_to_go = 0;
 2034|  1.57k|        }
 2035|  1.57k|      }
 2036|  1.57k|    }
 2037|  1.57k|    assert(scientific_exp >= 0);
 2038|       |    // By this point the exponent is accurate
 2039|  1.57k|    if (static_cast<size_t>(scientific_exp) > state.precision) {
 2040|  1.57k|      FormatEPositiveExpSlow(mantissa, exp, uppercase, state,
 2041|  1.57k|                             num_trailing_zeros);
 2042|  1.57k|    } else {
 2043|  1.57k|      FormatFPositiveExpSlow(mantissa, exp, state, !state.conv.has_alt_flag());
 2044|  1.57k|    }
 2045|  1.57k|  });
 2046|  1.57k|}
float_conversion.cc:_ZZN4absl19str_format_internal12_GLOBAL__N_122FormatGPositiveExpSlowImEEvT_ibRKNS1_11FormatStateEENKUlNS1_15BinaryToDecimalEE_clES7_:
 1962|  1.57k|  BinaryToDecimal::RunConversion(mantissa, exp, [&](BinaryToDecimal btd) {
 1963|  1.57k|    int scientific_exp = static_cast<int>(btd.TotalDigits()) - 1;
 1964|  1.57k|    absl::string_view digits = btd.CurrentDigits();
 1965|  1.57k|    size_t digits_to_go = state.precision + 1;
 1966|  1.57k|    auto [first_digit_opt, nines] = GetDigits(btd, digits);
 1967|  1.57k|    int first_digit = first_digit_opt.value_or(9);
 1968|  1.57k|    if (!first_digit_opt) {
  ------------------
  |  Branch (1968:9): [True: 77, False: 1.49k]
  ------------------
 1969|     77|      --nines;
 1970|     77|    }
 1971|       |    // At this point we are guaranteed to have some sort of first digit
 1972|  1.57k|    bool change_to_zeros = false;
 1973|  1.57k|    size_t num_trailing_zeros = 0;
 1974|  1.57k|    if (nines + 1 >= digits_to_go) {
  ------------------
  |  Branch (1974:9): [True: 100, False: 1.47k]
  ------------------
 1975|       |      // Everything we need to print is in the first DigitRun
 1976|    100|      auto next_digit_opt = GetDigits(btd, digits).digit;
 1977|    100|      if (nines == state.precision) {
  ------------------
  |  Branch (1977:11): [True: 75, False: 25]
  ------------------
 1978|     75|        change_to_zeros = next_digit_opt.value_or(0) > 4;
 1979|     75|      } else {
 1980|     25|        change_to_zeros = true;
 1981|     25|      }
 1982|    100|      if (change_to_zeros) {
  ------------------
  |  Branch (1982:11): [True: 94, False: 6]
  ------------------
 1983|     94|        if (first_digit != 9) {
  ------------------
  |  Branch (1983:13): [True: 85, False: 9]
  ------------------
 1984|     85|          first_digit = first_digit + 1;
 1985|     85|        } else {
 1986|      9|          first_digit = 1;
 1987|      9|          ++scientific_exp;
 1988|      9|        }
 1989|     94|        num_trailing_zeros = state.precision;
 1990|     94|      }
 1991|    100|    }
 1992|  1.57k|    if (state.conv.has_alt_flag()) {
  ------------------
  |  Branch (1992:9): [True: 0, False: 1.57k]
  ------------------
 1993|      0|      num_trailing_zeros = 0;
 1994|      0|    }
 1995|       |    // At this point the number of trailing zeros is not covered by the first
 1996|       |    // DigitRun
 1997|  1.57k|    if (!state.conv.has_alt_flag() && !num_trailing_zeros) {
  ------------------
  |  Branch (1997:9): [True: 1.57k, False: 0]
  |  Branch (1997:39): [True: 1.48k, False: 94]
  ------------------
 1998|  1.48k|      num_trailing_zeros = first_digit == 0;
 1999|  1.48k|      digits_to_go -= std::min(digits_to_go, nines + 1);
 2000|  7.45k|      while (digits_to_go > 0) {
  ------------------
  |  Branch (2000:14): [True: 5.97k, False: 1.48k]
  ------------------
 2001|  5.97k|        auto [digit_opt, curr_nines] = GetDigits(btd, digits);
 2002|  5.97k|        if (!digit_opt.has_value()) {
  ------------------
  |  Branch (2002:13): [True: 0, False: 5.97k]
  ------------------
 2003|      0|          break;
 2004|      0|        }
 2005|  5.97k|        if (curr_nines + 1 < digits_to_go) {
  ------------------
  |  Branch (2005:13): [True: 4.50k, False: 1.47k]
  ------------------
 2006|  4.50k|          int digit = *digit_opt;
 2007|       |          // If the previous one was a 0 we are too
 2008|  4.50k|          if (digit == 0 && curr_nines == 0) {
  ------------------
  |  Branch (2008:15): [True: 412, False: 4.09k]
  |  Branch (2008:29): [True: 372, False: 40]
  ------------------
 2009|    372|            ++num_trailing_zeros;
 2010|    372|            --digits_to_go;
 2011|  4.13k|          } else {
 2012|  4.13k|            num_trailing_zeros = 0;
 2013|  4.13k|            --digits_to_go;
 2014|  4.13k|            digits_to_go -= std::min(digits_to_go, curr_nines);
 2015|  4.13k|          }
 2016|  4.50k|        } else {
 2017|  1.47k|          auto next_digit_opt = GetDigits(btd, digits).digit;
 2018|  1.47k|          if (digits_to_go == 1) {
  ------------------
  |  Branch (2018:15): [True: 958, False: 516]
  ------------------
 2019|    958|            if (*digit_opt == 0) {
  ------------------
  |  Branch (2019:17): [True: 179, False: 779]
  ------------------
 2020|    179|              if (curr_nines || next_digit_opt > 4) {
  ------------------
  |  Branch (2020:19): [True: 14, False: 165]
  |  Branch (2020:19): [True: 47, False: 132]
  |  Branch (2020:33): [True: 33, False: 132]
  ------------------
 2021|     47|                num_trailing_zeros = 0;
 2022|    132|              } else {
 2023|    132|                ++num_trailing_zeros;
 2024|    132|              }
 2025|    779|            } else {
 2026|    779|              num_trailing_zeros = 0;
 2027|    779|            }
 2028|    958|          } else if (digits_to_go == curr_nines + 1) {
  ------------------
  |  Branch (2028:22): [True: 498, False: 18]
  ------------------
 2029|    498|            num_trailing_zeros = next_digit_opt > 4 ? digits_to_go - 1 : 0;
  ------------------
  |  Branch (2029:34): [True: 50, False: 448]
  ------------------
 2030|    498|          } else {
 2031|     18|            num_trailing_zeros = digits_to_go - 1;
 2032|     18|          }
 2033|  1.47k|          digits_to_go = 0;
 2034|  1.47k|        }
 2035|  5.97k|      }
 2036|  1.48k|    }
 2037|  1.57k|    assert(scientific_exp >= 0);
  ------------------
  |  Branch (2037:5): [True: 1.57k, False: 0]
  ------------------
 2038|       |    // By this point the exponent is accurate
 2039|  1.57k|    if (static_cast<size_t>(scientific_exp) > state.precision) {
  ------------------
  |  Branch (2039:9): [True: 1.57k, False: 0]
  ------------------
 2040|  1.57k|      FormatEPositiveExpSlow(mantissa, exp, uppercase, state,
 2041|  1.57k|                             num_trailing_zeros);
 2042|  1.57k|    } else {
 2043|      0|      FormatFPositiveExpSlow(mantissa, exp, state, !state.conv.has_alt_flag());
 2044|      0|    }
 2045|  1.57k|  });
float_conversion.cc:_ZN4absl19str_format_internal12_GLOBAL__N_111FormatGFastImEEvT_ibRKNS1_11FormatStateE:
 1667|  1.60k|void FormatGFast(Int v, int exp, bool uppercase, const FormatState& state) {
 1668|  1.60k|  if (!v) {
  ------------------
  |  Branch (1668:7): [True: 47, False: 1.56k]
  ------------------
 1669|     47|    absl::string_view mantissa_str =
 1670|     47|        state.ShouldPrintDot() && state.conv.has_alt_flag() ? "0." : "0";
  ------------------
  |  Branch (1670:9): [True: 47, False: 0]
  |  Branch (1670:35): [True: 0, False: 47]
  ------------------
 1671|     47|    FinalPrint(state, mantissa_str, 0,
 1672|     47|               state.conv.has_alt_flag() * state.precision, "");
 1673|     47|    return;
 1674|     47|  }
 1675|  1.56k|  constexpr int kInputBits = sizeof(Int) * 8;
 1676|  1.56k|  constexpr int kMaxFractionalDigits = 128;
 1677|       |  // We need enough headroom to the left of our starting pointer to support
 1678|       |  // a potential prefix shift for values between 1e-1 and 1e-4.
 1679|       |  // The prefix "0.000" is 5 chars, plus potential rounding carry (1 char).
 1680|  1.56k|  constexpr int kHeadroom = 32;
 1681|  1.56k|  constexpr int kBufferSize = kHeadroom +           // headroom + rounding + '.'
 1682|  1.56k|                              kMaxFixedPrecision +  // Integral
 1683|  1.56k|                              kMaxFractionalDigits;  // Fractional
 1684|  1.56k|  const int total_bits = kInputBits - LeadingZeros(v) + exp;
 1685|  1.56k|  char buffer[kBufferSize];
 1686|  1.56k|  char* integral_start = buffer + kHeadroom;
 1687|  1.56k|  char* integral_end = buffer + kHeadroom + kMaxFixedPrecision;
 1688|  1.56k|  char* final_start;
 1689|  1.56k|  char* final_end;
 1690|  1.56k|  bool zero_integral = false;
 1691|  1.56k|  int scientific_exp = 0;
 1692|  1.56k|  size_t digits_printed = 0;
 1693|  1.56k|  size_t trailing_zeros = 0;
 1694|  1.56k|  bool has_more_non_zero = false;
 1695|       |
 1696|  1.56k|  auto check_integral_zeros = [](char* const begin, char* const end,
 1697|  1.56k|                                 const size_t precision,
 1698|  1.56k|                                 size_t digits_processed) -> bool {
 1699|       |    // When considering rounding to even, we care about the digits after the
 1700|       |    // round digit which means the total digits to move from the start is
 1701|       |    // precision + 2 since the first digit we print before the decimal point
 1702|       |    // is not a part of precision.
 1703|  1.56k|    size_t digit_upper_bound = precision + 2;
 1704|  1.56k|    if (digits_processed > digit_upper_bound) {
 1705|  1.56k|      return std::any_of(begin + digit_upper_bound, end,
 1706|  1.56k|                         [](char c) { return c != '0'; });
 1707|  1.56k|    }
 1708|  1.56k|    return false;
 1709|  1.56k|  };
 1710|       |
 1711|  1.56k|  if (exp >= 0) {
  ------------------
  |  Branch (1711:7): [True: 1.56k, False: 0]
  ------------------
 1712|  1.56k|    integral_end = total_bits <= 64
  ------------------
  |  Branch (1712:20): [True: 0, False: 1.56k]
  ------------------
 1713|  1.56k|                       ? numbers_internal::FastIntToBuffer(
 1714|      0|                             static_cast<uint64_t>(v) << exp, integral_start)
 1715|  1.56k|                       : numbers_internal::FastIntToBuffer(
 1716|  1.56k|                             static_cast<uint128>(v) << exp, integral_start);
 1717|  1.56k|    *integral_end = '0';
 1718|  1.56k|    final_start = integral_start;
 1719|       |    // Integral is guaranteed to be non-zero at this point.
 1720|  1.56k|    scientific_exp = static_cast<int>(integral_end - integral_start) - 1;
 1721|  1.56k|    digits_printed = static_cast<size_t>(integral_end - integral_start);
 1722|  1.56k|    final_end = integral_end;
 1723|  1.56k|    has_more_non_zero = check_integral_zeros(integral_start, integral_end,
 1724|  1.56k|                                             state.precision, digits_printed);
 1725|  1.56k|  } else {
 1726|      0|    exp = -exp;
 1727|      0|    if (exp < kInputBits) {
  ------------------
  |  Branch (1727:9): [True: 0, False: 0]
  ------------------
 1728|      0|      integral_end =
 1729|      0|          numbers_internal::FastIntToBuffer(v >> exp, integral_start);
 1730|      0|    }
 1731|      0|    *integral_end = '0';
 1732|       |    // We didn't move integral_start and it gets set to 0 in
 1733|      0|    zero_integral = exp >= kInputBits || v >> exp == 0;
  ------------------
  |  Branch (1733:21): [True: 0, False: 0]
  |  Branch (1733:42): [True: 0, False: 0]
  ------------------
 1734|      0|    if (!zero_integral) {
  ------------------
  |  Branch (1734:9): [True: 0, False: 0]
  ------------------
 1735|      0|      digits_printed = static_cast<size_t>(integral_end - integral_start);
 1736|      0|      has_more_non_zero = check_integral_zeros(integral_start, integral_end,
 1737|      0|                                               state.precision, digits_printed);
 1738|      0|      final_end = integral_end;
 1739|      0|    }
 1740|       |    // Print fractional digits
 1741|      0|    char* fractional_start = integral_end;
 1742|       |
 1743|      0|    size_t digits_to_print = (state.precision + 1) >= digits_printed
  ------------------
  |  Branch (1743:30): [True: 0, False: 0]
  ------------------
 1744|      0|                                 ? state.precision + 1 - digits_printed
 1745|      0|                                 : 0;
 1746|      0|    bool print_extra = digits_printed <= state.precision + 1;
 1747|      0|    auto [fractional_end, skipped_zeros, has_nonzero_rem] =
 1748|      0|        exp <= 64 ? PrintFractionalDigitsScientific(
  ------------------
  |  Branch (1748:9): [True: 0, False: 0]
  ------------------
 1749|      0|                        v, fractional_start, exp, digits_to_print + print_extra,
 1750|      0|                        zero_integral)
 1751|      0|                  : PrintFractionalDigitsScientific(
 1752|      0|                        static_cast<uint128>(v), fractional_start, exp,
 1753|      0|                        digits_to_print + print_extra, zero_integral);
 1754|      0|    final_end = fractional_end;
 1755|      0|    *fractional_end = '0';
 1756|      0|    has_more_non_zero |= has_nonzero_rem;
 1757|      0|    digits_printed += static_cast<size_t>(fractional_end - fractional_start);
 1758|      0|    if (zero_integral) {
  ------------------
  |  Branch (1758:9): [True: 0, False: 0]
  ------------------
 1759|      0|      scientific_exp = -1 * static_cast<int>(skipped_zeros + 1);
 1760|      0|    } else {
 1761|      0|      scientific_exp = static_cast<int>(integral_end - integral_start) - 1;
 1762|      0|    }
 1763|       |    // Don't do any rounding here, we will do it ourselves.
 1764|      0|    final_start = zero_integral ? fractional_start : integral_start;
  ------------------
  |  Branch (1764:19): [True: 0, False: 0]
  ------------------
 1765|      0|  }
 1766|       |
 1767|       |  // For rounding
 1768|  1.56k|  if (digits_printed >= state.precision + 1) {
  ------------------
  |  Branch (1768:7): [True: 1.56k, False: 0]
  ------------------
 1769|  1.56k|    final_start[-1] = '0';
 1770|  1.56k|    char* round_digit_ptr = final_start + 1 + state.precision;
 1771|  1.56k|    if (*round_digit_ptr > '5') {
  ------------------
  |  Branch (1771:9): [True: 595, False: 966]
  ------------------
 1772|    595|      RoundUp(round_digit_ptr - 1);
 1773|    966|    } else if (*round_digit_ptr == '5') {
  ------------------
  |  Branch (1773:16): [True: 138, False: 828]
  ------------------
 1774|    138|      if (has_more_non_zero) {
  ------------------
  |  Branch (1774:11): [True: 138, False: 0]
  ------------------
 1775|    138|        RoundUp(round_digit_ptr - 1);
 1776|    138|      } else {
 1777|      0|        RoundToEven(round_digit_ptr - 1);
 1778|      0|      }
 1779|    138|    }
 1780|  1.56k|    final_end = round_digit_ptr;
 1781|  1.56k|    if (final_start[-1] == '1') {
  ------------------
  |  Branch (1781:9): [True: 62, False: 1.49k]
  ------------------
 1782|     62|      --final_start;
 1783|     62|      ++scientific_exp;
 1784|     62|      --final_end;
 1785|     62|    }
 1786|  1.56k|  } else {
 1787|       |    // Need to pad with zeros.
 1788|      0|    trailing_zeros = state.precision - (digits_printed - 1);
 1789|      0|  }
 1790|       |
 1791|  1.56k|  if (state.precision > 0 || state.ShouldPrintDot()) {
  ------------------
  |  Branch (1791:7): [True: 1.56k, False: 0]
  |  Branch (1791:30): [True: 0, False: 0]
  ------------------
 1792|  1.56k|    final_start[-1] = *final_start;
 1793|  1.56k|    *final_start = '.';
 1794|  1.56k|    --final_start;
 1795|  1.56k|  }
 1796|       |  // We have scientific exp at this point
 1797|  1.56k|  if ((scientific_exp < 0 ||
  ------------------
  |  Branch (1797:8): [True: 0, False: 1.56k]
  ------------------
 1798|  1.56k|       state.precision + 1 > static_cast<size_t>(scientific_exp)) &&
  ------------------
  |  Branch (1798:8): [True: 0, False: 1.56k]
  ------------------
 1799|      0|      scientific_exp >= -4) {
  ------------------
  |  Branch (1799:7): [True: 0, False: 0]
  ------------------
 1800|      0|    if (scientific_exp < 0) {
  ------------------
  |  Branch (1800:9): [True: 0, False: 0]
  ------------------
 1801|       |      // Have 1.23456, needs 0.00123456
 1802|       |      // Move the first digit
 1803|      0|      final_start[1] = *final_start;
 1804|      0|      if (!state.ShouldPrintDot()) {
  ------------------
  |  Branch (1804:11): [True: 0, False: 0]
  ------------------
 1805|      0|        ++final_end;
 1806|      0|      }
 1807|       |      // Add some zeros
 1808|      0|      for (; scientific_exp < -1; ++scientific_exp) {
  ------------------
  |  Branch (1808:14): [True: 0, False: 0]
  ------------------
 1809|      0|        *final_start = '0';
 1810|      0|        --final_start;
 1811|      0|      }
 1812|      0|      *final_start-- = '.';
 1813|      0|      *final_start = '0';
 1814|      0|    } else if (scientific_exp > 0) {
  ------------------
  |  Branch (1814:16): [True: 0, False: 0]
  ------------------
 1815|       |      // Have 1.23456, needs 1234.56
 1816|       |      // Move the '.' scientific_exp positions to the right.
 1817|      0|      std::rotate(final_start + 1, final_start + 2,
 1818|      0|                  final_start + scientific_exp + 2);
 1819|      0|    }
 1820|      0|    scientific_exp = 0;
 1821|      0|  }
 1822|  1.56k|  auto const& conv = state.conv;
 1823|  1.56k|  if (!conv.has_alt_flag()) {
  ------------------
  |  Branch (1823:7): [True: 1.56k, False: 0]
  ------------------
 1824|  1.56k|    trailing_zeros = 0;
 1825|  2.11k|    while (final_end[-1] == '0') {
  ------------------
  |  Branch (1825:12): [True: 557, False: 1.56k]
  ------------------
 1826|    557|      --final_end;
 1827|    557|    }
 1828|  1.56k|    if (final_end[-1] == '.') --final_end;
  ------------------
  |  Branch (1828:9): [True: 70, False: 1.49k]
  ------------------
 1829|  1.56k|  }
 1830|  1.56k|  if (scientific_exp) {
  ------------------
  |  Branch (1830:7): [True: 1.56k, False: 0]
  ------------------
 1831|       |    // We need to add 2 to the buffer size for the +/- sign and the e
 1832|  1.56k|    constexpr size_t kExpBufferSize = numbers_internal::kFastToBufferSize + 2;
 1833|  1.56k|    char exp_buffer[kExpBufferSize];
 1834|  1.56k|    char* exp_ptr_start = exp_buffer;
 1835|  1.56k|    char* exp_ptr = exp_ptr_start;
 1836|  1.56k|    *exp_ptr++ = uppercase ? 'E' : 'e';
  ------------------
  |  Branch (1836:18): [True: 0, False: 1.56k]
  ------------------
 1837|  1.56k|    if (scientific_exp >= 0) {
  ------------------
  |  Branch (1837:9): [True: 1.56k, False: 0]
  ------------------
 1838|  1.56k|      *exp_ptr++ = '+';
 1839|  1.56k|    } else {
 1840|      0|      *exp_ptr++ = '-';
 1841|      0|      scientific_exp = -scientific_exp;
 1842|      0|    }
 1843|       |
 1844|  1.56k|    if (scientific_exp < 10) {
  ------------------
  |  Branch (1844:9): [True: 0, False: 1.56k]
  ------------------
 1845|      0|      *exp_ptr++ = '0';
 1846|      0|    }
 1847|  1.56k|    exp_ptr = numbers_internal::FastIntToBuffer(scientific_exp, exp_ptr);
 1848|  1.56k|    FinalPrint(state,
 1849|  1.56k|               absl::string_view(
 1850|  1.56k|                   final_start, static_cast<size_t>((final_end - final_start))),
 1851|  1.56k|               0, trailing_zeros,
 1852|  1.56k|               absl::string_view(exp_ptr_start,
 1853|  1.56k|                                 static_cast<size_t>(exp_ptr - exp_ptr_start)));
 1854|  1.56k|  } else {
 1855|      0|    FinalPrint(state,
 1856|      0|               absl::string_view(
 1857|      0|                   final_start, static_cast<size_t>((final_end - final_start))),
 1858|      0|               0, trailing_zeros, "");
 1859|      0|  }
 1860|  1.56k|}
float_conversion.cc:_ZZN4absl19str_format_internal12_GLOBAL__N_111FormatGFastImEEvT_ibRKNS1_11FormatStateEENKUlPcS7_mmE_clES7_S7_mm:
 1698|  1.56k|                                 size_t digits_processed) -> bool {
 1699|       |    // When considering rounding to even, we care about the digits after the
 1700|       |    // round digit which means the total digits to move from the start is
 1701|       |    // precision + 2 since the first digit we print before the decimal point
 1702|       |    // is not a part of precision.
 1703|  1.56k|    size_t digit_upper_bound = precision + 2;
 1704|  1.56k|    if (digits_processed > digit_upper_bound) {
  ------------------
  |  Branch (1704:9): [True: 1.56k, False: 0]
  ------------------
 1705|  1.56k|      return std::any_of(begin + digit_upper_bound, end,
 1706|  1.56k|                         [](char c) { return c != '0'; });
 1707|  1.56k|    }
 1708|      0|    return false;
 1709|  1.56k|  };
float_conversion.cc:_ZZZN4absl19str_format_internal12_GLOBAL__N_111FormatGFastImEEvT_ibRKNS1_11FormatStateEENKUlPcS7_mmE_clES7_S7_mmENKUlcE_clEc:
 1706|  1.75k|                         [](char c) { return c != '0'; });

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

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

_ZN4absl16strings_internal9JoinRangeINSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEEEES9_RKT_NS2_17basic_string_viewIcS6_EE:
  321|  1.59k|std::string JoinRange(const Range& range, absl::string_view separator) {
  322|  1.59k|  using std::begin;
  323|  1.59k|  using std::end;
  324|  1.59k|  return JoinRange(begin(range), end(range), separator);
  325|  1.59k|}
_ZN4absl16strings_internal9JoinRangeINSt3__111__wrap_iterIPKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEES9_T_SD_NS2_17basic_string_viewIcS6_EE:
  305|  1.59k|                      absl::string_view separator) {
  306|       |  // No formatter was explicitly given, so a default must be chosen.
  307|  1.59k|  typedef typename std::iterator_traits<Iterator>::value_type ValueType;
  308|  1.59k|  typedef typename DefaultFormatter<ValueType>::Type Formatter;
  309|  1.59k|  return JoinAlgorithm(first, last, separator, Formatter());
  310|  1.59k|}
_ZN4absl16strings_internal13JoinAlgorithmINSt3__111__wrap_iterIPKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEvEES9_T_SD_NS2_17basic_string_viewIcS6_EENS0_11NoFormatterE:
  235|  1.59k|                          NoFormatter) {
  236|  1.59k|  std::string result;
  237|  1.59k|  if (start != end) {
  ------------------
  |  Branch (237:7): [True: 1.59k, False: 0]
  ------------------
  238|       |    // Sums size
  239|  1.59k|    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.59k|    uint64_t result_size = start_value.size();
  243|  19.5M|    for (Iterator it = start; ++it != end;) {
  ------------------
  |  Branch (243:31): [True: 19.5M, False: 1.59k]
  ------------------
  244|  19.5M|      result_size += s.size();
  245|  19.5M|      result_size += (*it).size();
  246|  19.5M|    }
  247|       |
  248|  1.59k|    if (result_size > 0) {
  ------------------
  |  Branch (248:9): [True: 1.59k, False: 0]
  ------------------
  249|  1.59k|      constexpr uint64_t kMaxSize =
  250|  1.59k|          uint64_t{(std::numeric_limits<size_t>::max)()};
  251|  1.59k|      ABSL_INTERNAL_CHECK(result_size <= kMaxSize, "size_t overflow");
  ------------------
  |  |   85|  1.59k|  do {                                                             \
  |  |   86|  1.59k|    if (ABSL_PREDICT_FALSE(!(condition))) {                        \
  |  |  ------------------
  |  |  |  |  190|  1.59k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 1.59k]
  |  |  |  |  |  Branch (190:49): [Folded, False: 1.59k]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 1.59k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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, \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   80|      0|        __LINE__, message);                                               \
  |  |  |  |   81|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   82|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (82:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|    }                                                              \
  |  |   91|  1.59k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (91:12): [Folded, False: 1.59k]
  |  |  ------------------
  ------------------
  |  Branch (251:7): [Folded, False: 0]
  |  Branch (251:7): [True: 0, Folded]
  |  Branch (251:7): [Folded, False: 0]
  ------------------
  252|       |
  253|  1.59k|      StringResizeAndOverwrite(
  254|  1.59k|          result, static_cast<size_t>(result_size),
  255|  1.59k|          [&start, &end, &start_value, s](char* result_buf,
  256|  1.59k|                                          size_t result_buf_size) {
  257|       |            // Joins strings
  258|  1.59k|            memcpy(result_buf, start_value.data(), start_value.size());
  259|  1.59k|            result_buf += start_value.size();
  260|  1.59k|            for (Iterator it = start; ++it != end;) {
  261|  1.59k|              memcpy(result_buf, s.data(), s.size());
  262|  1.59k|              result_buf += s.size();
  263|  1.59k|              auto&& value = *it;
  264|  1.59k|              memcpy(result_buf, value.data(), value.size());
  265|  1.59k|              result_buf += value.size();
  266|  1.59k|            }
  267|  1.59k|            return result_buf_size;
  268|  1.59k|          });
  269|  1.59k|    }
  270|  1.59k|  }
  271|  1.59k|  return result;
  272|  1.59k|}
_ZZN4absl16strings_internal13JoinAlgorithmINSt3__111__wrap_iterIPKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEvEES9_T_SD_NS2_17basic_string_viewIcS6_EENS0_11NoFormatterEENKUlPcmE_clESH_m:
  256|  1.59k|                                          size_t result_buf_size) {
  257|       |            // Joins strings
  258|  1.59k|            memcpy(result_buf, start_value.data(), start_value.size());
  259|  1.59k|            result_buf += start_value.size();
  260|  19.5M|            for (Iterator it = start; ++it != end;) {
  ------------------
  |  Branch (260:39): [True: 19.5M, False: 1.59k]
  ------------------
  261|  19.5M|              memcpy(result_buf, s.data(), s.size());
  262|  19.5M|              result_buf += s.size();
  263|  19.5M|              auto&& value = *it;
  264|  19.5M|              memcpy(result_buf, value.data(), value.size());
  265|  19.5M|              result_buf += value.size();
  266|  19.5M|            }
  267|  1.59k|            return result_buf_size;
  268|  1.59k|          });

_ZN4absl16strings_internal23ConvertibleToStringViewC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
   67|  1.59k|      : value_(s) {}
_ZNK4absl16strings_internal23ConvertibleToStringView5valueEv:
   73|  1.59k|  absl::string_view value() const { return value_; }
_ZN4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEC2ES8_S2_S3_:
  288|  1.59k|      : text_(std::move(input_text)),
  289|  1.59k|        delimiter_(std::move(d)),
  290|  1.59k|        predicate_(std::move(p)) {}
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEcvT_INS4_6vectorINS4_12basic_stringIcS7_NS4_9allocatorIcEEEENSE_ISG_EEEETnNS4_9enable_ifIXaantsr22ShouldUseLifetimeBoundIS8_SA_EE5valuesr23SplitterIsConvertibleToISA_EE5valueEDnE4typeELDn0EEEv:
  321|  1.59k|  operator Container() const {
  322|  1.59k|    return ConvertToContainer<Container, typename Container::value_type,
  323|  1.59k|                              HasMappedType<Container>::value>()(*this);
  324|  1.59k|  }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEE18ConvertToContainerINS4_6vectorINS4_12basic_stringIcS7_NS4_9allocatorIcEEEENSD_ISF_EEEESF_Lb0EEclERKS9_:
  455|  1.59k|    std::vector<std::string, A> operator()(const Splitter& splitter) const {
  456|  1.59k|      const std::vector<absl::string_view> v = splitter;
  457|  1.59k|      return std::vector<std::string, A>(v.begin(), v.end());
  458|  1.59k|    }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEcvT_INS4_6vectorIS8_NS4_9allocatorIS8_EEEETnNS4_9enable_ifIXaantsr22ShouldUseLifetimeBoundIS8_SA_EE5valuesr23SplitterIsConvertibleToISA_EE5valueEDnE4typeELDn0EEEv:
  321|  1.59k|  operator Container() const {
  322|  1.59k|    return ConvertToContainer<Container, typename Container::value_type,
  323|  1.59k|                              HasMappedType<Container>::value>()(*this);
  324|  1.59k|  }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEE18ConvertToContainerINS4_6vectorIS8_NS4_9allocatorIS8_EEEES8_Lb0EEclERKS9_:
  421|  1.59k|        const Splitter& splitter) const {
  422|  1.59k|      struct raw_view {
  423|  1.59k|        const char* data;
  424|  1.59k|        size_t size;
  425|  1.59k|        operator absl::string_view() const {  // NOLINT(runtime/explicit)
  426|  1.59k|          return {data, size};
  427|  1.59k|        }
  428|  1.59k|      };
  429|  1.59k|      std::vector<absl::string_view, A> v;
  430|  1.59k|      std::array<raw_view, 16> ar;
  431|  1.22M|      for (auto it = splitter.begin(); !it.at_end();) {
  ------------------
  |  Branch (431:40): [True: 1.22M, False: 1.59k]
  ------------------
  432|  1.22M|        size_t index = 0;
  433|  19.5M|        do {
  434|  19.5M|          ar[index].data = it->data();
  435|  19.5M|          ar[index].size = it->size();
  436|  19.5M|          ++it;
  437|  19.5M|        } while (++index != ar.size() && !it.at_end());
  ------------------
  |  Branch (437:18): [True: 18.3M, False: 1.22M]
  |  Branch (437:42): [True: 18.3M, False: 1.55k]
  ------------------
  438|       |        // We static_cast index to a signed type to work around overzealous
  439|       |        // compiler warnings about signedness.
  440|  1.22M|        v.insert(v.end(), ar.begin(),
  441|  1.22M|                 ar.begin() + static_cast<ptrdiff_t>(index));
  442|  1.22M|      }
  443|  1.59k|      return v;
  444|  1.59k|    }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEE5beginEv:
  299|  1.59k|  const_iterator begin() const { return {const_iterator::kInitState, this}; }
_ZN4absl16strings_internal13SplitIteratorINS0_8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEEEC2ENSB_5StateEPKSA_:
   96|  1.59k|      : pos_(0),
   97|  1.59k|        state_(state),
   98|  1.59k|        splitter_(splitter),
   99|  1.59k|        delimiter_(splitter->delimiter()),
  100|  1.59k|        predicate_(splitter->predicate()) {
  101|       |    // Hack to maintain backward compatibility. This one block makes it so an
  102|       |    // empty absl::string_view whose .data() happens to be nullptr behaves
  103|       |    // *differently* from an otherwise empty absl::string_view whose .data() is
  104|       |    // not nullptr. This is an undesirable difference in general, but this
  105|       |    // behavior is maintained to avoid breaking existing code that happens to
  106|       |    // depend on this old behavior/bug. Perhaps it will be fixed one day. The
  107|       |    // difference in behavior is as follows:
  108|       |    //   Split(absl::string_view(""), '-');  // {""}
  109|       |    //   Split(absl::string_view(), '-');    // {}
  110|  1.59k|    if (splitter_->text().data() == nullptr) {
  ------------------
  |  Branch (110:9): [True: 0, False: 1.59k]
  ------------------
  111|      0|      state_ = kEndState;
  112|      0|      pos_ = splitter_->text().size();
  113|      0|      return;
  114|      0|    }
  115|       |
  116|  1.59k|    if (state_ == kEndState) {
  ------------------
  |  Branch (116:9): [True: 0, False: 1.59k]
  ------------------
  117|      0|      pos_ = splitter_->text().size();
  118|  1.59k|    } else {
  119|  1.59k|      ++(*this);
  120|  1.59k|    }
  121|  1.59k|  }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEE9delimiterEv:
  293|  1.59k|  const Delimiter& delimiter() const { return delimiter_; }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEE9predicateEv:
  294|  1.59k|  const Predicate& predicate() const { return predicate_; }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEE4textEv:
  292|  19.5M|  absl::string_view text() const { return text_; }
_ZNK4absl16strings_internal13SplitIteratorINS0_8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEEE6at_endEv:
  123|  19.5M|  bool at_end() const { return state_ == kEndState; }
_ZNK4absl16strings_internal13SplitIteratorINS0_8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEEEptEv:
  126|  39.0M|  pointer operator->() const { return &curr_; }
_ZN4absl16strings_internal13SplitIteratorINS0_8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEEEppEv:
  128|  19.5M|  SplitIterator& operator++() {
  129|  19.5M|    do {
  130|  19.5M|      if (state_ == kLastState) {
  ------------------
  |  Branch (130:11): [True: 1.59k, False: 19.5M]
  ------------------
  131|  1.59k|        state_ = kEndState;
  132|  1.59k|        return *this;
  133|  1.59k|      }
  134|  19.5M|      const absl::string_view text = splitter_->text();
  135|  19.5M|      const absl::string_view d = delimiter_.Find(text, pos_);
  136|  19.5M|      if (d.data() == text.data() + text.size()) state_ = kLastState;
  ------------------
  |  Branch (136:11): [True: 1.59k, False: 19.5M]
  ------------------
  137|  19.5M|      curr_ = text.substr(pos_,
  138|  19.5M|                          static_cast<size_t>(d.data() - (text.data() + pos_)));
  139|  19.5M|      pos_ += curr_.size() + d.size();
  140|  19.5M|    } while (!predicate_(curr_));
  ------------------
  |  Branch (140:14): [True: 0, False: 19.5M]
  ------------------
  141|  19.5M|    return *this;
  142|  19.5M|  }
_ZZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEE18ConvertToContainerINS4_6vectorIS8_NS4_9allocatorIS8_EEEES8_Lb0EEclERKS9_ENK8raw_viewcvS8_Ev:
  425|  19.5M|        operator absl::string_view() const {  // NOLINT(runtime/explicit)
  426|  19.5M|          return {data, size};
  427|  19.5M|        }

_ZN4absl16EqualsIgnoreCaseENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEES4_:
   32|  14.3k|                      absl::string_view piece2) noexcept {
   33|  14.3k|  return (piece1.size() == piece2.size() &&
  ------------------
  |  Branch (33:11): [True: 8.58k, False: 5.72k]
  ------------------
   34|  8.58k|          0 == absl::strings_internal::memcasecmp(piece1.data(), piece2.data(),
  ------------------
  |  Branch (34:11): [True: 1.59k, False: 6.99k]
  ------------------
   35|  8.58k|                                                  piece1.size()));
   36|       |  // memcasecmp uses absl::ascii_tolower().
   37|  14.3k|}

_ZN4absl10SimpleAtofENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEPf:
   52|  1.59k|bool SimpleAtof(absl::string_view str, float* absl_nonnull out) {
   53|  1.59k|  *out = 0.0;
   54|  1.59k|  str = StripAsciiWhitespace(str);
   55|  1.59k|  if (str.empty()) {
  ------------------
  |  Branch (55:7): [True: 0, False: 1.59k]
  ------------------
   56|       |    // absl::from_chars doesn't accept empty strings.
   57|      0|    return false;
   58|      0|  }
   59|       |  // std::from_chars doesn't accept an initial +, but SimpleAtof does, so if one
   60|       |  // is present, skip it, while avoiding accepting "+-0" as valid.
   61|  1.59k|  if (str[0] == '+') {
  ------------------
  |  Branch (61:7): [True: 0, False: 1.59k]
  ------------------
   62|      0|    str.remove_prefix(1);
   63|      0|    if (str.empty() || str[0] == '-') {
  ------------------
  |  Branch (63:9): [True: 0, False: 0]
  |  Branch (63:24): [True: 0, False: 0]
  ------------------
   64|      0|      return false;
   65|      0|    }
   66|      0|  }
   67|  1.59k|  auto result = absl::from_chars(str.data(), str.data() + str.size(), *out);
   68|  1.59k|  if (result.ec == std::errc::invalid_argument) {
  ------------------
  |  Branch (68:7): [True: 0, False: 1.59k]
  ------------------
   69|      0|    return false;
   70|      0|  }
   71|  1.59k|  if (result.ptr != str.data() + str.size()) {
  ------------------
  |  Branch (71:7): [True: 0, False: 1.59k]
  ------------------
   72|       |    // not all non-whitespace characters consumed
   73|      0|    return false;
   74|      0|  }
   75|       |  // from_chars() with DR 3081's current wording will return max() on
   76|       |  // overflow.  SimpleAtof returns infinity instead.
   77|  1.59k|  if (result.ec == std::errc::result_out_of_range) {
  ------------------
  |  Branch (77:7): [True: 0, False: 1.59k]
  ------------------
   78|      0|    if (*out > 1.0) {
  ------------------
  |  Branch (78:9): [True: 0, False: 0]
  ------------------
   79|      0|      *out = std::numeric_limits<float>::infinity();
   80|      0|    } else if (*out < -1.0) {
  ------------------
  |  Branch (80:16): [True: 0, False: 0]
  ------------------
   81|      0|      *out = -std::numeric_limits<float>::infinity();
   82|      0|    }
   83|      0|  }
   84|  1.59k|  return true;
   85|  1.59k|}
_ZN4absl10SimpleAtodENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEPd:
   87|  1.59k|bool SimpleAtod(absl::string_view str, double* absl_nonnull out) {
   88|  1.59k|  *out = 0.0;
   89|  1.59k|  str = StripAsciiWhitespace(str);
   90|  1.59k|  if (str.empty()) {
  ------------------
  |  Branch (90:7): [True: 0, False: 1.59k]
  ------------------
   91|       |    // absl::from_chars doesn't accept empty strings.
   92|      0|    return false;
   93|      0|  }
   94|       |  // std::from_chars doesn't accept an initial +, but SimpleAtod does, so if one
   95|       |  // is present, skip it, while avoiding accepting "+-0" as valid.
   96|  1.59k|  if (str[0] == '+') {
  ------------------
  |  Branch (96:7): [True: 0, False: 1.59k]
  ------------------
   97|      0|    str.remove_prefix(1);
   98|      0|    if (str.empty() || str[0] == '-') {
  ------------------
  |  Branch (98:9): [True: 0, False: 0]
  |  Branch (98:24): [True: 0, False: 0]
  ------------------
   99|      0|      return false;
  100|      0|    }
  101|      0|  }
  102|  1.59k|  auto result = absl::from_chars(str.data(), str.data() + str.size(), *out);
  103|  1.59k|  if (result.ec == std::errc::invalid_argument) {
  ------------------
  |  Branch (103:7): [True: 0, False: 1.59k]
  ------------------
  104|      0|    return false;
  105|      0|  }
  106|  1.59k|  if (result.ptr != str.data() + str.size()) {
  ------------------
  |  Branch (106:7): [True: 0, False: 1.59k]
  ------------------
  107|       |    // not all non-whitespace characters consumed
  108|      0|    return false;
  109|      0|  }
  110|       |  // from_chars() with DR 3081's current wording will return max() on
  111|       |  // overflow.  SimpleAtod returns infinity instead.
  112|  1.59k|  if (result.ec == std::errc::result_out_of_range) {
  ------------------
  |  Branch (112:7): [True: 0, False: 1.59k]
  ------------------
  113|      0|    if (*out > 1.0) {
  ------------------
  |  Branch (113:9): [True: 0, False: 0]
  ------------------
  114|      0|      *out = std::numeric_limits<double>::infinity();
  115|      0|    } else if (*out < -1.0) {
  ------------------
  |  Branch (115:16): [True: 0, False: 0]
  ------------------
  116|      0|      *out = -std::numeric_limits<double>::infinity();
  117|      0|    }
  118|      0|  }
  119|  1.59k|  return true;
  120|  1.59k|}
_ZN4absl10SimpleAtobENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEPb:
  122|  1.59k|bool SimpleAtob(absl::string_view str, bool* absl_nonnull out) {
  123|  1.59k|  ABSL_RAW_CHECK(out != nullptr, "Output pointer must not be nullptr.");
  ------------------
  |  |   60|  1.59k|  do {                                                                 \
  |  |   61|  1.59k|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|  1.59k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 1.59k]
  |  |  |  |  |  Branch (190:49): [Folded, False: 1.59k]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 1.59k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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,         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|  1.59k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 1.59k]
  |  |  ------------------
  ------------------
  |  Branch (123:3): [Folded, False: 0]
  |  Branch (123:3): [True: 0, Folded]
  |  Branch (123:3): [Folded, False: 0]
  ------------------
  124|  1.59k|  if (EqualsIgnoreCase(str, "true") || EqualsIgnoreCase(str, "t") ||
  ------------------
  |  Branch (124:7): [True: 0, False: 1.59k]
  |  Branch (124:40): [True: 0, False: 1.59k]
  ------------------
  125|  1.59k|      EqualsIgnoreCase(str, "yes") || EqualsIgnoreCase(str, "y") ||
  ------------------
  |  Branch (125:7): [True: 0, False: 1.59k]
  |  Branch (125:39): [True: 0, False: 1.59k]
  ------------------
  126|  1.59k|      EqualsIgnoreCase(str, "1")) {
  ------------------
  |  Branch (126:7): [True: 320, False: 1.27k]
  ------------------
  127|    320|    *out = true;
  128|    320|    return true;
  129|    320|  }
  130|  1.27k|  if (EqualsIgnoreCase(str, "false") || EqualsIgnoreCase(str, "f") ||
  ------------------
  |  Branch (130:7): [True: 0, False: 1.27k]
  |  Branch (130:41): [True: 0, False: 1.27k]
  ------------------
  131|  1.27k|      EqualsIgnoreCase(str, "no") || EqualsIgnoreCase(str, "n") ||
  ------------------
  |  Branch (131:7): [True: 0, False: 1.27k]
  |  Branch (131:38): [True: 0, False: 1.27k]
  ------------------
  132|  1.27k|      EqualsIgnoreCase(str, "0")) {
  ------------------
  |  Branch (132:7): [True: 1.27k, False: 0]
  ------------------
  133|  1.27k|    *out = false;
  134|  1.27k|    return true;
  135|  1.27k|  }
  136|      0|  return false;
  137|  1.27k|}
_ZN4absl16numbers_internal12PutTwoDigitsEjPc:
  333|  12.5k|void numbers_internal::PutTwoDigits(uint32_t i, char* absl_nonnull buf) {
  334|  12.5k|  assert(i < 100);
  ------------------
  |  Branch (334:3): [True: 12.5k, False: 0]
  ------------------
  335|  12.5k|  uint32_t base = kTwoZeroBytes;
  336|  12.5k|  uint32_t div10 = (i * kDivisionBy10Mul) / kDivisionBy10Div;
  337|  12.5k|  uint32_t mod10 = i - 10u * div10;
  338|  12.5k|  base += div10 + (mod10 << 8);
  339|  12.5k|  little_endian::Store16(buf, static_cast<uint16_t>(base));
  340|  12.5k|}
_ZN4absl16numbers_internal15FastIntToBufferEiPc:
  350|  9.49k|    int32_t i, char* absl_nonnull buffer) {
  351|  9.49k|  uint32_t u = static_cast<uint32_t>(i);
  352|  9.49k|  if (i < 0) {
  ------------------
  |  Branch (352:7): [True: 2.74k, False: 6.75k]
  ------------------
  353|  2.74k|    *buffer++ = '-';
  354|       |    // We need to do the negation in modular (i.e., "unsigned")
  355|       |    // arithmetic; MSVC++ apparently warns for plain "-u", so
  356|       |    // we write the equivalent expression "0 - u" instead.
  357|  2.74k|    u = 0 - u;
  358|  2.74k|  }
  359|  9.49k|  buffer = EncodeFullU32(u, buffer);
  360|  9.49k|  *buffer = '\0';
  361|  9.49k|  return buffer;
  362|  9.49k|}
_ZN4absl16numbers_internal15FastIntToBufferENS_7uint128EPc:
  387|  1.56k|    uint128 i, char* absl_nonnull buffer) {
  388|  1.56k|  buffer = EncodeFullU128(i, buffer);
  389|  1.56k|  *buffer = '\0';
  390|  1.56k|  return buffer;
  391|  1.56k|}
_ZN4absl16numbers_internal17SixDigitsToBufferEdPc:
 1043|  3.18k|                                           char* absl_nonnull const buffer) {
 1044|  3.18k|  static_assert(std::numeric_limits<float>::is_iec559,
 1045|  3.18k|                "IEEE-754/IEC-559 support only");
 1046|       |
 1047|  3.18k|  char* out = buffer;  // we write data to out, incrementing as we go, but
 1048|       |                       // FloatToBuffer always returns the address of the buffer
 1049|       |                       // passed in.
 1050|       |
 1051|  3.18k|  if (std::isnan(d)) {
  ------------------
  |  Branch (1051:7): [True: 0, False: 3.18k]
  ------------------
 1052|      0|    strcpy(out, "nan");  // NOLINT(runtime/printf)
 1053|      0|    return 3;
 1054|      0|  }
 1055|  3.18k|  if (d == 0) {  // +0 and -0 are handled here
  ------------------
  |  Branch (1055:7): [True: 47, False: 3.13k]
  ------------------
 1056|     47|    if (std::signbit(d)) *out++ = '-';
  ------------------
  |  Branch (1056:9): [True: 0, False: 47]
  ------------------
 1057|     47|    *out++ = '0';
 1058|     47|    *out = 0;
 1059|     47|    return static_cast<size_t>(out - buffer);
 1060|     47|  }
 1061|  3.13k|  if (d < 0) {
  ------------------
  |  Branch (1061:7): [True: 1.86k, False: 1.26k]
  ------------------
 1062|  1.86k|    *out++ = '-';
 1063|  1.86k|    d = -d;
 1064|  1.86k|  }
 1065|  3.13k|  if (d > std::numeric_limits<double>::max()) {
  ------------------
  |  Branch (1065:7): [True: 0, False: 3.13k]
  ------------------
 1066|      0|    strcpy(out, "inf");  // NOLINT(runtime/printf)
 1067|      0|    return static_cast<size_t>(out + 3 - buffer);
 1068|      0|  }
 1069|       |
 1070|  3.13k|  auto exp_dig = SplitToSix(d);
 1071|  3.13k|  int exp = exp_dig.exponent;
 1072|  3.13k|  const char* digits = exp_dig.digits;
 1073|  3.13k|  out[0] = '0';
 1074|  3.13k|  out[1] = '.';
 1075|  3.13k|  switch (exp) {
  ------------------
  |  Branch (1075:11): [True: 0, False: 3.13k]
  ------------------
 1076|      0|    case 5:
  ------------------
  |  Branch (1076:5): [True: 0, False: 3.13k]
  ------------------
 1077|      0|      memcpy(out, &digits[0], 6), out += 6;
 1078|      0|      *out = 0;
 1079|      0|      return static_cast<size_t>(out - buffer);
 1080|      0|    case 4:
  ------------------
  |  Branch (1080:5): [True: 0, False: 3.13k]
  ------------------
 1081|      0|      memcpy(out, &digits[0], 5), out += 5;
 1082|      0|      if (digits[5] != '0') {
  ------------------
  |  Branch (1082:11): [True: 0, False: 0]
  ------------------
 1083|      0|        *out++ = '.';
 1084|      0|        *out++ = digits[5];
 1085|      0|      }
 1086|      0|      *out = 0;
 1087|      0|      return static_cast<size_t>(out - buffer);
 1088|      0|    case 3:
  ------------------
  |  Branch (1088:5): [True: 0, False: 3.13k]
  ------------------
 1089|      0|      memcpy(out, &digits[0], 4), out += 4;
 1090|      0|      if ((digits[5] | digits[4]) != '0') {
  ------------------
  |  Branch (1090:11): [True: 0, False: 0]
  ------------------
 1091|      0|        *out++ = '.';
 1092|      0|        *out++ = digits[4];
 1093|      0|        if (digits[5] != '0') *out++ = digits[5];
  ------------------
  |  Branch (1093:13): [True: 0, False: 0]
  ------------------
 1094|      0|      }
 1095|      0|      *out = 0;
 1096|      0|      return static_cast<size_t>(out - buffer);
 1097|      0|    case 2:
  ------------------
  |  Branch (1097:5): [True: 0, False: 3.13k]
  ------------------
 1098|      0|      memcpy(out, &digits[0], 3), out += 3;
 1099|      0|      *out++ = '.';
 1100|      0|      memcpy(out, &digits[3], 3);
 1101|      0|      out += 3;
 1102|      0|      while (out[-1] == '0') --out;
  ------------------
  |  Branch (1102:14): [True: 0, False: 0]
  ------------------
 1103|      0|      if (out[-1] == '.') --out;
  ------------------
  |  Branch (1103:11): [True: 0, False: 0]
  ------------------
 1104|      0|      *out = 0;
 1105|      0|      return static_cast<size_t>(out - buffer);
 1106|      0|    case 1:
  ------------------
  |  Branch (1106:5): [True: 0, False: 3.13k]
  ------------------
 1107|      0|      memcpy(out, &digits[0], 2), out += 2;
 1108|      0|      *out++ = '.';
 1109|      0|      memcpy(out, &digits[2], 4);
 1110|      0|      out += 4;
 1111|      0|      while (out[-1] == '0') --out;
  ------------------
  |  Branch (1111:14): [True: 0, False: 0]
  ------------------
 1112|      0|      if (out[-1] == '.') --out;
  ------------------
  |  Branch (1112:11): [True: 0, False: 0]
  ------------------
 1113|      0|      *out = 0;
 1114|      0|      return static_cast<size_t>(out - buffer);
 1115|      0|    case 0:
  ------------------
  |  Branch (1115:5): [True: 0, False: 3.13k]
  ------------------
 1116|      0|      memcpy(out, &digits[0], 1), out += 1;
 1117|      0|      *out++ = '.';
 1118|      0|      memcpy(out, &digits[1], 5);
 1119|      0|      out += 5;
 1120|      0|      while (out[-1] == '0') --out;
  ------------------
  |  Branch (1120:14): [True: 0, False: 0]
  ------------------
 1121|      0|      if (out[-1] == '.') --out;
  ------------------
  |  Branch (1121:11): [True: 0, False: 0]
  ------------------
 1122|      0|      *out = 0;
 1123|      0|      return static_cast<size_t>(out - buffer);
 1124|      0|    case -4:
  ------------------
  |  Branch (1124:5): [True: 0, False: 3.13k]
  ------------------
 1125|      0|      out[2] = '0';
 1126|      0|      ++out;
 1127|      0|      ABSL_FALLTHROUGH_INTENDED;
  ------------------
  |  |  673|      0|#define ABSL_FALLTHROUGH_INTENDED [[fallthrough]]
  ------------------
 1128|      0|    case -3:
  ------------------
  |  Branch (1128:5): [True: 0, False: 3.13k]
  ------------------
 1129|      0|      out[2] = '0';
 1130|      0|      ++out;
 1131|      0|      ABSL_FALLTHROUGH_INTENDED;
  ------------------
  |  |  673|      0|#define ABSL_FALLTHROUGH_INTENDED [[fallthrough]]
  ------------------
 1132|      0|    case -2:
  ------------------
  |  Branch (1132:5): [True: 0, False: 3.13k]
  ------------------
 1133|      0|      out[2] = '0';
 1134|      0|      ++out;
 1135|      0|      ABSL_FALLTHROUGH_INTENDED;
  ------------------
  |  |  673|      0|#define ABSL_FALLTHROUGH_INTENDED [[fallthrough]]
  ------------------
 1136|      0|    case -1:
  ------------------
  |  Branch (1136:5): [True: 0, False: 3.13k]
  ------------------
 1137|      0|      out += 2;
 1138|      0|      memcpy(out, &digits[0], 6);
 1139|      0|      out += 6;
 1140|      0|      while (out[-1] == '0') --out;
  ------------------
  |  Branch (1140:14): [True: 0, False: 0]
  ------------------
 1141|      0|      *out = 0;
 1142|      0|      return static_cast<size_t>(out - buffer);
 1143|  3.13k|  }
 1144|  3.13k|  assert(exp < -4 || exp >= 6);
  ------------------
  |  Branch (1144:3): [True: 0, False: 3.13k]
  |  Branch (1144:3): [True: 3.13k, False: 0]
  |  Branch (1144:3): [True: 3.13k, False: 0]
  ------------------
 1145|  3.13k|  out[0] = digits[0];
 1146|  3.13k|  assert(out[1] == '.');
  ------------------
  |  Branch (1146:3): [True: 3.13k, False: 0]
  ------------------
 1147|  3.13k|  out += 2;
 1148|  3.13k|  memcpy(out, &digits[1], 5), out += 5;
 1149|  4.45k|  while (out[-1] == '0') --out;
  ------------------
  |  Branch (1149:10): [True: 1.31k, False: 3.13k]
  ------------------
 1150|  3.13k|  if (out[-1] == '.') --out;
  ------------------
  |  Branch (1150:7): [True: 173, False: 2.96k]
  ------------------
 1151|  3.13k|  *out++ = 'e';
 1152|  3.13k|  if (exp > 0) {
  ------------------
  |  Branch (1152:7): [True: 3.13k, False: 0]
  ------------------
 1153|  3.13k|    *out++ = '+';
 1154|  3.13k|  } else {
 1155|      0|    *out++ = '-';
 1156|      0|    exp = -exp;
 1157|      0|  }
 1158|  3.13k|  if (exp > 99) {
  ------------------
  |  Branch (1158:7): [True: 1.57k, False: 1.56k]
  ------------------
 1159|  1.57k|    int dig1 = exp / 100;
 1160|  1.57k|    exp -= dig1 * 100;
 1161|  1.57k|    *out++ = '0' + static_cast<char>(dig1);
 1162|  1.57k|  }
 1163|  3.13k|  PutTwoDigits(static_cast<uint32_t>(exp), out);
 1164|  3.13k|  out += 2;
 1165|  3.13k|  *out = 0;
 1166|  3.13k|  return static_cast<size_t>(out - buffer);
 1167|  3.13k|}
_ZN4absl16numbers_internal17safe_strto32_baseENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPii:
 1620|  1.59k|                       int base) {
 1621|  1.59k|  return safe_int_internal<int32_t>(text, value, base);
 1622|  1.59k|}
numbers.cc:_ZN4absl12_GLOBAL__N_113EncodeFullU32EjPc:
  260|  11.0k|    uint32_t n, char* absl_nonnull out_str) {
  261|  11.0k|  if (n < 10) {
  ------------------
  |  Branch (261:7): [True: 3.23k, False: 7.82k]
  ------------------
  262|  3.23k|    *out_str = static_cast<char>('0' + n);
  263|  3.23k|    return out_str + 1;
  264|  3.23k|  }
  265|  7.82k|  if (n < 100'000'000) {
  ------------------
  |  Branch (265:7): [True: 4.86k, False: 2.96k]
  ------------------
  266|  4.86k|    uint64_t bottom = PrepareEightDigits(n);
  267|  4.86k|    ABSL_ASSUME(bottom != 0);
  ------------------
  |  |  270|  4.86k|  (ABSL_PREDICT_TRUE((cond)) ? void() : assert(false && #cond))  // NOLINT
  |  |  ------------------
  |  |  |  |  191|  4.86k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (191:30): [True: 4.86k, False: 0]
  |  |  |  |  |  Branch (191:48): [Folded, False: 4.86k]
  |  |  |  |  |  Branch (191:57): [True: 4.86k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (267:5): [Folded, False: 0]
  |  Branch (267:5): [True: 0, Folded]
  |  Branch (267:5): [Folded, False: 0]
  ------------------
  268|       |    // 0 minus 8 to make MSVC happy.
  269|  4.86k|    uint32_t zeroes =
  270|  4.86k|        static_cast<uint32_t>(absl::countr_zero(bottom)) & (0 - 8u);
  271|  4.86k|    little_endian::Store64(out_str, (bottom + kEightZeroBytes) >> zeroes);
  272|  4.86k|    return out_str + sizeof(bottom) - zeroes / 8;
  273|  4.86k|  }
  274|  2.96k|  uint32_t div08 = n / 100'000'000;
  275|  2.96k|  uint32_t mod08 = n % 100'000'000;
  276|  2.96k|  uint64_t bottom = PrepareEightDigits(mod08) + kEightZeroBytes;
  277|  2.96k|  out_str = EncodeHundred(div08, out_str);
  278|  2.96k|  little_endian::Store64(out_str, bottom);
  279|  2.96k|  return out_str + sizeof(bottom);
  280|  7.82k|}
numbers.cc:_ZN4absl12_GLOBAL__N_118PrepareEightDigitsEj:
  231|  13.9k|inline uint64_t PrepareEightDigits(uint32_t i) {
  232|  13.9k|  ABSL_ASSUME(i < 10000'0000);
  ------------------
  |  |  270|  13.9k|  (ABSL_PREDICT_TRUE((cond)) ? void() : assert(false && #cond))  // NOLINT
  |  |  ------------------
  |  |  |  |  191|  13.9k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (191:30): [True: 13.9k, False: 0]
  |  |  |  |  |  Branch (191:48): [Folded, False: 13.9k]
  |  |  |  |  |  Branch (191:57): [True: 13.9k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (232:3): [Folded, False: 0]
  |  Branch (232:3): [True: 0, Folded]
  |  Branch (232:3): [Folded, False: 0]
  ------------------
  233|       |  // Prepare 2 blocks of 4 digits "in parallel".
  234|  13.9k|  uint32_t hi = i / 10000;
  235|  13.9k|  uint32_t lo = i % 10000;
  236|  13.9k|  uint64_t merged = hi | (uint64_t{lo} << 32);
  237|  13.9k|  uint64_t div100 = ((merged * kDivisionBy100Mul) / kDivisionBy100Div) &
  238|  13.9k|                    ((0x7Full << 32) | 0x7Full);
  239|  13.9k|  uint64_t mod100 = merged - 100ull * div100;
  240|  13.9k|  uint64_t hundreds = (mod100 << 16) + div100;
  241|  13.9k|  uint64_t tens = (hundreds * kDivisionBy10Mul) / kDivisionBy10Div;
  242|  13.9k|  tens &= (0xFull << 48) | (0xFull << 32) | (0xFull << 16) | 0xFull;
  243|  13.9k|  tens += (hundreds - 10ull * tens) << 8;
  244|  13.9k|  return tens;
  245|  13.9k|}
numbers.cc:_ZN4absl12_GLOBAL__N_113EncodeHundredEjPc:
  181|  2.96k|inline char* EncodeHundred(uint32_t n, char* absl_nonnull out_str) {
  182|  2.96k|  int num_digits = static_cast<int>(n - 10) >> 8;
  183|  2.96k|  uint32_t div10 = (n * kDivisionBy10Mul) / kDivisionBy10Div;
  184|  2.96k|  uint32_t mod10 = n - 10u * div10;
  185|  2.96k|  uint32_t base = kTwoZeroBytes + div10 + (mod10 << 8);
  186|  2.96k|  base >>= num_digits & 8;
  187|  2.96k|  little_endian::Store16(out_str, static_cast<uint16_t>(base));
  188|  2.96k|  return out_str + 2 + num_digits;
  189|  2.96k|}
numbers.cc:_ZN4absl12_GLOBAL__N_113EncodeFullU64EmPc:
  283|  1.56k|    uint64_t i, char* absl_nonnull buffer) {
  284|  1.56k|  if (i <= std::numeric_limits<uint32_t>::max()) {
  ------------------
  |  Branch (284:7): [True: 1.44k, False: 114]
  ------------------
  285|  1.44k|    return EncodeFullU32(static_cast<uint32_t>(i), buffer);
  286|  1.44k|  }
  287|    114|  uint32_t mod08;
  288|    114|  if (i < 1'0000'0000'0000'0000ull) {
  ------------------
  |  Branch (288:7): [True: 114, False: 0]
  ------------------
  289|    114|    uint32_t div08 = static_cast<uint32_t>(i / 100'000'000ull);
  290|    114|    mod08 = static_cast<uint32_t>(i % 100'000'000ull);
  291|    114|    buffer = EncodeFullU32(div08, buffer);
  292|    114|  } else {
  293|      0|    uint64_t div08 = i / 100'000'000ull;
  294|      0|    mod08 = static_cast<uint32_t>(i % 100'000'000ull);
  295|      0|    uint32_t div016 = static_cast<uint32_t>(div08 / 100'000'000ull);
  296|      0|    uint32_t div08mod08 = static_cast<uint32_t>(div08 % 100'000'000ull);
  297|      0|    uint64_t mid_result = PrepareEightDigits(div08mod08) + kEightZeroBytes;
  298|      0|    buffer = EncodeTenThousand(div016, buffer);
  299|      0|    little_endian::Store64(buffer, mid_result);
  300|      0|    buffer += sizeof(mid_result);
  301|      0|  }
  302|    114|  uint64_t mod_result = PrepareEightDigits(mod08) + kEightZeroBytes;
  303|    114|  little_endian::Store64(buffer, mod_result);
  304|    114|  return buffer + sizeof(mod_result);
  305|  1.56k|}
numbers.cc:_ZN4absl12_GLOBAL__N_114EncodeFullU128ENS_7uint128EPc:
  308|  1.56k|    uint128 i, char* absl_nonnull buffer) {
  309|  1.56k|  if (absl::Uint128High64(i) == 0) {
  ------------------
  |  Branch (309:7): [True: 0, False: 1.56k]
  ------------------
  310|      0|    return EncodeFullU64(absl::Uint128Low64(i), buffer);
  311|      0|  }
  312|       |  // We divide the number into 16-digit chunks because `EncodePadded16` is
  313|       |  // optimized to handle 16 digits at a time (as two 8-digit chunks).
  314|  1.56k|  constexpr uint64_t k1e16 = uint64_t{10'000'000'000'000'000};
  315|  1.56k|  uint128 high = i / k1e16;
  316|  1.56k|  uint64_t low = absl::Uint128Low64(i % k1e16);
  317|  1.56k|  uint64_t mid = absl::Uint128Low64(high % k1e16);
  318|  1.56k|  high /= k1e16;
  319|       |
  320|  1.56k|  if (high == 0) {
  ------------------
  |  Branch (320:7): [True: 114, False: 1.44k]
  ------------------
  321|    114|    buffer = EncodeFullU64(mid, buffer);
  322|    114|    buffer = EncodePadded16(low, buffer);
  323|  1.44k|  } else {
  324|  1.44k|    buffer = EncodeFullU64(absl::Uint128Low64(high), buffer);
  325|  1.44k|    buffer = EncodePadded16(mid, buffer);
  326|  1.44k|    buffer = EncodePadded16(low, buffer);
  327|  1.44k|  }
  328|  1.56k|  return buffer;
  329|  1.56k|}
numbers.cc:_ZN4absl12_GLOBAL__N_114EncodePadded16EmPc:
  250|  3.00k|inline char* EncodePadded16(uint64_t v, char* absl_nonnull buffer) {
  251|  3.00k|  constexpr uint64_t k1e8 = 100000000;
  252|  3.00k|  uint32_t hi = static_cast<uint32_t>(v / k1e8);
  253|  3.00k|  uint32_t lo = static_cast<uint32_t>(v % k1e8);
  254|  3.00k|  little_endian::Store64(buffer, PrepareEightDigits(hi) + kEightZeroBytes);
  255|  3.00k|  little_endian::Store64(buffer + 8, PrepareEightDigits(lo) + kEightZeroBytes);
  256|  3.00k|  return buffer + 16;
  257|  3.00k|}
numbers.cc:_ZN4abslL10SplitToSixEd:
  921|  3.13k|static ExpDigits SplitToSix(const double value) {
  922|  3.13k|  ExpDigits exp_dig;
  923|  3.13k|  int exp = 5;
  924|  3.13k|  double d = value;
  925|       |  // First step: calculate a close approximation of the output, where the
  926|       |  // value d will be between 100,000 and 999,999, representing the digits
  927|       |  // in the output ASCII array, and exp is the base-10 exponent.  It would be
  928|       |  // faster to use a table here, and to look up the base-2 exponent of value,
  929|       |  // however value is an IEEE-754 64-bit number, so the table would have 2,000
  930|       |  // entries, which is not cache-friendly.
  931|  3.13k|  if (d >= 999999.5) {
  ------------------
  |  Branch (931:7): [True: 3.13k, False: 0]
  ------------------
  932|  3.13k|    if (d >= 1e+261) exp += 256, d *= 1e-256;
  ------------------
  |  Branch (932:9): [True: 1.57k, False: 1.56k]
  ------------------
  933|  3.13k|    if (d >= 1e+133) exp += 128, d *= 1e-128;
  ------------------
  |  Branch (933:9): [True: 0, False: 3.13k]
  ------------------
  934|  3.13k|    if (d >= 1e+69) exp += 64, d *= 1e-64;
  ------------------
  |  Branch (934:9): [True: 0, False: 3.13k]
  ------------------
  935|  3.13k|    if (d >= 1e+37) exp += 32, d *= 1e-32;
  ------------------
  |  Branch (935:9): [True: 2.70k, False: 426]
  ------------------
  936|  3.13k|    if (d >= 1e+21) exp += 16, d *= 1e-16;
  ------------------
  |  Branch (936:9): [True: 426, False: 2.70k]
  ------------------
  937|  3.13k|    if (d >= 1e+13) exp += 8, d *= 1e-8;
  ------------------
  |  Branch (937:9): [True: 1.71k, False: 1.41k]
  ------------------
  938|  3.13k|    if (d >= 1e+9) exp += 4, d *= 1e-4;
  ------------------
  |  Branch (938:9): [True: 1.59k, False: 1.54k]
  ------------------
  939|  3.13k|    if (d >= 1e+7) exp += 2, d *= 1e-2;
  ------------------
  |  Branch (939:9): [True: 1.55k, False: 1.58k]
  ------------------
  940|  3.13k|    if (d >= 1e+6) exp += 1, d *= 1e-1;
  ------------------
  |  Branch (940:9): [True: 2.14k, False: 992]
  ------------------
  941|  3.13k|  } else {
  942|      0|    if (d < 1e-250) exp -= 256, d *= 1e256;
  ------------------
  |  Branch (942:9): [True: 0, False: 0]
  ------------------
  943|      0|    if (d < 1e-122) exp -= 128, d *= 1e128;
  ------------------
  |  Branch (943:9): [True: 0, False: 0]
  ------------------
  944|      0|    if (d < 1e-58) exp -= 64, d *= 1e64;
  ------------------
  |  Branch (944:9): [True: 0, False: 0]
  ------------------
  945|      0|    if (d < 1e-26) exp -= 32, d *= 1e32;
  ------------------
  |  Branch (945:9): [True: 0, False: 0]
  ------------------
  946|      0|    if (d < 1e-10) exp -= 16, d *= 1e16;
  ------------------
  |  Branch (946:9): [True: 0, False: 0]
  ------------------
  947|      0|    if (d < 1e-2) exp -= 8, d *= 1e8;
  ------------------
  |  Branch (947:9): [True: 0, False: 0]
  ------------------
  948|      0|    if (d < 1e+2) exp -= 4, d *= 1e4;
  ------------------
  |  Branch (948:9): [True: 0, False: 0]
  ------------------
  949|      0|    if (d < 1e+4) exp -= 2, d *= 1e2;
  ------------------
  |  Branch (949:9): [True: 0, False: 0]
  ------------------
  950|      0|    if (d < 1e+5) exp -= 1, d *= 1e1;
  ------------------
  |  Branch (950:9): [True: 0, False: 0]
  ------------------
  951|      0|  }
  952|       |  // At this point, d is in the range [99999.5..999999.5) and exp is in the
  953|       |  // range [-324..308]. Since we need to round d up, we want to add a half
  954|       |  // and truncate.
  955|       |  // However, the technique above may have lost some precision, due to its
  956|       |  // repeated multiplication by constants that each may be off by half a bit
  957|       |  // of precision.  This only matters if we're close to the edge though.
  958|       |  // Since we'd like to know if the fractional part of d is close to a half,
  959|       |  // we multiply it by 65536 and see if the fractional part is close to 32768.
  960|       |  // (The number doesn't have to be a power of two,but powers of two are faster)
  961|  3.13k|  uint64_t d64k = static_cast<uint64_t>(d * 65536);
  962|  3.13k|  uint32_t dddddd;  // A 6-digit decimal integer.
  963|  3.13k|  if ((d64k % 65536) == 32767 || (d64k % 65536) == 32768) {
  ------------------
  |  Branch (963:7): [True: 0, False: 3.13k]
  |  Branch (963:34): [True: 0, False: 3.13k]
  ------------------
  964|       |    // OK, it's fairly likely that precision was lost above, which is
  965|       |    // not a surprise given only 52 mantissa bits are available.  Therefore
  966|       |    // redo the calculation using 128-bit numbers.  (64 bits are not enough).
  967|       |
  968|       |    // Start out with digits rounded down; maybe add one below.
  969|      0|    dddddd = static_cast<uint32_t>(d64k / 65536);
  970|       |
  971|       |    // mantissa is a 64-bit integer representing M.mmm... * 2^63.  The actual
  972|       |    // value we're representing, of course, is M.mmm... * 2^exp2.
  973|      0|    int exp2;
  974|      0|    double m = std::frexp(value, &exp2);
  975|      0|    uint64_t mantissa =
  976|      0|        static_cast<uint64_t>(m * (32768.0 * 65536.0 * 65536.0 * 65536.0));
  977|       |    // std::frexp returns an m value in the range [0.5, 1.0), however we
  978|       |    // can't multiply it by 2^64 and convert to an integer because some FPUs
  979|       |    // throw an exception when converting an number higher than 2^63 into an
  980|       |    // integer - even an unsigned 64-bit integer!  Fortunately it doesn't matter
  981|       |    // since m only has 52 significant bits anyway.
  982|      0|    mantissa <<= 1;
  983|      0|    exp2 -= 64;  // not needed, but nice for debugging
  984|       |
  985|       |    // OK, we are here to compare:
  986|       |    //     (dddddd + 0.5) * 10^(exp-5)  vs.  mantissa * 2^exp2
  987|       |    // so we can round up dddddd if appropriate.  Those values span the full
  988|       |    // range of 600 orders of magnitude of IEE 64-bit floating-point.
  989|       |    // Fortunately, we already know they are very close, so we don't need to
  990|       |    // track the base-2 exponent of both sides.  This greatly simplifies the
  991|       |    // the math since the 2^exp2 calculation is unnecessary and the power-of-10
  992|       |    // calculation can become a power-of-5 instead.
  993|       |
  994|      0|    std::pair<uint64_t, uint64_t> edge, val;
  995|      0|    if (exp >= 6) {
  ------------------
  |  Branch (995:9): [True: 0, False: 0]
  ------------------
  996|       |      // Compare (dddddd + 0.5) * 5 ^ (exp - 5) to mantissa
  997|       |      // Since we're tossing powers of two, 2 * dddddd + 1 is the
  998|       |      // same as dddddd + 0.5
  999|      0|      edge = PowFive(2 * dddddd + 1, exp - 5);
 1000|       |
 1001|      0|      val.first = mantissa;
 1002|      0|      val.second = 0;
 1003|      0|    } else {
 1004|       |      // We can't compare (dddddd + 0.5) * 5 ^ (exp - 5) to mantissa as we did
 1005|       |      // above because (exp - 5) is negative.  So we compare (dddddd + 0.5) to
 1006|       |      // mantissa * 5 ^ (5 - exp)
 1007|      0|      edge = PowFive(2 * dddddd + 1, 0);
 1008|       |
 1009|      0|      val = PowFive(mantissa, 5 - exp);
 1010|      0|    }
 1011|       |    // printf("exp=%d %016lx %016lx vs %016lx %016lx\n", exp, val.first,
 1012|       |    //        val.second, edge.first, edge.second);
 1013|      0|    if (val > edge) {
  ------------------
  |  Branch (1013:9): [True: 0, False: 0]
  ------------------
 1014|      0|      dddddd++;
 1015|      0|    } else if (val == edge) {
  ------------------
  |  Branch (1015:16): [True: 0, False: 0]
  ------------------
 1016|      0|      dddddd += (dddddd & 1);
 1017|      0|    }
 1018|  3.13k|  } else {
 1019|       |    // Here, we are not close to the edge.
 1020|  3.13k|    dddddd = static_cast<uint32_t>((d64k + 32768) / 65536);
 1021|  3.13k|  }
 1022|  3.13k|  if (dddddd == 1000000) {
  ------------------
  |  Branch (1022:7): [True: 62, False: 3.07k]
  ------------------
 1023|     62|    dddddd = 100000;
 1024|     62|    exp += 1;
 1025|     62|  }
 1026|  3.13k|  exp_dig.exponent = exp;
 1027|       |
 1028|  3.13k|  uint32_t two_digits = dddddd / 10000;
 1029|  3.13k|  dddddd -= two_digits * 10000;
 1030|  3.13k|  numbers_internal::PutTwoDigits(two_digits, &exp_dig.digits[0]);
 1031|       |
 1032|  3.13k|  two_digits = dddddd / 100;
 1033|  3.13k|  dddddd -= two_digits * 100;
 1034|  3.13k|  numbers_internal::PutTwoDigits(two_digits, &exp_dig.digits[2]);
 1035|       |
 1036|  3.13k|  numbers_internal::PutTwoDigits(dddddd, &exp_dig.digits[4]);
 1037|  3.13k|  return exp_dig;
 1038|  3.13k|}
numbers.cc:_ZN4absl12_GLOBAL__N_124safe_parse_sign_and_baseEPNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPiPb:
 1193|  1.59k|    bool* absl_nonnull negative_ptr /*output*/) {
 1194|  1.59k|  if (text->data() == nullptr) {
  ------------------
  |  Branch (1194:7): [True: 0, False: 1.59k]
  ------------------
 1195|      0|    return false;
 1196|      0|  }
 1197|       |
 1198|  1.59k|  const char* start = text->data();
 1199|  1.59k|  const char* end = start + text->size();
 1200|  1.59k|  int base = *base_ptr;
 1201|       |
 1202|       |  // Consume whitespace.
 1203|  1.59k|  while (start < end &&
  ------------------
  |  Branch (1203:10): [True: 1.59k, False: 0]
  ------------------
 1204|  1.59k|         absl::ascii_isspace(static_cast<unsigned char>(start[0]))) {
  ------------------
  |  Branch (1204:10): [True: 0, False: 1.59k]
  ------------------
 1205|      0|    ++start;
 1206|      0|  }
 1207|  1.59k|  while (start < end &&
  ------------------
  |  Branch (1207:10): [True: 1.59k, False: 0]
  ------------------
 1208|  1.59k|         absl::ascii_isspace(static_cast<unsigned char>(end[-1]))) {
  ------------------
  |  Branch (1208:10): [True: 0, False: 1.59k]
  ------------------
 1209|      0|    --end;
 1210|      0|  }
 1211|  1.59k|  if (start >= end) {
  ------------------
  |  Branch (1211:7): [True: 0, False: 1.59k]
  ------------------
 1212|      0|    return false;
 1213|      0|  }
 1214|       |
 1215|       |  // Consume sign.
 1216|  1.59k|  *negative_ptr = (start[0] == '-');
 1217|  1.59k|  if (*negative_ptr || start[0] == '+') {
  ------------------
  |  Branch (1217:7): [True: 1.37k, False: 218]
  |  Branch (1217:24): [True: 0, False: 218]
  ------------------
 1218|  1.37k|    ++start;
 1219|  1.37k|    if (start >= end) {
  ------------------
  |  Branch (1219:9): [True: 0, False: 1.37k]
  ------------------
 1220|      0|      return false;
 1221|      0|    }
 1222|  1.37k|  }
 1223|       |
 1224|       |  // Consume base-dependent prefix.
 1225|       |  //  base 0: "0x" -> base 16, "0" -> base 8, default -> base 10
 1226|       |  //  base 16: "0x" -> base 16
 1227|       |  // Also validate the base.
 1228|  1.59k|  if (base == 0) {
  ------------------
  |  Branch (1228:7): [True: 0, False: 1.59k]
  ------------------
 1229|      0|    if (end - start >= 2 && start[0] == '0' &&
  ------------------
  |  Branch (1229:9): [True: 0, False: 0]
  |  Branch (1229:29): [True: 0, False: 0]
  ------------------
 1230|      0|        (start[1] == 'x' || start[1] == 'X')) {
  ------------------
  |  Branch (1230:10): [True: 0, False: 0]
  |  Branch (1230:29): [True: 0, False: 0]
  ------------------
 1231|      0|      base = 16;
 1232|      0|      start += 2;
 1233|      0|      if (start >= end) {
  ------------------
  |  Branch (1233:11): [True: 0, False: 0]
  ------------------
 1234|       |        // "0x" with no digits after is invalid.
 1235|      0|        return false;
 1236|      0|      }
 1237|      0|    } else if (end - start >= 1 && start[0] == '0') {
  ------------------
  |  Branch (1237:16): [True: 0, False: 0]
  |  Branch (1237:36): [True: 0, False: 0]
  ------------------
 1238|      0|      base = 8;
 1239|      0|      start += 1;
 1240|      0|    } else {
 1241|      0|      base = 10;
 1242|      0|    }
 1243|  1.59k|  } else if (base == 16) {
  ------------------
  |  Branch (1243:14): [True: 0, False: 1.59k]
  ------------------
 1244|      0|    if (end - start >= 2 && start[0] == '0' &&
  ------------------
  |  Branch (1244:9): [True: 0, False: 0]
  |  Branch (1244:29): [True: 0, False: 0]
  ------------------
 1245|      0|        (start[1] == 'x' || start[1] == 'X')) {
  ------------------
  |  Branch (1245:10): [True: 0, False: 0]
  |  Branch (1245:29): [True: 0, False: 0]
  ------------------
 1246|      0|      start += 2;
 1247|      0|      if (start >= end) {
  ------------------
  |  Branch (1247:11): [True: 0, False: 0]
  ------------------
 1248|       |        // "0x" with no digits after is invalid.
 1249|      0|        return false;
 1250|      0|      }
 1251|      0|    }
 1252|  1.59k|  } else if (base >= 2 && base <= 36) {
  ------------------
  |  Branch (1252:14): [True: 1.59k, False: 0]
  |  Branch (1252:27): [True: 1.59k, False: 0]
  ------------------
 1253|       |    // okay
 1254|  1.59k|  } else {
 1255|      0|    return false;
 1256|      0|  }
 1257|  1.59k|  *text = absl::string_view(start, static_cast<size_t>(end - start));
 1258|  1.59k|  *base_ptr = base;
 1259|  1.59k|  return true;
 1260|  1.59k|}
numbers.cc:_ZN4absl12_GLOBAL__N_117safe_int_internalIiEEbNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPT_i:
 1560|  1.59k|                              IntType* absl_nonnull value_p, int base) {
 1561|  1.59k|  *value_p = 0;
 1562|  1.59k|  bool negative;
 1563|  1.59k|  if (!safe_parse_sign_and_base(&text, &base, &negative)) {
  ------------------
  |  Branch (1563:7): [True: 0, False: 1.59k]
  ------------------
 1564|      0|    return false;
 1565|      0|  }
 1566|  1.59k|  if (!negative) {
  ------------------
  |  Branch (1566:7): [True: 218, False: 1.37k]
  ------------------
 1567|    218|    return safe_parse_positive_int(text, base, value_p);
 1568|  1.37k|  } else {
 1569|  1.37k|    return safe_parse_negative_int(text, base, value_p);
 1570|  1.37k|  }
 1571|  1.59k|}
numbers.cc:_ZN4absl12_GLOBAL__N_123safe_parse_positive_intIiEEbNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEiPT_:
 1478|    218|                                    IntType* absl_nonnull value_p) {
 1479|    218|  IntType value = 0;
 1480|    218|  const IntType vmax = std::numeric_limits<IntType>::max();
 1481|    218|  assert(vmax > 0);
  ------------------
  |  Branch (1481:3): [True: 218, Folded]
  ------------------
 1482|    218|  assert(base >= 0);
  ------------------
  |  Branch (1482:3): [True: 218, False: 0]
  ------------------
 1483|    218|  const IntType base_inttype = static_cast<IntType>(base);
 1484|    218|  assert(vmax >= base_inttype);
  ------------------
  |  Branch (1484:3): [True: 218, False: 0]
  ------------------
 1485|    218|  const IntType vmax_over_base = LookupTables<IntType>::kVmaxOverBase[base];
 1486|    218|  assert(base < 2 ||
  ------------------
  |  Branch (1486:3): [True: 0, False: 218]
  |  Branch (1486:3): [True: 218, False: 0]
  |  Branch (1486:3): [True: 218, False: 0]
  ------------------
 1487|    218|         std::numeric_limits<IntType>::max() / base_inttype == vmax_over_base);
 1488|    218|  const char* start = text.data();
 1489|    218|  const char* end = start + text.size();
 1490|       |  // loop over digits
 1491|  2.22k|  for (; start < end; ++start) {
  ------------------
  |  Branch (1491:10): [True: 2.00k, False: 218]
  ------------------
 1492|  2.00k|    unsigned char c = static_cast<unsigned char>(start[0]);
 1493|  2.00k|    IntType digit = static_cast<IntType>(kAsciiToInt[c]);
 1494|  2.00k|    if (digit >= base_inttype) {
  ------------------
  |  Branch (1494:9): [True: 0, False: 2.00k]
  ------------------
 1495|      0|      *value_p = value;
 1496|      0|      return false;
 1497|      0|    }
 1498|  2.00k|    if (value > vmax_over_base) {
  ------------------
  |  Branch (1498:9): [True: 0, False: 2.00k]
  ------------------
 1499|      0|      *value_p = vmax;
 1500|      0|      return false;
 1501|      0|    }
 1502|  2.00k|    value *= base_inttype;
 1503|  2.00k|    if (value > vmax - digit) {
  ------------------
  |  Branch (1503:9): [True: 0, False: 2.00k]
  ------------------
 1504|      0|      *value_p = vmax;
 1505|      0|      return false;
 1506|      0|    }
 1507|  2.00k|    value += digit;
 1508|  2.00k|  }
 1509|    218|  *value_p = value;
 1510|    218|  return true;
 1511|    218|}
numbers.cc:_ZN4absl12_GLOBAL__N_123safe_parse_negative_intIiEEbNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEiPT_:
 1515|  1.37k|                                    IntType* absl_nonnull value_p) {
 1516|  1.37k|  IntType value = 0;
 1517|  1.37k|  const IntType vmin = std::numeric_limits<IntType>::min();
 1518|  1.37k|  assert(vmin < 0);
  ------------------
  |  Branch (1518:3): [True: 1.37k, Folded]
  ------------------
 1519|  1.37k|  assert(vmin <= 0 - base);
  ------------------
  |  Branch (1519:3): [True: 1.37k, False: 0]
  ------------------
 1520|  1.37k|  IntType vmin_over_base = LookupTables<IntType>::kVminOverBase[base];
 1521|  1.37k|  assert(base < 2 ||
  ------------------
  |  Branch (1521:3): [True: 0, False: 1.37k]
  |  Branch (1521:3): [True: 1.37k, False: 0]
  |  Branch (1521:3): [True: 1.37k, False: 0]
  ------------------
 1522|  1.37k|         std::numeric_limits<IntType>::min() / base == vmin_over_base);
 1523|       |  // 2003 c++ standard [expr.mul]
 1524|       |  // "... the sign of the remainder is implementation-defined."
 1525|       |  // Although (vmin/base)*base + vmin%base is always vmin.
 1526|       |  // 2011 c++ standard tightens the spec but we cannot rely on it.
 1527|       |  // TODO(junyer): Handle this in the lookup table generation.
 1528|  1.37k|  if (vmin % base > 0) {
  ------------------
  |  Branch (1528:7): [True: 0, False: 1.37k]
  ------------------
 1529|      0|    vmin_over_base += 1;
 1530|      0|  }
 1531|  1.37k|  const char* start = text.data();
 1532|  1.37k|  const char* end = start + text.size();
 1533|       |  // loop over digits
 1534|  14.7k|  for (; start < end; ++start) {
  ------------------
  |  Branch (1534:10): [True: 13.3k, False: 1.37k]
  ------------------
 1535|  13.3k|    unsigned char c = static_cast<unsigned char>(start[0]);
 1536|  13.3k|    int digit = kAsciiToInt[c];
 1537|  13.3k|    if (digit >= base) {
  ------------------
  |  Branch (1537:9): [True: 0, False: 13.3k]
  ------------------
 1538|      0|      *value_p = value;
 1539|      0|      return false;
 1540|      0|    }
 1541|  13.3k|    if (value < vmin_over_base) {
  ------------------
  |  Branch (1541:9): [True: 0, False: 13.3k]
  ------------------
 1542|      0|      *value_p = vmin;
 1543|      0|      return false;
 1544|      0|    }
 1545|  13.3k|    value *= base;
 1546|  13.3k|    if (value < vmin + digit) {
  ------------------
  |  Branch (1546:9): [True: 0, False: 13.3k]
  ------------------
 1547|      0|      *value_p = vmin;
 1548|      0|      return false;
 1549|      0|    }
 1550|  13.3k|    value -= digit;
 1551|  13.3k|  }
 1552|  1.37k|  *value_p = value;
 1553|  1.37k|  return true;
 1554|  1.37k|}

_ZN4absl10SimpleAtoiIiEEbNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPT_:
  330|  1.59k|                              int_type* absl_nonnull out) {
  331|  1.59k|  return numbers_internal::safe_strtoi_base(str, out, 10);
  332|  1.59k|}
_ZN4absl16numbers_internal16safe_strtoi_baseIiEEbNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPT_i:
  247|  1.59k|                                    int_type* absl_nonnull out, int base) {
  248|  1.59k|  static_assert(sizeof(*out) == 1 || sizeof(*out) == 2 || sizeof(*out) == 4 ||
  249|  1.59k|                    sizeof(*out) == 8,
  250|  1.59k|                "SimpleAtoi works only with 8, 16, 32, or 64-bit integers.");
  251|  1.59k|  static_assert(!std::is_floating_point_v<int_type>,
  252|  1.59k|                "Use SimpleAtof or SimpleAtod instead.");
  253|  1.59k|  bool parsed;
  254|       |  // These conditions are constexpr bools to suppress MSVC warning C4127.
  255|  1.59k|  constexpr bool kIsSigned = is_signed<int_type>();
  256|  1.59k|  constexpr int kIntTypeSize = sizeof(*out) * 8;
  257|  1.59k|  if (kIsSigned) {
  ------------------
  |  Branch (257:7): [True: 1.59k, Folded]
  ------------------
  258|  1.59k|    if (kIntTypeSize == 64) {
  ------------------
  |  Branch (258:9): [Folded, False: 1.59k]
  ------------------
  259|      0|      int64_t val;
  260|      0|      parsed = numbers_internal::safe_strto64_base(s, &val, base);
  261|      0|      *out = static_cast<int_type>(val);
  262|  1.59k|    } else if (kIntTypeSize == 32) {
  ------------------
  |  Branch (262:16): [True: 1.59k, Folded]
  ------------------
  263|  1.59k|      int32_t val;
  264|  1.59k|      parsed = numbers_internal::safe_strto32_base(s, &val, base);
  265|  1.59k|      *out = static_cast<int_type>(val);
  266|  1.59k|    } else if (kIntTypeSize == 16) {
  ------------------
  |  Branch (266:16): [Folded, False: 0]
  ------------------
  267|      0|      int16_t val;
  268|      0|      parsed = numbers_internal::safe_strto16_base(s, &val, base);
  269|      0|      *out = static_cast<int_type>(val);
  270|      0|    } else if (kIntTypeSize == 8) {
  ------------------
  |  Branch (270:16): [Folded, False: 0]
  ------------------
  271|      0|      int8_t val;
  272|      0|      parsed = numbers_internal::safe_strto8_base(s, &val, base);
  273|      0|      *out = static_cast<int_type>(val);
  274|      0|    }
  275|  1.59k|  } else {
  276|      0|    if (kIntTypeSize == 64) {
  ------------------
  |  Branch (276:9): [Folded, False: 0]
  ------------------
  277|      0|      uint64_t val;
  278|      0|      parsed = numbers_internal::safe_strtou64_base(s, &val, base);
  279|      0|      *out = static_cast<int_type>(val);
  280|      0|    } else if (kIntTypeSize == 32) {
  ------------------
  |  Branch (280:16): [True: 0, Folded]
  ------------------
  281|      0|      uint32_t val;
  282|      0|      parsed = numbers_internal::safe_strtou32_base(s, &val, base);
  283|      0|      *out = static_cast<int_type>(val);
  284|      0|    } else if (kIntTypeSize == 16) {
  ------------------
  |  Branch (284:16): [Folded, False: 0]
  ------------------
  285|      0|      uint16_t val;
  286|      0|      parsed = numbers_internal::safe_strtou16_base(s, &val, base);
  287|      0|      *out = static_cast<int_type>(val);
  288|      0|    } else if (kIntTypeSize == 8) {
  ------------------
  |  Branch (288:16): [Folded, False: 0]
  ------------------
  289|      0|      uint8_t val;
  290|      0|      parsed = numbers_internal::safe_strtou8_base(s, &val, base);
  291|      0|      *out = static_cast<int_type>(val);
  292|      0|    }
  293|      0|  }
  294|  1.59k|  return parsed;
  295|  1.59k|}

_ZN4absl24StringResizeAndOverwriteINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEZNS_16strings_internal13JoinAlgorithmINS1_11__wrap_iterIPKS7_EEvEES7_T_SE_NS1_17basic_string_viewIcS4_EENS8_11NoFormatterEEUlPcmE_EEvRSE_NSE_9size_typeET0_:
  186|  1.59k|void StringResizeAndOverwrite(T& str, typename T::size_type n, Op op) {
  187|  1.59k|  strings_internal::StringResizeAndOverwriteImpl(str, n, std::move(op));
  188|       |#if defined(ABSL_HAVE_MEMORY_SANITIZER)
  189|       |  __msan_check_mem_is_initialized(str.data(), str.size());
  190|       |#endif
  191|  1.59k|}
_ZN4absl16strings_internal28StringResizeAndOverwriteImplINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEZNS0_13JoinAlgorithmINS2_11__wrap_iterIPKS8_EEvEES8_T_SE_NS2_17basic_string_viewIcS5_EENS0_11NoFormatterEEUlPcmE_EEvRSE_NSE_9size_typeET0_:
  149|  1.59k|void StringResizeAndOverwriteImpl(T& str, typename T::size_type n, Op op) {
  150|       |#ifdef ABSL_INTERNAL_HAS_RESIZE_AND_OVERWRITE
  151|       |  str.resize_and_overwrite(n, std::move(op));
  152|       |#else
  153|       |  if constexpr (strings_internal::
  154|       |                    has__google_nonstandard_backport_resize_and_overwrite<
  155|       |                        T>::value) {
  156|       |    str.__google_nonstandard_backport_resize_and_overwrite(n, std::move(op));
  157|       |  } else if constexpr (strings_internal::has__resize_and_overwrite<T>::value) {
  158|       |    str.__resize_and_overwrite(n, std::move(op));
  159|  1.59k|  } else if constexpr (strings_internal::has__resize_default_init<T>::value) {
  160|  1.59k|    str.__resize_default_init(n);
  161|  1.59k|    str.__resize_default_init(
  162|  1.59k|        static_cast<typename T::size_type>(std::move(op)(str.data(), n)));
  163|       |  } else if constexpr (strings_internal::has_Resize_and_overwrite<T>::value) {
  164|       |    str._Resize_and_overwrite(n, std::move(op));
  165|       |  } else {
  166|       |    strings_internal::StringResizeAndOverwriteFallback(str, n, std::move(op));
  167|       |  }
  168|  1.59k|#endif
  169|  1.59k|}
str_cat.cc:_ZN4absl24StringResizeAndOverwriteINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEZNS_16strings_internal9CatPiecesESt16initializer_listINS1_17basic_string_viewIcS4_EEEE3$_0EEvRT_NSE_9size_typeET0_:
  186|  1.59k|void StringResizeAndOverwrite(T& str, typename T::size_type n, Op op) {
  187|  1.59k|  strings_internal::StringResizeAndOverwriteImpl(str, n, std::move(op));
  188|       |#if defined(ABSL_HAVE_MEMORY_SANITIZER)
  189|       |  __msan_check_mem_is_initialized(str.data(), str.size());
  190|       |#endif
  191|  1.59k|}
str_cat.cc:_ZN4absl16strings_internal28StringResizeAndOverwriteImplINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEZNS0_9CatPiecesESt16initializer_listINS2_17basic_string_viewIcS5_EEEE3$_0EEvRT_NSE_9size_typeET0_:
  149|  1.59k|void StringResizeAndOverwriteImpl(T& str, typename T::size_type n, Op op) {
  150|       |#ifdef ABSL_INTERNAL_HAS_RESIZE_AND_OVERWRITE
  151|       |  str.resize_and_overwrite(n, std::move(op));
  152|       |#else
  153|       |  if constexpr (strings_internal::
  154|       |                    has__google_nonstandard_backport_resize_and_overwrite<
  155|       |                        T>::value) {
  156|       |    str.__google_nonstandard_backport_resize_and_overwrite(n, std::move(op));
  157|       |  } else if constexpr (strings_internal::has__resize_and_overwrite<T>::value) {
  158|       |    str.__resize_and_overwrite(n, std::move(op));
  159|  1.59k|  } else if constexpr (strings_internal::has__resize_default_init<T>::value) {
  160|  1.59k|    str.__resize_default_init(n);
  161|  1.59k|    str.__resize_default_init(
  162|  1.59k|        static_cast<typename T::size_type>(std::move(op)(str.data(), n)));
  163|       |  } else if constexpr (strings_internal::has_Resize_and_overwrite<T>::value) {
  164|       |    str._Resize_and_overwrite(n, std::move(op));
  165|       |  } else {
  166|       |    strings_internal::StringResizeAndOverwriteFallback(str, n, std::move(op));
  167|       |  }
  168|  1.59k|#endif
  169|  1.59k|}
str_cat.cc:_ZN4absl16strings_internal28StringResizeAndOverwriteImplINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEZNS0_24StringAppendAndOverwriteIS8_ZNS_9StrAppendEPS8_RKNS_8AlphaNumEE3$_0EEvRT_NSF_9size_typeET0_EUlPcmE_EEvSG_SH_SI_:
  149|  1.59k|void StringResizeAndOverwriteImpl(T& str, typename T::size_type n, Op op) {
  150|       |#ifdef ABSL_INTERNAL_HAS_RESIZE_AND_OVERWRITE
  151|       |  str.resize_and_overwrite(n, std::move(op));
  152|       |#else
  153|       |  if constexpr (strings_internal::
  154|       |                    has__google_nonstandard_backport_resize_and_overwrite<
  155|       |                        T>::value) {
  156|       |    str.__google_nonstandard_backport_resize_and_overwrite(n, std::move(op));
  157|       |  } else if constexpr (strings_internal::has__resize_and_overwrite<T>::value) {
  158|       |    str.__resize_and_overwrite(n, std::move(op));
  159|  1.59k|  } else if constexpr (strings_internal::has__resize_default_init<T>::value) {
  160|  1.59k|    str.__resize_default_init(n);
  161|  1.59k|    str.__resize_default_init(
  162|  1.59k|        static_cast<typename T::size_type>(std::move(op)(str.data(), n)));
  163|       |  } else if constexpr (strings_internal::has_Resize_and_overwrite<T>::value) {
  164|       |    str._Resize_and_overwrite(n, std::move(op));
  165|       |  } else {
  166|       |    strings_internal::StringResizeAndOverwriteFallback(str, n, std::move(op));
  167|       |  }
  168|  1.59k|#endif
  169|  1.59k|}

_ZN4absl16strings_internal9CatPiecesESt16initializer_listINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEE:
  148|  1.59k|std::string CatPieces(std::initializer_list<absl::string_view> pieces) {
  149|  1.59k|  std::string result;
  150|       |  // Use uint64_t to prevent size_t overflow. We assume it is not possible for
  151|       |  // in memory strings to overflow a uint64_t.
  152|  1.59k|  constexpr uint64_t kMaxSize = uint64_t{std::numeric_limits<size_t>::max()};
  153|  1.59k|  uint64_t total_size = 0;
  154|  7.95k|  for (absl::string_view piece : pieces) {
  ------------------
  |  Branch (154:32): [True: 7.95k, False: 1.59k]
  ------------------
  155|  7.95k|    total_size += piece.size();
  156|  7.95k|  }
  157|  1.59k|  ABSL_INTERNAL_CHECK(total_size <= kMaxSize, "size_t overflow");
  ------------------
  |  |   85|  1.59k|  do {                                                             \
  |  |   86|  1.59k|    if (ABSL_PREDICT_FALSE(!(condition))) {                        \
  |  |  ------------------
  |  |  |  |  190|  1.59k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 1.59k]
  |  |  |  |  |  Branch (190:49): [Folded, False: 1.59k]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 1.59k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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, \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   80|      0|        __LINE__, message);                                               \
  |  |  |  |   81|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   82|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (82:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|    }                                                              \
  |  |   91|  1.59k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (91:12): [Folded, False: 1.59k]
  |  |  ------------------
  ------------------
  |  Branch (157:3): [Folded, False: 0]
  |  Branch (157:3): [True: 0, Folded]
  |  Branch (157:3): [Folded, False: 0]
  ------------------
  158|  1.59k|  absl::StringResizeAndOverwrite(result, static_cast<size_t>(total_size),
  159|  1.59k|                                 [&pieces](char* const begin, size_t buf_size) {
  160|  1.59k|                                   char* out = begin;
  161|  1.59k|                                   for (absl::string_view piece : pieces) {
  162|  1.59k|                                     const size_t this_size = piece.size();
  163|  1.59k|                                     if (this_size != 0) {
  164|  1.59k|                                       memcpy(out, piece.data(), this_size);
  165|  1.59k|                                       out += this_size;
  166|  1.59k|                                     }
  167|  1.59k|                                   }
  168|  1.59k|                                   assert(out == begin + buf_size);
  169|  1.59k|                                   return buf_size;
  170|  1.59k|                                 });
  171|  1.59k|  return result;
  172|  1.59k|}
_ZN4absl9StrAppendEPNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEERKNS_8AlphaNumE:
  207|  1.59k|void StrAppend(std::string* absl_nonnull dest, const AlphaNum& a) {
  208|  1.59k|  ASSERT_NO_OVERLAP(*dest, a);
  ------------------
  |  |  180|  1.59k|  assert(((src).size() == 0) ||      \
  |  |  181|  1.59k|         (uintptr_t((src).data() - (dest).data()) > uintptr_t((dest).size())))
  ------------------
  |  Branch (208:3): [True: 1.15k, False: 433]
  |  Branch (208:3): [True: 433, False: 0]
  |  Branch (208:3): [True: 1.59k, False: 0]
  ------------------
  209|  1.59k|  strings_internal::StringAppendAndOverwrite(
  210|  1.59k|      *dest, a.size(), [&a](char* const buf, size_t buf_size) {
  211|  1.59k|        char* out = buf;
  212|  1.59k|        out = Append(out, a);
  213|  1.59k|        assert(out == buf + buf_size);
  214|  1.59k|        return buf_size;
  215|  1.59k|      });
  216|  1.59k|}
str_cat.cc:_ZN4absl12_GLOBAL__N_16AppendEPcRKNS_8AlphaNumE:
   48|  1.59k|inline char* absl_nonnull Append(char* absl_nonnull out, const AlphaNum& x) {
   49|       |  // memcpy is allowed to overwrite arbitrary memory, so doing this after the
   50|       |  // call would force an extra fetch of x.size().
   51|  1.59k|  char* after = out + x.size();
   52|  1.59k|  if (x.size() != 0) {
  ------------------
  |  Branch (52:7): [True: 433, False: 1.15k]
  ------------------
   53|    433|    memcpy(out, x.data(), x.size());
   54|    433|  }
   55|  1.59k|  return after;
   56|  1.59k|}
str_cat.cc:_ZZN4absl16strings_internal9CatPiecesESt16initializer_listINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEENK3$_0clEPcm:
  159|  1.59k|                                 [&pieces](char* const begin, size_t buf_size) {
  160|  1.59k|                                   char* out = begin;
  161|  7.95k|                                   for (absl::string_view piece : pieces) {
  ------------------
  |  Branch (161:65): [True: 7.95k, False: 1.59k]
  ------------------
  162|  7.95k|                                     const size_t this_size = piece.size();
  163|  7.95k|                                     if (this_size != 0) {
  ------------------
  |  Branch (163:42): [True: 7.22k, False: 732]
  ------------------
  164|  7.22k|                                       memcpy(out, piece.data(), this_size);
  165|  7.22k|                                       out += this_size;
  166|  7.22k|                                     }
  167|  7.95k|                                   }
  168|  1.59k|                                   assert(out == begin + buf_size);
  ------------------
  |  Branch (168:36): [True: 1.59k, False: 0]
  ------------------
  169|  1.59k|                                   return buf_size;
  170|  1.59k|                                 });
str_cat.cc:_ZZN4absl9StrAppendEPNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEERKNS_8AlphaNumEENK3$_0clEPcm:
  210|  1.59k|      *dest, a.size(), [&a](char* const buf, size_t buf_size) {
  211|  1.59k|        char* out = buf;
  212|  1.59k|        out = Append(out, a);
  213|  1.59k|        assert(out == buf + buf_size);
  ------------------
  |  Branch (213:9): [True: 1.59k, False: 0]
  ------------------
  214|  1.59k|        return buf_size;
  215|  1.59k|      });

_ZN4absl8AlphaNumC2Ef:
  384|  1.59k|      : piece_(digits_, numbers_internal::SixDigitsToBuffer(f, digits_)) {}
_ZN4absl8AlphaNumC2Ed:
  386|  1.59k|      : piece_(digits_, numbers_internal::SixDigitsToBuffer(f, digits_)) {}
_ZN4absl8AlphaNumC2Ei:
  359|  3.18k|      : piece_(digits_, static_cast<size_t>(
  360|  3.18k|                            numbers_internal::FastIntToBuffer(x, digits_) -
  361|  3.18k|                            &digits_[0])) {}
_ZN4absl8AlphaNumC2INSt3__19allocatorIcEEEERKNS2_12basic_stringIcNS2_11char_traitsIcEET_EE:
  417|  3.18k|      : piece_(str) {}
_ZN4absl6StrCatIJEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_8AlphaNumESA_SA_SA_SA_DpRKT_:
  595|  1.59k|                                        const AlphaNum& e, const AV&... args) {
  596|  1.59k|  return strings_internal::CatPieces(
  597|  1.59k|      {a.Piece(), b.Piece(), c.Piece(), d.Piece(), e.Piece(),
  598|  1.59k|       static_cast<const AlphaNum&>(args).Piece()...});
  599|  1.59k|}
_ZNK4absl8AlphaNum5PieceEv:
  427|  7.95k|  absl::string_view Piece() const { return piece_; }
_ZNK4absl8AlphaNum4sizeEv:
  425|  6.79k|  absl::string_view::size_type size() const { return piece_.size(); }
_ZNK4absl8AlphaNum4dataEv:
  426|    866|  const char* absl_nullable data() const { return piece_.data(); }

_ZN4absl9StrFormatIJfEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_19str_format_internal18FormatSpecTemplateIJXspclsr19str_format_internalE14ArgumentToConvIT_EEEEEEDpRKSA_:
  366|  1.59k|                                    const Args&... args) {
  367|  1.59k|  return str_format_internal::FormatPack(
  368|  1.59k|      str_format_internal::UntypedFormatSpecImpl::Extract(format),
  369|  1.59k|      {str_format_internal::FormatArgImpl(args)...});
  370|  1.59k|}
_ZN4absl17UntypedFormatSpecC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  112|  6.36k|  explicit UntypedFormatSpec(string_view s) : spec_(s) {}
_ZN4absl9StrFormatIJdEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_19str_format_internal18FormatSpecTemplateIJXspclsr19str_format_internalE14ArgumentToConvIT_EEEEEEDpRKSA_:
  366|  1.59k|                                    const Args&... args) {
  367|  1.59k|  return str_format_internal::FormatPack(
  368|  1.59k|      str_format_internal::UntypedFormatSpecImpl::Extract(format),
  369|  1.59k|      {str_format_internal::FormatArgImpl(args)...});
  370|  1.59k|}
_ZN4absl9StrFormatIJiEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_19str_format_internal18FormatSpecTemplateIJXspclsr19str_format_internalE14ArgumentToConvIT_EEEEEEDpRKSA_:
  366|  1.59k|                                    const Args&... args) {
  367|  1.59k|  return str_format_internal::FormatPack(
  368|  1.59k|      str_format_internal::UntypedFormatSpecImpl::Extract(format),
  369|  1.59k|      {str_format_internal::FormatArgImpl(args)...});
  370|  1.59k|}
_ZN4absl9StrFormatIJbEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_19str_format_internal18FormatSpecTemplateIJXspclsr19str_format_internalE14ArgumentToConvIT_EEEEEEDpRKSA_:
  366|  1.59k|                                    const Args&... args) {
  367|  1.59k|  return str_format_internal::FormatPack(
  368|  1.59k|      str_format_internal::UntypedFormatSpecImpl::Extract(format),
  369|  1.59k|      {str_format_internal::FormatArgImpl(args)...});
  370|  1.59k|}

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

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

_ZN4absl8StrSplitIPKcEENS_16strings_internal8SplitterINS3_15SelectDelimiterIT_E4typeENS_10AllowEmptyENSt3__117basic_string_viewIcNSA_11char_traitsIcEEEEEENS3_23ConvertibleToStringViewES6_:
  539|  1.59k|StrSplit(strings_internal::ConvertibleToStringView text, Delimiter d) {
  540|  1.59k|  using DelimiterType =
  541|  1.59k|      typename strings_internal::SelectDelimiter<Delimiter>::type;
  542|  1.59k|  return strings_internal::Splitter<DelimiterType, AllowEmpty,
  543|  1.59k|                                    absl::string_view>(
  544|  1.59k|      text.value(), DelimiterType(d), AllowEmpty());
  545|  1.59k|}
_ZNK4absl10AllowEmptyclENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  348|  19.5M|  bool operator()(absl::string_view) const { return true; }

_ZN4absl4SpanIKNS_19str_format_internal13FormatArgImplEEC2IS3_S3_EESt16initializer_listIS2_E:
  308|  6.36k|      : Span(v.begin(), v.size()) {}
_ZN4absl4SpanIKNS_19str_format_internal13FormatArgImplEEC2EPS3_m:
  228|  6.36k|      : ptr_(array), len_(length) {}
_ZNK4absl4SpanIKNS_19str_format_internal13FormatArgImplEE4sizeEv:
  321|  12.7k|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl4SpanIKNS_19str_format_internal13FormatArgImplEEixEm:
  336|  6.36k|  constexpr reference operator[](size_type i) const noexcept {
  337|  6.36k|    absl::base_internal::HardeningAssertLT(i, size());
  338|  6.36k|    return ptr_[i];
  339|  6.36k|  }
_ZN4absl8MakeSpanITpTnRiJEjLm128EEENS_4SpanIT0_EERAT1__S3_:
  757|  3.14k|    T (&array ABSL_ATTRIBUTE_LIFETIME_BOUND)[N]) noexcept {
  758|  3.14k|  return Span<T>(array, N);
  759|  3.14k|}
_ZN4absl4SpanIjEC2EPjm:
  228|  3.14k|      : ptr_(array), len_(length) {}
_ZNK4absl4SpanIjEixEm:
  336|  3.83M|  constexpr reference operator[](size_type i) const noexcept {
  337|  3.83M|    absl::base_internal::HardeningAssertLT(i, size());
  338|  3.83M|    return ptr_[i];
  339|  3.83M|  }
_ZNK4absl4SpanIjE4sizeEv:
  321|  3.83M|  constexpr size_type size() const noexcept { return len_; }

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