_ZN4absl8bit_castIdmTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS4_EE5valuesr3std21is_trivially_copyableIS3_EE5valueEiE4typeELi0EEES3_RKS4_:
  190|  1.40k|inline constexpr Dest bit_cast(const Source& source) {
  191|  1.40k|  return __builtin_bit_cast(Dest, source);
  192|  1.40k|}
_ZN4absl8bit_castIfjTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS4_EE5valuesr3std21is_trivially_copyableIS3_EE5valueEiE4typeELi0EEES3_RKS4_:
  190|  1.39k|inline constexpr Dest bit_cast(const Source& source) {
  191|  1.39k|  return __builtin_bit_cast(Dest, source);
  192|  1.39k|}

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

_ZN4absl13base_internal17HardeningAssertLTImEEvT_S2_:
   88|  3.43M|constexpr void HardeningAssertLT(T val1, T val2) {
   89|  3.43M|  ABSL_ASSERT(val1 < val2);
  ------------------
  |  |  130|  3.43M|  (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
  |  |  ------------------
  |  |  |  |  191|  3.43M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (191:30): [True: 3.43M, False: 0]
  |  |  |  |  |  Branch (191:48): [Folded, False: 3.43M]
  |  |  |  |  |  Branch (191:57): [True: 3.43M, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  131|  3.43M|                             : assert(false && #expr))  // NOLINT
  ------------------
  |  Branch (89:3): [Folded, False: 0]
  |  Branch (89:3): [True: 0, Folded]
  |  Branch (89:3): [Folded, False: 0]
  ------------------
   90|       |#if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)
   91|       |  if (!ABSL_PREDICT_TRUE(val1 < val2)) {
   92|       |    ABSL_INTERNAL_HARDENING_ABORT();
   93|       |  }
   94|       |#endif
   95|  3.43M|}
_ZN4absl13base_internal17HardeningAssertGEImEEvT_S2_:
   78|  1.41k|constexpr void HardeningAssertGE(T val1, T val2) {
   79|  1.41k|  ABSL_ASSERT(val1 >= val2);
  ------------------
  |  |  130|  1.41k|  (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
  |  |  ------------------
  |  |  |  |  191|  1.41k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (191:30): [True: 1.41k, False: 0]
  |  |  |  |  |  Branch (191:48): [Folded, False: 1.41k]
  |  |  |  |  |  Branch (191:57): [True: 1.41k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  131|  1.41k|                             : assert(false && #expr))  // NOLINT
  ------------------
  |  Branch (79:3): [Folded, False: 0]
  |  Branch (79:3): [True: 0, Folded]
  |  Branch (79:3): [Folded, False: 0]
  ------------------
   80|       |#if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)
   81|       |  if (!ABSL_PREDICT_TRUE(val1 >= val2)) {
   82|       |    ABSL_INTERNAL_HARDENING_ABORT();
   83|       |  }
   84|       |#endif
   85|  1.41k|}
_ZN4absl13base_internal17HardeningAssertLEImEEvT_S2_:
   98|  1.41k|constexpr void HardeningAssertLE(T val1, T val2) {
   99|  1.41k|  ABSL_ASSERT(val1 <= val2);
  ------------------
  |  |  130|  1.41k|  (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
  |  |  ------------------
  |  |  |  |  191|  1.41k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (191:30): [True: 1.41k, False: 0]
  |  |  |  |  |  Branch (191:48): [Folded, False: 1.41k]
  |  |  |  |  |  Branch (191:57): [True: 1.41k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  131|  1.41k|                             : assert(false && #expr))  // NOLINT
  ------------------
  |  Branch (99:3): [Folded, False: 0]
  |  Branch (99:3): [True: 0, Folded]
  |  Branch (99:3): [Folded, False: 0]
  ------------------
  100|       |#if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)
  101|       |  if (!ABSL_PREDICT_TRUE(val1 <= val2)) {
  102|       |    ABSL_INTERNAL_HARDENING_ABORT();
  103|       |  }
  104|       |#endif
  105|  1.41k|}

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

_ZNK4absl11FunctionRefIFvNS_4SpanIjEEEEclES2_:
  164|  2.80k|  R operator()(Args... args) const {
  165|  2.80k|    return invoker_(ptr_, std::forward<Args>(args)...);
  166|  2.80k|  }
float_conversion.cc:_ZN4absl11FunctionRefIFvNS_4SpanIjEEEEC2IZNS_19str_format_internal12_GLOBAL__N_115BinaryToDecimal13RunConversionENS_7uint128EiNS0_IFvS8_EEEEUlS2_E_vEEOT_:
  112|  2.80k|      : 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|  2.80k|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|  2.80k|    absl::functional_internal::AssertNonNull(f);
  102|  2.80k|    ptr_.obj = &f;
  103|  2.80k|  }
float_conversion.cc:_ZNK4absl11FunctionRefIFvNS_19str_format_internal12_GLOBAL__N_115BinaryToDecimalEEEclES3_:
  164|  2.80k|  R operator()(Args... args) const {
  165|  2.80k|    return invoker_(ptr_, std::forward<Args>(args)...);
  166|  2.80k|  }
float_conversion.cc:_ZN4absl11FunctionRefIFvNS_19str_format_internal12_GLOBAL__N_115BinaryToDecimalEEEC2IZNS2_22FormatEPositiveExpSlowENS_7uint128EibRKNS2_11FormatStateEmE3$_0vEEOT_:
  112|  1.40k|      : 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.40k|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|  1.40k|    absl::functional_internal::AssertNonNull(f);
  102|  1.40k|    ptr_.obj = &f;
  103|  1.40k|  }
float_conversion.cc:_ZN4absl11FunctionRefIFvNS_19str_format_internal12_GLOBAL__N_115BinaryToDecimalEEEC2IZNS2_22FormatGPositiveExpSlowImEEvT_ibRKNS2_11FormatStateEEUlS3_E_vEEOS8_:
  112|  1.40k|      : 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.40k|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|  1.40k|    absl::functional_internal::AssertNonNull(f);
  102|  1.40k|    ptr_.obj = &f;
  103|  1.40k|  }

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

_ZN4absl11countl_zeroImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES3_:
  108|  7.03k|    countl_zero(T x) noexcept {
  109|  7.03k|  return numeric_internal::CountLeadingZeroes(x);
  110|  7.03k|}
_ZN4absl11countr_zeroImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES3_:
  123|  4.37k|    countr_zero(T x) noexcept {
  124|  4.37k|  return numeric_internal::CountTrailingZeroes(x);
  125|  4.37k|}

_ZN4absl7uint128rSEi:
  631|  5.91k|inline uint128& uint128::operator>>=(int amount) {
  632|  5.91k|  *this = *this >> amount;
  633|  5.91k|  return *this;
  634|  5.91k|}
_ZN4absl7uint128pLES0_:
  636|     78|inline uint128& uint128::operator+=(uint128 other) {
  637|     78|  *this = *this + other;
  638|     78|  return *this;
  639|     78|}
_ZN4absl7uint128dVES0_:
  651|  1.39k|inline uint128& uint128::operator/=(uint128 other) {
  652|  1.39k|  *this = *this / other;
  653|  1.39k|  return *this;
  654|  1.39k|}
_ZN4absl12Uint128Low64ENS_7uint128E:
  661|  7.06k|constexpr uint64_t Uint128Low64(uint128 v) { return v.lo_; }
_ZN4absl13Uint128High64ENS_7uint128E:
  663|  10.0k|constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; }
_ZNK4absl7uint128cvbEv:
  737|  5.91k|constexpr uint128::operator bool() const { return lo_ || hi_; }
  ------------------
  |  Branch (737:51): [True: 3.10k, False: 2.80k]
  |  Branch (737:58): [True: 0, False: 2.80k]
  ------------------
_ZNK4absl7uint128cvjEv:
  770|  5.91k|constexpr uint128::operator unsigned int() const {
  771|  5.91k|  return static_cast<unsigned int>(lo_);
  772|  5.91k|}
_ZNK4absl7uint128cvoEv:
  794|  30.0k|constexpr uint128::operator unsigned __int128() const {
  795|  30.0k|  return (static_cast<unsigned __int128>(hi_) << 64) + lo_;
  796|  30.0k|}
_ZN4absleqENS_7uint128ES0_:
  820|  1.39k|constexpr bool operator==(uint128 lhs, uint128 rhs) {
  821|  1.39k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  822|  1.39k|  return static_cast<unsigned __int128>(lhs) ==
  823|  1.39k|         static_cast<unsigned __int128>(rhs);
  824|       |#else
  825|       |  return (Uint128Low64(lhs) == Uint128Low64(rhs) &&
  826|       |          Uint128High64(lhs) == Uint128High64(rhs));
  827|       |#endif
  828|  1.39k|}
_ZN4absllsENS_7uint128Ei:
  960|  4.20k|constexpr uint128 operator<<(uint128 lhs, int amount) {
  961|  4.20k|#ifdef ABSL_HAVE_INTRINSIC_INT128
  962|  4.20k|  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.20k|}
_ZN4abslrsENS_7uint128Ei:
  974|  5.91k|constexpr uint128 operator>>(uint128 lhs, int amount) {
  975|  5.91k|#ifdef ABSL_HAVE_INTRINSIC_INT128
  976|  5.91k|  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|  5.91k|}
_ZN4abslplENS_7uint128ES0_:
  999|     78|constexpr uint128 operator+(uint128 lhs, uint128 rhs) {
 1000|     78|#if defined(ABSL_HAVE_INTRINSIC_INT128)
 1001|     78|  return static_cast<unsigned __int128>(lhs) +
 1002|     78|         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|     78|}
_ZN4abslmlENS_7uint128ES0_:
 1059|  2.88k|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|  2.88k|  return static_cast<unsigned __int128>(lhs) *
 1063|  2.88k|         static_cast<unsigned __int128>(rhs);
 1064|  2.88k|}
_ZN4absldvENS_7uint128ES0_:
 1066|  2.79k|constexpr uint128 operator/(uint128 lhs, uint128 rhs) {
 1067|  2.79k|  return static_cast<unsigned __int128>(lhs) /
 1068|  2.79k|         static_cast<unsigned __int128>(rhs);
 1069|  2.79k|}
_ZN4abslrmENS_7uint128ES0_:
 1071|  2.79k|constexpr uint128 operator%(uint128 lhs, uint128 rhs) {
 1072|  2.79k|  return static_cast<unsigned __int128>(lhs) %
 1073|  2.79k|         static_cast<unsigned __int128>(rhs);
 1074|  2.79k|}
_ZN4absl7uint128C2Eo:
  692|  18.6k|    : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
  693|  18.6k|      hi_{static_cast<uint64_t>(v >> 64)} {}
_ZN4absl7uint128C2Ei:
  672|  1.39k|    : lo_{static_cast<uint64_t>(v)},
  673|  1.39k|      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {}
  ------------------
  |  Branch (673:11): [True: 0, False: 1.39k]
  ------------------
_ZN4absl7uint128C2Em:
  683|  15.6k|constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {}

_ZN4absl16numeric_internal20CountLeadingZeroes64Em:
  214|  7.03k|CountLeadingZeroes64(uint64_t x) {
  215|  7.03k|#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.03k|  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
  221|  7.03k|                "__builtin_clzll does not take 64-bit arg");
  222|       |
  223|       |  // Handle 0 as a special case because __builtin_clzll(0) is undefined.
  224|  7.03k|  return x == 0 ? 64 : __builtin_clzll(x);
  ------------------
  |  Branch (224:10): [True: 36, False: 7.00k]
  ------------------
  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.03k|}
_ZN4absl16numeric_internal28CountTrailingZeroesNonzero64Em:
  307|  4.37k|CountTrailingZeroesNonzero64(uint64_t x) {
  308|  4.37k|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctzll)
  309|  4.37k|  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
  310|  4.37k|                "__builtin_ctzll does not take 64-bit arg");
  311|  4.37k|  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.37k|}
_ZN4absl16numeric_internal18CountLeadingZeroesImEEiT_:
  268|  7.03k|CountLeadingZeroes(T x) {
  269|  7.03k|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  270|  7.03k|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  271|  7.03k|                "T must have a power-of-2 size");
  272|  7.03k|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  273|  7.03k|  return sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (273:10): [Folded, False: 7.03k]
  ------------------
  274|  7.03k|             ? CountLeadingZeroes16(static_cast<uint16_t>(x)) -
  275|      0|                   (std::numeric_limits<uint16_t>::digits -
  276|      0|                    std::numeric_limits<T>::digits)
  277|  7.03k|             : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (277:17): [Folded, False: 7.03k]
  ------------------
  278|  7.03k|                    ? CountLeadingZeroes32(static_cast<uint32_t>(x)) -
  279|      0|                          (std::numeric_limits<uint32_t>::digits -
  280|      0|                           std::numeric_limits<T>::digits)
  281|  7.03k|                    : CountLeadingZeroes64(x));
  282|  7.03k|}
_ZN4absl16numeric_internal19CountTrailingZeroesImEEiT_:
  353|  4.37k|CountTrailingZeroes(T x) noexcept {
  354|  4.37k|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  355|  4.37k|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  356|  4.37k|                "T must have a power-of-2 size");
  357|  4.37k|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  358|  4.37k|  return x == 0 ? std::numeric_limits<T>::digits
  ------------------
  |  Branch (358:10): [True: 0, False: 4.37k]
  ------------------
  359|  4.37k|                : (sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (359:20): [Folded, False: 4.37k]
  ------------------
  360|  4.37k|                       ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x))
  361|  4.37k|                       : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (361:27): [Folded, False: 4.37k]
  ------------------
  362|  4.37k|                              ? CountTrailingZeroesNonzero32(
  363|      0|                                    static_cast<uint32_t>(x))
  364|  4.37k|                              : CountTrailingZeroesNonzero64(x)));
  365|  4.37k|}

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

_ZN4absl10from_charsEPKcS1_RdNS_12chars_formatE:
  949|  1.41k|                             chars_format fmt) {
  950|  1.41k|  return FromCharsImpl(first, last, value, fmt);
  951|  1.41k|}
_ZN4absl10from_charsEPKcS1_RfNS_12chars_formatE:
  955|  1.41k|                             chars_format fmt) {
  956|  1.41k|  return FromCharsImpl(first, last, value, fmt);
  957|  1.41k|}
charconv.cc:_ZN4absl12_GLOBAL__N_113FromCharsImplIdEENS_17from_chars_resultEPKcS4_RT_NS_12chars_formatE:
  862|  1.41k|                                chars_format fmt_flags) {
  863|  1.41k|  from_chars_result result;
  864|  1.41k|  result.ptr = first;  // overwritten on successful parse
  865|  1.41k|  result.ec = std::errc();
  866|       |
  867|  1.41k|  bool negative = false;
  868|  1.41k|  if (first != last && *first == '-') {
  ------------------
  |  Branch (868:7): [True: 1.41k, False: 0]
  |  Branch (868:24): [True: 935, False: 484]
  ------------------
  869|    935|    ++first;
  870|    935|    negative = true;
  871|    935|  }
  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.41k|  if ((fmt_flags & chars_format::hex) == chars_format{} && last - first >= 2 &&
  ------------------
  |  Branch (874:7): [True: 1.41k, False: 0]
  |  Branch (874:60): [True: 1.40k, False: 15]
  ------------------
  875|  1.40k|      *first == '0' && (first[1] == 'x' || first[1] == 'X')) {
  ------------------
  |  Branch (875:7): [True: 0, False: 1.40k]
  |  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.41k|  if ((fmt_flags & chars_format::hex) == chars_format::hex) {
  ------------------
  |  Branch (907:7): [True: 0, False: 1.41k]
  ------------------
  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.41k|  } else {
  923|  1.41k|    strings_internal::ParsedFloat decimal_parse =
  924|  1.41k|        strings_internal::ParseFloat<10>(first, last, fmt_flags);
  925|  1.41k|    if (decimal_parse.end == nullptr) {
  ------------------
  |  Branch (925:9): [True: 0, False: 1.41k]
  ------------------
  926|      0|      result.ec = std::errc::invalid_argument;
  927|      0|      return result;
  928|      0|    }
  929|  1.41k|    result.ptr = decimal_parse.end;
  930|  1.41k|    if (HandleEdgeCase(decimal_parse, negative, &value)) {
  ------------------
  |  Branch (930:9): [True: 15, False: 1.40k]
  ------------------
  931|     15|      return result;
  932|     15|    }
  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.40k|    if ((decimal_parse.subrange_begin == nullptr) &&
  ------------------
  |  Branch (935:9): [True: 1.40k, False: 0]
  ------------------
  936|  1.40k|        EiselLemire<FloatType>(decimal_parse, negative, &value, &result.ec)) {
  ------------------
  |  Branch (936:9): [True: 1.40k, False: 0]
  ------------------
  937|  1.40k|      return result;
  938|  1.40k|    }
  939|      0|    CalculatedFloat calculated =
  940|      0|        CalculateFromParsedDecimal<FloatType>(decimal_parse);
  941|      0|    EncodeResult(calculated, negative, &result, &value);
  942|      0|    return result;
  943|  1.40k|  }
  944|  1.41k|}
charconv.cc:_ZN4absl12_GLOBAL__N_114HandleEdgeCaseIdEEbRKNS_16strings_internal11ParsedFloatEbPT_:
  360|  1.41k|                    FloatType* absl_nonnull value) {
  361|  1.41k|  if (input.type == strings_internal::FloatType::kNan) {
  ------------------
  |  Branch (361:7): [True: 0, False: 1.41k]
  ------------------
  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.41k|  if (input.type == strings_internal::FloatType::kInfinity) {
  ------------------
  |  Branch (386:7): [True: 0, False: 1.41k]
  ------------------
  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.41k|  if (input.mantissa == 0) {
  ------------------
  |  Branch (391:7): [True: 15, False: 1.40k]
  ------------------
  392|     15|    *value = negative ? -0.0f : 0.0f;
  ------------------
  |  Branch (392:14): [True: 0, False: 15]
  ------------------
  393|     15|    return true;
  394|     15|  }
  395|  1.40k|  return false;
  396|  1.41k|}
charconv.cc:_ZN4absl12_GLOBAL__N_111EiselLemireIdEEbRKNS_16strings_internal11ParsedFloatEbPT_PNSt3__14errcE:
  687|  1.40k|                 FloatType* absl_nonnull value, std::errc* absl_nonnull ec) {
  688|  1.40k|  uint64_t man = input.mantissa;
  689|  1.40k|  int exp10 = input.exponent;
  690|  1.40k|  if (exp10 < FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10) {
  ------------------
  |  Branch (690:7): [True: 0, False: 1.40k]
  ------------------
  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.40k|  } else if (exp10 >= FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10) {
  ------------------
  |  Branch (694:14): [True: 0, False: 1.40k]
  ------------------
  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.40k|  static_assert(
  706|  1.40k|      FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10 >=
  707|  1.40k|          kPower10TableMinInclusive,
  708|  1.40k|      "(exp10-kPower10TableMinInclusive) in kPower10MantissaHighTable bounds");
  709|  1.40k|  static_assert(
  710|  1.40k|      FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10 <=
  711|  1.40k|          kPower10TableMaxExclusive,
  712|  1.40k|      "(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.40k|  int clz = countl_zero(man);
  728|  1.40k|  man <<= static_cast<unsigned int>(clz);
  729|       |  // The 217706 etc magic numbers are from the Power10Exponent function.
  730|  1.40k|  uint64_t ret_exp2 =
  731|  1.40k|      static_cast<uint64_t>((217706 * exp10 >> 16) + 64 +
  732|  1.40k|                            FloatTraits<FloatType>::kExponentBias - clz);
  733|       |
  734|       |  // (+) Multiplication.
  735|  1.40k|  uint128 x = static_cast<uint128>(man) *
  736|  1.40k|              static_cast<uint128>(
  737|  1.40k|                  kPower10MantissaHighTable[exp10 - kPower10TableMinInclusive]);
  738|       |
  739|       |  // (+) Wider Approximation.
  740|  1.40k|  static constexpr uint64_t high64_mask =
  741|  1.40k|      FloatTraits<FloatType>::kEiselLemireMask;
  742|  1.40k|  if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (742:7): [True: 84, False: 1.32k]
  ------------------
  743|     84|      (man > (std::numeric_limits<uint64_t>::max() - Uint128Low64(x)))) {
  ------------------
  |  Branch (743:7): [True: 78, False: 6]
  ------------------
  744|     78|    uint128 y =
  745|     78|        static_cast<uint128>(man) *
  746|     78|        static_cast<uint128>(
  747|     78|            kPower10MantissaLowTable[exp10 - kPower10TableMinInclusive]);
  748|     78|    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|     78|    if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (758:9): [True: 55, False: 23]
  ------------------
  759|     55|        ((Uint128Low64(x) + 1) == 0) &&
  ------------------
  |  Branch (759:9): [True: 0, False: 55]
  ------------------
  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|     78|  }
  764|       |
  765|       |  // (+) Shifting to 54 Bits (or for single precision, to 25 bits).
  766|  1.40k|  uint64_t msb = Uint128High64(x) >> 63;
  767|  1.40k|  uint64_t ret_man =
  768|  1.40k|      Uint128High64(x) >> (msb + FloatTraits<FloatType>::kEiselLemireShift);
  769|  1.40k|  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.40k|  if ((Uint128Low64(x) == 0) && ((Uint128High64(x) & high64_mask) == 0) &&
  ------------------
  |  Branch (780:7): [True: 8, False: 1.39k]
  |  Branch (780:33): [True: 0, False: 8]
  ------------------
  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.40k|  ret_man += ret_man & 1;  // Line From54a.
  787|  1.40k|  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.40k|  if ((ret_man >> FloatTraits<FloatType>::kTargetMantissaBits) > 0) {
  ------------------
  |  Branch (796:7): [True: 0, False: 1.40k]
  ------------------
  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.40k|  static constexpr uint64_t max_exp2 =
  821|  1.40k|      (1 << FloatTraits<FloatType>::kTargetExponentBits) - 1;
  822|  1.40k|  if ((ret_exp2 - 1) >= (max_exp2 - 1)) {
  ------------------
  |  Branch (822:7): [True: 0, False: 1.40k]
  ------------------
  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.40k|  if (FloatTraits<FloatType>::kTargetBits == 64) {
  ------------------
  |  Branch (839:7): [True: 1.40k, Folded]
  ------------------
  840|  1.40k|    uint64_t ret_bits = (ret_exp2 << 52) | (ret_man & 0x000FFFFFFFFFFFFFu);
  841|  1.40k|    if (negative) {
  ------------------
  |  Branch (841:9): [True: 935, False: 469]
  ------------------
  842|    935|      ret_bits |= 0x8000000000000000u;
  843|    935|    }
  844|  1.40k|    *value = static_cast<FloatType>(absl::bit_cast<double>(ret_bits));
  845|  1.40k|    return true;
  846|  1.40k|  } 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.40k|}
charconv.cc:_ZN4absl12_GLOBAL__N_113FromCharsImplIfEENS_17from_chars_resultEPKcS4_RT_NS_12chars_formatE:
  862|  1.41k|                                chars_format fmt_flags) {
  863|  1.41k|  from_chars_result result;
  864|  1.41k|  result.ptr = first;  // overwritten on successful parse
  865|  1.41k|  result.ec = std::errc();
  866|       |
  867|  1.41k|  bool negative = false;
  868|  1.41k|  if (first != last && *first == '-') {
  ------------------
  |  Branch (868:7): [True: 1.41k, False: 0]
  |  Branch (868:24): [True: 803, False: 616]
  ------------------
  869|    803|    ++first;
  870|    803|    negative = true;
  871|    803|  }
  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.41k|  if ((fmt_flags & chars_format::hex) == chars_format{} && last - first >= 2 &&
  ------------------
  |  Branch (874:7): [True: 1.41k, False: 0]
  |  Branch (874:60): [True: 1.39k, False: 21]
  ------------------
  875|  1.39k|      *first == '0' && (first[1] == 'x' || first[1] == 'X')) {
  ------------------
  |  Branch (875:7): [True: 0, False: 1.39k]
  |  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.41k|  if ((fmt_flags & chars_format::hex) == chars_format::hex) {
  ------------------
  |  Branch (907:7): [True: 0, False: 1.41k]
  ------------------
  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.41k|  } else {
  923|  1.41k|    strings_internal::ParsedFloat decimal_parse =
  924|  1.41k|        strings_internal::ParseFloat<10>(first, last, fmt_flags);
  925|  1.41k|    if (decimal_parse.end == nullptr) {
  ------------------
  |  Branch (925:9): [True: 0, False: 1.41k]
  ------------------
  926|      0|      result.ec = std::errc::invalid_argument;
  927|      0|      return result;
  928|      0|    }
  929|  1.41k|    result.ptr = decimal_parse.end;
  930|  1.41k|    if (HandleEdgeCase(decimal_parse, negative, &value)) {
  ------------------
  |  Branch (930:9): [True: 21, False: 1.39k]
  ------------------
  931|     21|      return result;
  932|     21|    }
  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.39k|    if ((decimal_parse.subrange_begin == nullptr) &&
  ------------------
  |  Branch (935:9): [True: 1.39k, False: 0]
  ------------------
  936|  1.39k|        EiselLemire<FloatType>(decimal_parse, negative, &value, &result.ec)) {
  ------------------
  |  Branch (936:9): [True: 1.39k, False: 0]
  ------------------
  937|  1.39k|      return result;
  938|  1.39k|    }
  939|      0|    CalculatedFloat calculated =
  940|      0|        CalculateFromParsedDecimal<FloatType>(decimal_parse);
  941|      0|    EncodeResult(calculated, negative, &result, &value);
  942|      0|    return result;
  943|  1.39k|  }
  944|  1.41k|}
charconv.cc:_ZN4absl12_GLOBAL__N_114HandleEdgeCaseIfEEbRKNS_16strings_internal11ParsedFloatEbPT_:
  360|  1.41k|                    FloatType* absl_nonnull value) {
  361|  1.41k|  if (input.type == strings_internal::FloatType::kNan) {
  ------------------
  |  Branch (361:7): [True: 0, False: 1.41k]
  ------------------
  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.41k|  if (input.type == strings_internal::FloatType::kInfinity) {
  ------------------
  |  Branch (386:7): [True: 0, False: 1.41k]
  ------------------
  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.41k|  if (input.mantissa == 0) {
  ------------------
  |  Branch (391:7): [True: 21, False: 1.39k]
  ------------------
  392|     21|    *value = negative ? -0.0f : 0.0f;
  ------------------
  |  Branch (392:14): [True: 0, False: 21]
  ------------------
  393|     21|    return true;
  394|     21|  }
  395|  1.39k|  return false;
  396|  1.41k|}
charconv.cc:_ZN4absl12_GLOBAL__N_111EiselLemireIfEEbRKNS_16strings_internal11ParsedFloatEbPT_PNSt3__14errcE:
  687|  1.39k|                 FloatType* absl_nonnull value, std::errc* absl_nonnull ec) {
  688|  1.39k|  uint64_t man = input.mantissa;
  689|  1.39k|  int exp10 = input.exponent;
  690|  1.39k|  if (exp10 < FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10) {
  ------------------
  |  Branch (690:7): [True: 0, False: 1.39k]
  ------------------
  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.39k|  } else if (exp10 >= FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10) {
  ------------------
  |  Branch (694:14): [True: 0, False: 1.39k]
  ------------------
  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.39k|  static_assert(
  706|  1.39k|      FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10 >=
  707|  1.39k|          kPower10TableMinInclusive,
  708|  1.39k|      "(exp10-kPower10TableMinInclusive) in kPower10MantissaHighTable bounds");
  709|  1.39k|  static_assert(
  710|  1.39k|      FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10 <=
  711|  1.39k|          kPower10TableMaxExclusive,
  712|  1.39k|      "(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.39k|  int clz = countl_zero(man);
  728|  1.39k|  man <<= static_cast<unsigned int>(clz);
  729|       |  // The 217706 etc magic numbers are from the Power10Exponent function.
  730|  1.39k|  uint64_t ret_exp2 =
  731|  1.39k|      static_cast<uint64_t>((217706 * exp10 >> 16) + 64 +
  732|  1.39k|                            FloatTraits<FloatType>::kExponentBias - clz);
  733|       |
  734|       |  // (+) Multiplication.
  735|  1.39k|  uint128 x = static_cast<uint128>(man) *
  736|  1.39k|              static_cast<uint128>(
  737|  1.39k|                  kPower10MantissaHighTable[exp10 - kPower10TableMinInclusive]);
  738|       |
  739|       |  // (+) Wider Approximation.
  740|  1.39k|  static constexpr uint64_t high64_mask =
  741|  1.39k|      FloatTraits<FloatType>::kEiselLemireMask;
  742|  1.39k|  if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (742:7): [True: 0, False: 1.39k]
  ------------------
  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.39k|  uint64_t msb = Uint128High64(x) >> 63;
  767|  1.39k|  uint64_t ret_man =
  768|  1.39k|      Uint128High64(x) >> (msb + FloatTraits<FloatType>::kEiselLemireShift);
  769|  1.39k|  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.39k|  if ((Uint128Low64(x) == 0) && ((Uint128High64(x) & high64_mask) == 0) &&
  ------------------
  |  Branch (780:7): [True: 68, False: 1.33k]
  |  Branch (780:33): [True: 0, False: 68]
  ------------------
  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.39k|  ret_man += ret_man & 1;  // Line From54a.
  787|  1.39k|  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.39k|  if ((ret_man >> FloatTraits<FloatType>::kTargetMantissaBits) > 0) {
  ------------------
  |  Branch (796:7): [True: 0, False: 1.39k]
  ------------------
  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.39k|  static constexpr uint64_t max_exp2 =
  821|  1.39k|      (1 << FloatTraits<FloatType>::kTargetExponentBits) - 1;
  822|  1.39k|  if ((ret_exp2 - 1) >= (max_exp2 - 1)) {
  ------------------
  |  Branch (822:7): [True: 0, False: 1.39k]
  ------------------
  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.39k|  if (FloatTraits<FloatType>::kTargetBits == 64) {
  ------------------
  |  Branch (839:7): [Folded, False: 1.39k]
  ------------------
  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.39k|  } else if (FloatTraits<FloatType>::kTargetBits == 32) {
  ------------------
  |  Branch (846:14): [True: 1.39k, Folded]
  ------------------
  847|  1.39k|    uint32_t ret_bits = (static_cast<uint32_t>(ret_exp2) << 23) |
  848|  1.39k|                        (static_cast<uint32_t>(ret_man) & 0x007FFFFFu);
  849|  1.39k|    if (negative) {
  ------------------
  |  Branch (849:9): [True: 803, False: 595]
  ------------------
  850|    803|      ret_bits |= 0x80000000u;
  851|    803|    }
  852|  1.39k|    *value = static_cast<FloatType>(absl::bit_cast<float>(ret_bits));
  853|  1.39k|    return true;
  854|  1.39k|  }
  855|      0|#endif  // ABSL_BIT_PACK_FLOATS
  856|      0|  return false;
  857|  1.39k|}

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

str_cat.cc:_ZN4absl16strings_internal24StringAppendAndOverwriteINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEZNS_9StrAppendEPS8_RKNS_8AlphaNumEE3$_0EEvRT_NSE_9size_typeET0_:
   48|  1.41k|                              Op append_op) {
   49|  1.41k|  if (ABSL_PREDICT_FALSE(append_n > str.max_size() - str.size())) {
  ------------------
  |  |  190|  1.41k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.41k]
  |  |  |  Branch (190:49): [Folded, False: 1.41k]
  |  |  |  Branch (190:58): [True: 0, False: 1.41k]
  |  |  ------------------
  ------------------
   50|      0|    ThrowStdLengthError("absl::strings_internal::StringAppendAndOverwrite");
   51|      0|  }
   52|       |
   53|  1.41k|  auto old_size = str.size();
   54|  1.41k|  auto resize = old_size + append_n;
   55|       |
   56|  1.41k|  if (resize > str.capacity()) {
  ------------------
  |  Branch (56:7): [True: 344, False: 1.07k]
  ------------------
   57|       |    // Make sure to always grow by at least a factor of 2x.
   58|    344|    const auto min_growth = str.capacity();
   59|    344|    if (ABSL_PREDICT_FALSE(str.capacity() > str.max_size() - min_growth)) {
  ------------------
  |  |  190|    344|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 344]
  |  |  |  Branch (190:49): [Folded, False: 344]
  |  |  |  Branch (190:58): [True: 0, False: 344]
  |  |  ------------------
  ------------------
   60|      0|      str.reserve(str.max_size());
   61|    344|    } else if (resize < str.capacity() + min_growth) {
  ------------------
  |  Branch (61:16): [True: 151, False: 193]
  ------------------
   62|    151|      str.reserve(str.capacity() + min_growth);
   63|    151|    }
   64|    344|  }
   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.41k|  StringResizeAndOverwriteImpl(
   70|  1.41k|      str, resize,
   71|  1.41k|      [old_size, append_n, do_append = std::move(append_op)](
   72|  1.41k|          typename T::value_type* data_ptr, typename T::size_type) mutable {
   73|  1.41k|        typename T::size_type num_appended = static_cast<typename T::size_type>(
   74|  1.41k|            std::move(do_append)(data_ptr + old_size, append_n));
   75|  1.41k|        absl::base_internal::HardeningAssertGE(num_appended,
   76|  1.41k|                                               typename T::size_type{0});
   77|  1.41k|        absl::base_internal::HardeningAssertLE(num_appended, append_n);
   78|  1.41k|        return old_size + num_appended;
   79|  1.41k|      });
   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.41k|}
str_cat.cc:_ZZN4absl16strings_internal24StringAppendAndOverwriteINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEZNS_9StrAppendEPS8_RKNS_8AlphaNumEE3$_0EEvRT_NSE_9size_typeET0_ENUlPcmE_clESI_m:
   72|  1.41k|          typename T::value_type* data_ptr, typename T::size_type) mutable {
   73|  1.41k|        typename T::size_type num_appended = static_cast<typename T::size_type>(
   74|  1.41k|            std::move(do_append)(data_ptr + old_size, append_n));
   75|  1.41k|        absl::base_internal::HardeningAssertGE(num_appended,
   76|  1.41k|                                               typename T::size_type{0});
   77|  1.41k|        absl::base_internal::HardeningAssertLE(num_appended, append_n);
   78|  1.41k|        return old_size + num_appended;
   79|  1.41k|      });

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

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

_ZN4absl19str_format_internal13ConvertIntArgIiEEbT_NS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  349|  2.83k|bool ConvertIntArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
  350|  2.83k|  using U = typename MakeUnsigned<T>::type;
  351|  2.83k|  IntDigits as_digits;
  352|       |
  353|       |  // This odd casting is due to a bug in -Wswitch behavior in gcc49 which causes
  354|       |  // it to complain about a switch/case type mismatch, even though both are
  355|       |  // FormatConversionChar.  Likely this is because at this point
  356|       |  // FormatConversionChar is declared, but not defined.
  357|  2.83k|  switch (static_cast<uint8_t>(conv.conversion_char())) {
  358|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::c):
  ------------------
  |  Branch (358:5): [True: 0, False: 2.83k]
  ------------------
  359|      0|      return (std::is_same<T, wchar_t>::value ||
  ------------------
  |  Branch (359:15): [Folded, False: 0]
  ------------------
  360|      0|              (conv.length_mod() == LengthMod::l))
  ------------------
  |  Branch (360:15): [True: 0, False: 0]
  ------------------
  361|      0|                 ? ConvertWCharTImpl(static_cast<wchar_t>(v), conv, sink)
  362|      0|                 : ConvertCharImpl(static_cast<char>(v), conv, sink);
  363|       |
  364|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::o):
  ------------------
  |  Branch (364:5): [True: 0, False: 2.83k]
  ------------------
  365|      0|      as_digits.PrintAsOct(static_cast<U>(v));
  366|      0|      break;
  367|       |
  368|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::x):
  ------------------
  |  Branch (368:5): [True: 0, False: 2.83k]
  ------------------
  369|      0|      as_digits.PrintAsHexLower(static_cast<U>(v));
  370|      0|      break;
  371|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::X):
  ------------------
  |  Branch (371:5): [True: 0, False: 2.83k]
  ------------------
  372|      0|      as_digits.PrintAsHexUpper(static_cast<U>(v));
  373|      0|      break;
  374|       |
  375|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::u):
  ------------------
  |  Branch (375:5): [True: 0, False: 2.83k]
  ------------------
  376|      0|      as_digits.PrintAsDec(static_cast<U>(v));
  377|      0|      break;
  378|       |
  379|  2.83k|    case static_cast<uint8_t>(FormatConversionCharInternal::d):
  ------------------
  |  Branch (379:5): [True: 2.83k, False: 0]
  ------------------
  380|  2.83k|    case static_cast<uint8_t>(FormatConversionCharInternal::i):
  ------------------
  |  Branch (380:5): [True: 0, False: 2.83k]
  ------------------
  381|  2.83k|    case static_cast<uint8_t>(FormatConversionCharInternal::v):
  ------------------
  |  Branch (381:5): [True: 0, False: 2.83k]
  ------------------
  382|  2.83k|      as_digits.PrintAsDec(v);
  383|  2.83k|      break;
  384|       |
  385|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::a):
  ------------------
  |  Branch (385:5): [True: 0, False: 2.83k]
  ------------------
  386|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::e):
  ------------------
  |  Branch (386:5): [True: 0, False: 2.83k]
  ------------------
  387|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::f):
  ------------------
  |  Branch (387:5): [True: 0, False: 2.83k]
  ------------------
  388|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::g):
  ------------------
  |  Branch (388:5): [True: 0, False: 2.83k]
  ------------------
  389|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::A):
  ------------------
  |  Branch (389:5): [True: 0, False: 2.83k]
  ------------------
  390|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::E):
  ------------------
  |  Branch (390:5): [True: 0, False: 2.83k]
  ------------------
  391|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::F):
  ------------------
  |  Branch (391:5): [True: 0, False: 2.83k]
  ------------------
  392|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::G):
  ------------------
  |  Branch (392:5): [True: 0, False: 2.83k]
  ------------------
  393|      0|      return ConvertFloatImpl(static_cast<double>(v), conv, sink);
  394|       |
  395|      0|    default:
  ------------------
  |  Branch (395:5): [True: 0, False: 2.83k]
  ------------------
  396|      0|      ABSL_ASSUME(false);
  ------------------
  |  |  269|      0|#define ABSL_ASSUME(cond) assert(cond)
  ------------------
  |  Branch (396:7): [Folded, False: 0]
  ------------------
  397|  2.83k|  }
  398|       |
  399|  2.83k|  if (conv.is_basic()) {
  ------------------
  |  Branch (399:7): [True: 2.83k, False: 0]
  ------------------
  400|  2.83k|    sink->Append(as_digits.with_neg_and_zero());
  401|  2.83k|    return true;
  402|  2.83k|  }
  403|      0|  return ConvertIntImplInnerSlow(as_digits, conv, sink);
  404|  2.83k|}
_ZN4absl19str_format_internal17FormatConvertImplEfNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  521|  1.41k|                                        FormatSinkImpl *sink) {
  522|  1.41k|  return {ConvertFloatArg(v, conv, sink)};
  523|  1.41k|}
_ZN4absl19str_format_internal17FormatConvertImplEdNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  526|  1.41k|                                        FormatSinkImpl *sink) {
  527|  1.41k|  return {ConvertFloatArg(v, conv, sink)};
  528|  1.41k|}
_ZN4absl19str_format_internal17FormatConvertImplEiNS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  569|  2.83k|                                        FormatSinkImpl *sink) {
  570|  2.83k|  return {ConvertIntArg(v, conv, sink)};
  571|  2.83k|}
arg.cc:_ZNK4absl19str_format_internal12_GLOBAL__N_19IntDigits17with_neg_and_zeroEv:
  174|  2.83k|  string_view with_neg_and_zero() const { return {start_, size_}; }
arg.cc:_ZN4absl19str_format_internal12_GLOBAL__N_19IntDigits10PrintAsDecIiEEvT_:
   97|  2.83k|  void PrintAsDec(T v) {
   98|  2.83k|    static_assert(std::is_integral<T>::value, "");
   99|  2.83k|    start_ = storage_;
  100|  2.83k|    size_ = static_cast<size_t>(numbers_internal::FastIntToBuffer(v, storage_) -
  101|  2.83k|                                storage_);
  102|  2.83k|  }
arg.cc:_ZN4absl19str_format_internal12_GLOBAL__N_115ConvertFloatArgIfEEbT_NS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  293|  1.41k|bool ConvertFloatArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
  294|  1.41k|  if (conv.conversion_char() == FormatConversionCharInternal::v) {
  ------------------
  |  Branch (294:7): [True: 0, False: 1.41k]
  ------------------
  295|      0|    conv.set_conversion_char(FormatConversionCharInternal::g);
  296|      0|  }
  297|       |
  298|  1.41k|  return FormatConversionCharIsFloat(conv.conversion_char()) &&
  ------------------
  |  Branch (298:10): [True: 1.41k, False: 0]
  ------------------
  299|  1.41k|         ConvertFloatImpl(v, conv, sink);
  ------------------
  |  Branch (299:10): [True: 1.41k, False: 0]
  ------------------
  300|  1.41k|}
arg.cc:_ZN4absl19str_format_internal12_GLOBAL__N_115ConvertFloatArgIdEEbT_NS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  293|  1.41k|bool ConvertFloatArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
  294|  1.41k|  if (conv.conversion_char() == FormatConversionCharInternal::v) {
  ------------------
  |  Branch (294:7): [True: 0, False: 1.41k]
  ------------------
  295|      0|    conv.set_conversion_char(FormatConversionCharInternal::g);
  296|      0|  }
  297|       |
  298|  1.41k|  return FormatConversionCharIsFloat(conv.conversion_char()) &&
  ------------------
  |  Branch (298:10): [True: 1.41k, False: 0]
  ------------------
  299|  1.41k|         ConvertFloatImpl(v, conv, sink);
  ------------------
  |  Branch (299:10): [True: 1.41k, False: 0]
  ------------------
  300|  1.41k|}

_ZN4absl19str_format_internal13FormatArgImplC2IfEERKT_:
  494|  1.41k|  explicit FormatArgImpl(const T& value) {
  495|  1.41k|    using D = typename DecayType<T>::type;
  496|  1.41k|    static_assert(
  497|  1.41k|        std::is_same<D, const T&>::value || storage_policy<D>::value == ByValue,
  498|  1.41k|        "Decayed types must be stored by value");
  499|  1.41k|    Init(static_cast<D>(value));
  500|  1.41k|  }
_ZN4absl19str_format_internal13FormatArgImpl4InitIfEEvRKT_:
  547|  1.41k|  void Init(const T& value) {
  548|  1.41k|    data_ = Manager<T>::SetValue(value);
  549|  1.41k|    dispatcher_ = &Dispatch<T>;
  550|  1.41k|  }
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIfLNS1_13StoragePolicyE2EE8SetValueERKf:
  533|  1.41k|    static Data SetValue(const T& value) {
  534|  1.41k|      Data data;
  535|  1.41k|      memcpy(data.buf, &value, sizeof(value));
  536|  1.41k|      return data;
  537|  1.41k|    }
_ZN4absl19str_format_internal13FormatArgImpl8DispatchIfEEbNS1_4DataENS0_24FormatConversionSpecImplEPv:
  588|  1.41k|  static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) {
  589|       |    // A `none` conv indicates that we want the `int` conversion.
  590|  1.41k|    if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
  ------------------
  |  |  190|  1.41k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.41k]
  |  |  |  Branch (190:49): [Folded, False: 1.41k]
  |  |  |  Branch (190:58): [True: 0, False: 1.41k]
  |  |  ------------------
  ------------------
  591|  1.41k|                           FormatConversionCharInternal::kNone)) {
  592|      0|      return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
  593|      0|                      std::is_enum<T>());
  594|      0|    }
  595|  1.41k|    if (ABSL_PREDICT_FALSE(
  ------------------
  |  |  190|  1.41k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.41k]
  |  |  |  Branch (190:49): [Folded, False: 1.41k]
  |  |  |  Branch (190:58): [True: 0, False: 1.41k]
  |  |  ------------------
  ------------------
  596|  1.41k|            !Contains(ArgumentToConv<T>(), spec.conversion_char()))) {
  597|      0|      return false;
  598|      0|    }
  599|  1.41k|    return str_format_internal::FormatConvertImpl(
  600|  1.41k|               Manager<T>::Value(arg), spec, static_cast<FormatSinkImpl*>(out))
  601|  1.41k|        .value;
  602|  1.41k|  }
_ZN4absl19str_format_internal14ArgumentToConvIfEENS_23FormatConversionCharSetEv:
  420|  1.41k|constexpr FormatConversionCharSet ArgumentToConv() {
  421|  1.41k|  using ConvResult = decltype(str_format_internal::FormatConvertImpl(
  422|  1.41k|      std::declval<const Arg&>(),
  423|  1.41k|      std::declval<const FormatConversionSpecImpl&>(),
  424|  1.41k|      std::declval<FormatSinkImpl*>()));
  425|  1.41k|  return absl::str_format_internal::ExtractCharSet(ConvResult{});
  426|  1.41k|}
_ZN4absl19str_format_internal14ExtractCharSetILNS_23FormatConversionCharSetE654848EEES2_NS0_16ArgConvertResultIXT_EEE:
  206|  2.83k|constexpr FormatConversionCharSet ExtractCharSet(ArgConvertResult<C>) {
  207|  2.83k|  return C;
  208|  2.83k|}
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIfLNS1_13StoragePolicyE2EE5ValueENS1_4DataE:
  539|  1.41k|    static T Value(Data arg) {
  540|  1.41k|      T value;
  541|  1.41k|      memcpy(&value, arg.buf, sizeof(T));
  542|  1.41k|      return value;
  543|  1.41k|    }
_ZN4absl19str_format_internal13FormatArgImplC2IdEERKT_:
  494|  1.41k|  explicit FormatArgImpl(const T& value) {
  495|  1.41k|    using D = typename DecayType<T>::type;
  496|  1.41k|    static_assert(
  497|  1.41k|        std::is_same<D, const T&>::value || storage_policy<D>::value == ByValue,
  498|  1.41k|        "Decayed types must be stored by value");
  499|  1.41k|    Init(static_cast<D>(value));
  500|  1.41k|  }
_ZN4absl19str_format_internal13FormatArgImpl4InitIdEEvRKT_:
  547|  1.41k|  void Init(const T& value) {
  548|  1.41k|    data_ = Manager<T>::SetValue(value);
  549|  1.41k|    dispatcher_ = &Dispatch<T>;
  550|  1.41k|  }
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIdLNS1_13StoragePolicyE2EE8SetValueERKd:
  533|  1.41k|    static Data SetValue(const T& value) {
  534|  1.41k|      Data data;
  535|  1.41k|      memcpy(data.buf, &value, sizeof(value));
  536|  1.41k|      return data;
  537|  1.41k|    }
_ZN4absl19str_format_internal13FormatArgImpl8DispatchIdEEbNS1_4DataENS0_24FormatConversionSpecImplEPv:
  588|  1.41k|  static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) {
  589|       |    // A `none` conv indicates that we want the `int` conversion.
  590|  1.41k|    if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
  ------------------
  |  |  190|  1.41k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.41k]
  |  |  |  Branch (190:49): [Folded, False: 1.41k]
  |  |  |  Branch (190:58): [True: 0, False: 1.41k]
  |  |  ------------------
  ------------------
  591|  1.41k|                           FormatConversionCharInternal::kNone)) {
  592|      0|      return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
  593|      0|                      std::is_enum<T>());
  594|      0|    }
  595|  1.41k|    if (ABSL_PREDICT_FALSE(
  ------------------
  |  |  190|  1.41k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.41k]
  |  |  |  Branch (190:49): [Folded, False: 1.41k]
  |  |  |  Branch (190:58): [True: 0, False: 1.41k]
  |  |  ------------------
  ------------------
  596|  1.41k|            !Contains(ArgumentToConv<T>(), spec.conversion_char()))) {
  597|      0|      return false;
  598|      0|    }
  599|  1.41k|    return str_format_internal::FormatConvertImpl(
  600|  1.41k|               Manager<T>::Value(arg), spec, static_cast<FormatSinkImpl*>(out))
  601|  1.41k|        .value;
  602|  1.41k|  }
_ZN4absl19str_format_internal14ArgumentToConvIdEENS_23FormatConversionCharSetEv:
  420|  1.41k|constexpr FormatConversionCharSet ArgumentToConv() {
  421|  1.41k|  using ConvResult = decltype(str_format_internal::FormatConvertImpl(
  422|  1.41k|      std::declval<const Arg&>(),
  423|  1.41k|      std::declval<const FormatConversionSpecImpl&>(),
  424|  1.41k|      std::declval<FormatSinkImpl*>()));
  425|  1.41k|  return absl::str_format_internal::ExtractCharSet(ConvResult{});
  426|  1.41k|}
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIdLNS1_13StoragePolicyE2EE5ValueENS1_4DataE:
  539|  1.41k|    static T Value(Data arg) {
  540|  1.41k|      T value;
  541|  1.41k|      memcpy(&value, arg.buf, sizeof(T));
  542|  1.41k|      return value;
  543|  1.41k|    }
_ZN4absl19str_format_internal13FormatArgImplC2IiEERKT_:
  494|  1.41k|  explicit FormatArgImpl(const T& value) {
  495|  1.41k|    using D = typename DecayType<T>::type;
  496|  1.41k|    static_assert(
  497|  1.41k|        std::is_same<D, const T&>::value || storage_policy<D>::value == ByValue,
  498|  1.41k|        "Decayed types must be stored by value");
  499|  1.41k|    Init(static_cast<D>(value));
  500|  1.41k|  }
_ZN4absl19str_format_internal13FormatArgImpl4InitIiEEvRKT_:
  547|  1.41k|  void Init(const T& value) {
  548|  1.41k|    data_ = Manager<T>::SetValue(value);
  549|  1.41k|    dispatcher_ = &Dispatch<T>;
  550|  1.41k|  }
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIiLNS1_13StoragePolicyE2EE8SetValueERKi:
  533|  1.41k|    static Data SetValue(const T& value) {
  534|  1.41k|      Data data;
  535|  1.41k|      memcpy(data.buf, &value, sizeof(value));
  536|  1.41k|      return data;
  537|  1.41k|    }
_ZN4absl19str_format_internal13FormatArgImpl8DispatchIiEEbNS1_4DataENS0_24FormatConversionSpecImplEPv:
  588|  1.41k|  static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) {
  589|       |    // A `none` conv indicates that we want the `int` conversion.
  590|  1.41k|    if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
  ------------------
  |  |  190|  1.41k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.41k]
  |  |  |  Branch (190:49): [Folded, False: 1.41k]
  |  |  |  Branch (190:58): [True: 0, False: 1.41k]
  |  |  ------------------
  ------------------
  591|  1.41k|                           FormatConversionCharInternal::kNone)) {
  592|      0|      return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
  593|      0|                      std::is_enum<T>());
  594|      0|    }
  595|  1.41k|    if (ABSL_PREDICT_FALSE(
  ------------------
  |  |  190|  1.41k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.41k]
  |  |  |  Branch (190:49): [Folded, False: 1.41k]
  |  |  |  Branch (190:58): [True: 0, False: 1.41k]
  |  |  ------------------
  ------------------
  596|  1.41k|            !Contains(ArgumentToConv<T>(), spec.conversion_char()))) {
  597|      0|      return false;
  598|      0|    }
  599|  1.41k|    return str_format_internal::FormatConvertImpl(
  600|  1.41k|               Manager<T>::Value(arg), spec, static_cast<FormatSinkImpl*>(out))
  601|  1.41k|        .value;
  602|  1.41k|  }
_ZN4absl19str_format_internal14ArgumentToConvIiEENS_23FormatConversionCharSetEv:
  420|  1.41k|constexpr FormatConversionCharSet ArgumentToConv() {
  421|  1.41k|  using ConvResult = decltype(str_format_internal::FormatConvertImpl(
  422|  1.41k|      std::declval<const Arg&>(),
  423|  1.41k|      std::declval<const FormatConversionSpecImpl&>(),
  424|  1.41k|      std::declval<FormatSinkImpl*>()));
  425|  1.41k|  return absl::str_format_internal::ExtractCharSet(ConvResult{});
  426|  1.41k|}
_ZN4absl19str_format_internal14ExtractCharSetILNS_23FormatConversionCharSetE655355EEES2_NS0_16ArgConvertResultIXT_EEE:
  206|  2.83k|constexpr FormatConversionCharSet ExtractCharSet(ArgConvertResult<C>) {
  207|  2.83k|  return C;
  208|  2.83k|}
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIiLNS1_13StoragePolicyE2EE5ValueENS1_4DataE:
  539|  1.41k|    static T Value(Data arg) {
  540|  1.41k|      T value;
  541|  1.41k|      memcpy(&value, arg.buf, sizeof(T));
  542|  1.41k|      return value;
  543|  1.41k|    }
_ZN4absl19str_format_internal13FormatArgImplC2IbEERKT_:
  494|  1.41k|  explicit FormatArgImpl(const T& value) {
  495|  1.41k|    using D = typename DecayType<T>::type;
  496|  1.41k|    static_assert(
  497|  1.41k|        std::is_same<D, const T&>::value || storage_policy<D>::value == ByValue,
  498|  1.41k|        "Decayed types must be stored by value");
  499|  1.41k|    Init(static_cast<D>(value));
  500|  1.41k|  }
_ZN4absl19str_format_internal13FormatArgImpl4InitIbEEvRKT_:
  547|  1.41k|  void Init(const T& value) {
  548|  1.41k|    data_ = Manager<T>::SetValue(value);
  549|  1.41k|    dispatcher_ = &Dispatch<T>;
  550|  1.41k|  }
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIbLNS1_13StoragePolicyE2EE8SetValueERKb:
  533|  1.41k|    static Data SetValue(const T& value) {
  534|  1.41k|      Data data;
  535|  1.41k|      memcpy(data.buf, &value, sizeof(value));
  536|  1.41k|      return data;
  537|  1.41k|    }
_ZN4absl19str_format_internal13FormatArgImpl8DispatchIbEEbNS1_4DataENS0_24FormatConversionSpecImplEPv:
  588|  1.41k|  static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) {
  589|       |    // A `none` conv indicates that we want the `int` conversion.
  590|  1.41k|    if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
  ------------------
  |  |  190|  1.41k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.41k]
  |  |  |  Branch (190:49): [Folded, False: 1.41k]
  |  |  |  Branch (190:58): [True: 0, False: 1.41k]
  |  |  ------------------
  ------------------
  591|  1.41k|                           FormatConversionCharInternal::kNone)) {
  592|      0|      return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
  593|      0|                      std::is_enum<T>());
  594|      0|    }
  595|  1.41k|    if (ABSL_PREDICT_FALSE(
  ------------------
  |  |  190|  1.41k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.41k]
  |  |  |  Branch (190:49): [Folded, False: 1.41k]
  |  |  |  Branch (190:58): [True: 0, False: 1.41k]
  |  |  ------------------
  ------------------
  596|  1.41k|            !Contains(ArgumentToConv<T>(), spec.conversion_char()))) {
  597|      0|      return false;
  598|      0|    }
  599|  1.41k|    return str_format_internal::FormatConvertImpl(
  600|  1.41k|               Manager<T>::Value(arg), spec, static_cast<FormatSinkImpl*>(out))
  601|  1.41k|        .value;
  602|  1.41k|  }
_ZN4absl19str_format_internal14ArgumentToConvIbEENS_23FormatConversionCharSetEv:
  420|  1.41k|constexpr FormatConversionCharSet ArgumentToConv() {
  421|  1.41k|  using ConvResult = decltype(str_format_internal::FormatConvertImpl(
  422|  1.41k|      std::declval<const Arg&>(),
  423|  1.41k|      std::declval<const FormatConversionSpecImpl&>(),
  424|  1.41k|      std::declval<FormatSinkImpl*>()));
  425|  1.41k|  return absl::str_format_internal::ExtractCharSet(ConvResult{});
  426|  1.41k|}
_ZN4absl19str_format_internal17FormatConvertImplIbTnNSt3__19enable_ifIXsr3std7is_sameIT_bEE5valueEiE4typeELi0EEENS0_16ArgConvertResultILNS_23FormatConversionCharSetE655355EEES4_NS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  345|  1.41k|                                        FormatSinkImpl* sink) {
  346|  1.41k|  if (conv.conversion_char() == FormatConversionCharInternal::v) {
  ------------------
  |  Branch (346:7): [True: 0, False: 1.41k]
  ------------------
  347|      0|    return {ConvertBoolArg(v, sink)};
  348|      0|  }
  349|       |
  350|  1.41k|  return FormatConvertImpl(static_cast<int>(v), conv, sink);
  351|  1.41k|}
_ZN4absl19str_format_internal13FormatArgImpl7ManagerIbLNS1_13StoragePolicyE2EE5ValueENS1_4DataE:
  539|  1.41k|    static T Value(Data arg) {
  540|  1.41k|      T value;
  541|  1.41k|      memcpy(&value, arg.buf, sizeof(T));
  542|  1.41k|      return value;
  543|  1.41k|    }
_ZN4absl19str_format_internal19FormatArgImplFriend7ConvertINS0_13FormatArgImplEEEbT_NS0_24FormatConversionSpecImplEPNS0_14FormatSinkImplE:
  409|  5.67k|                      FormatSinkImpl* out) {
  410|  5.67k|    return arg.dispatcher_(arg.data_, conv, out);
  411|  5.67k|  }

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

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

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

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

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

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

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

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

_ZN4absl16strings_internal23ConvertibleToStringViewC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
   71|  1.41k|      : value_(s) {}
_ZNK4absl16strings_internal23ConvertibleToStringView5valueEv:
   77|  1.41k|  absl::string_view value() const { return value_; }
_ZN4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEC2ES8_S2_S3_:
  295|  1.41k|      : text_(std::move(input_text)),
  296|  1.41k|        delimiter_(std::move(d)),
  297|  1.41k|        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:
  328|  1.41k|  operator Container() const {
  329|  1.41k|    return ConvertToContainer<Container, typename Container::value_type,
  330|  1.41k|                              HasMappedType<Container>::value>()(*this);
  331|  1.41k|  }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEE18ConvertToContainerINS4_6vectorINS4_12basic_stringIcS7_NS4_9allocatorIcEEEENSD_ISF_EEEESF_Lb0EEclERKS9_:
  462|  1.41k|    std::vector<std::string, A> operator()(const Splitter& splitter) const {
  463|  1.41k|      const std::vector<absl::string_view> v = splitter;
  464|  1.41k|      return std::vector<std::string, A>(v.begin(), v.end());
  465|  1.41k|    }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEcvT_INS4_6vectorIS8_NS4_9allocatorIS8_EEEETnNS4_9enable_ifIXaantsr22ShouldUseLifetimeBoundIS8_SA_EE5valuesr23SplitterIsConvertibleToISA_EE5valueEDnE4typeELDn0EEEv:
  328|  1.41k|  operator Container() const {
  329|  1.41k|    return ConvertToContainer<Container, typename Container::value_type,
  330|  1.41k|                              HasMappedType<Container>::value>()(*this);
  331|  1.41k|  }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEE18ConvertToContainerINS4_6vectorIS8_NS4_9allocatorIS8_EEEES8_Lb0EEclERKS9_:
  428|  1.41k|        const Splitter& splitter) const {
  429|  1.41k|      struct raw_view {
  430|  1.41k|        const char* data;
  431|  1.41k|        size_t size;
  432|  1.41k|        operator absl::string_view() const {  // NOLINT(runtime/explicit)
  433|  1.41k|          return {data, size};
  434|  1.41k|        }
  435|  1.41k|      };
  436|  1.41k|      std::vector<absl::string_view, A> v;
  437|  1.41k|      std::array<raw_view, 16> ar;
  438|  1.35M|      for (auto it = splitter.begin(); !it.at_end();) {
  ------------------
  |  Branch (438:40): [True: 1.35M, False: 1.41k]
  ------------------
  439|  1.35M|        size_t index = 0;
  440|  21.5M|        do {
  441|  21.5M|          ar[index].data = it->data();
  442|  21.5M|          ar[index].size = it->size();
  443|  21.5M|          ++it;
  444|  21.5M|        } while (++index != ar.size() && !it.at_end());
  ------------------
  |  Branch (444:18): [True: 20.2M, False: 1.34M]
  |  Branch (444:42): [True: 20.2M, False: 1.39k]
  ------------------
  445|       |        // We static_cast index to a signed type to work around overzealous
  446|       |        // compiler warnings about signedness.
  447|  1.35M|        v.insert(v.end(), ar.begin(),
  448|  1.35M|                 ar.begin() + static_cast<ptrdiff_t>(index));
  449|  1.35M|      }
  450|  1.41k|      return v;
  451|  1.41k|    }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEE5beginEv:
  306|  1.41k|  const_iterator begin() const { return {const_iterator::kInitState, this}; }
_ZN4absl16strings_internal13SplitIteratorINS0_8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEEEC2ENSB_5StateEPKSA_:
  100|  1.41k|      : pos_(0),
  101|  1.41k|        state_(state),
  102|  1.41k|        splitter_(splitter),
  103|  1.41k|        delimiter_(splitter->delimiter()),
  104|  1.41k|        predicate_(splitter->predicate()) {
  105|       |    // Hack to maintain backward compatibility. This one block makes it so an
  106|       |    // empty absl::string_view whose .data() happens to be nullptr behaves
  107|       |    // *differently* from an otherwise empty absl::string_view whose .data() is
  108|       |    // not nullptr. This is an undesirable difference in general, but this
  109|       |    // behavior is maintained to avoid breaking existing code that happens to
  110|       |    // depend on this old behavior/bug. Perhaps it will be fixed one day. The
  111|       |    // difference in behavior is as follows:
  112|       |    //   Split(absl::string_view(""), '-');  // {""}
  113|       |    //   Split(absl::string_view(), '-');    // {}
  114|  1.41k|    if (splitter_->text().data() == nullptr) {
  ------------------
  |  Branch (114:9): [True: 0, False: 1.41k]
  ------------------
  115|      0|      state_ = kEndState;
  116|      0|      pos_ = splitter_->text().size();
  117|      0|      return;
  118|      0|    }
  119|       |
  120|  1.41k|    if (state_ == kEndState) {
  ------------------
  |  Branch (120:9): [True: 0, False: 1.41k]
  ------------------
  121|      0|      pos_ = splitter_->text().size();
  122|  1.41k|    } else {
  123|  1.41k|      ++(*this);
  124|  1.41k|    }
  125|  1.41k|  }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEE9delimiterEv:
  300|  1.41k|  const Delimiter& delimiter() const { return delimiter_; }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEE9predicateEv:
  301|  1.41k|  const Predicate& predicate() const { return predicate_; }
_ZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEE4textEv:
  299|  21.5M|  absl::string_view text() const { return text_; }
_ZNK4absl16strings_internal13SplitIteratorINS0_8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEEE6at_endEv:
  127|  21.5M|  bool at_end() const { return state_ == kEndState; }
_ZNK4absl16strings_internal13SplitIteratorINS0_8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEEEptEv:
  130|  43.1M|  pointer operator->() const { return &curr_; }
_ZN4absl16strings_internal13SplitIteratorINS0_8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEEEppEv:
  132|  21.5M|  SplitIterator& operator++() {
  133|  21.5M|    do {
  134|  21.5M|      if (state_ == kLastState) {
  ------------------
  |  Branch (134:11): [True: 1.41k, False: 21.5M]
  ------------------
  135|  1.41k|        state_ = kEndState;
  136|  1.41k|        return *this;
  137|  1.41k|      }
  138|  21.5M|      const absl::string_view text = splitter_->text();
  139|  21.5M|      const absl::string_view d = delimiter_.Find(text, pos_);
  140|  21.5M|      if (d.data() == text.data() + text.size()) state_ = kLastState;
  ------------------
  |  Branch (140:11): [True: 1.41k, False: 21.5M]
  ------------------
  141|  21.5M|      curr_ = text.substr(pos_,
  142|  21.5M|                          static_cast<size_t>(d.data() - (text.data() + pos_)));
  143|  21.5M|      pos_ += curr_.size() + d.size();
  144|  21.5M|    } while (!predicate_(curr_));
  ------------------
  |  Branch (144:14): [True: 0, False: 21.5M]
  ------------------
  145|  21.5M|    return *this;
  146|  21.5M|  }
_ZZNK4absl16strings_internal8SplitterINS_8ByStringENS_10AllowEmptyENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEE18ConvertToContainerINS4_6vectorIS8_NS4_9allocatorIS8_EEEES8_Lb0EEclERKS9_ENK8raw_viewcvS8_Ev:
  432|  21.5M|        operator absl::string_view() const {  // NOLINT(runtime/explicit)
  433|  21.5M|          return {data, size};
  434|  21.5M|        }

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

_ZN4absl10SimpleAtofENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEPf:
   51|  1.41k|bool SimpleAtof(absl::string_view str, float* absl_nonnull out) {
   52|  1.41k|  *out = 0.0;
   53|  1.41k|  str = StripAsciiWhitespace(str);
   54|  1.41k|  if (str.empty()) {
  ------------------
  |  Branch (54:7): [True: 0, False: 1.41k]
  ------------------
   55|       |    // absl::from_chars doesn't accept empty strings.
   56|      0|    return false;
   57|      0|  }
   58|       |  // std::from_chars doesn't accept an initial +, but SimpleAtof does, so if one
   59|       |  // is present, skip it, while avoiding accepting "+-0" as valid.
   60|  1.41k|  if (str[0] == '+') {
  ------------------
  |  Branch (60:7): [True: 0, False: 1.41k]
  ------------------
   61|      0|    str.remove_prefix(1);
   62|      0|    if (str.empty() || str[0] == '-') {
  ------------------
  |  Branch (62:9): [True: 0, False: 0]
  |  Branch (62:24): [True: 0, False: 0]
  ------------------
   63|      0|      return false;
   64|      0|    }
   65|      0|  }
   66|  1.41k|  auto result = absl::from_chars(str.data(), str.data() + str.size(), *out);
   67|  1.41k|  if (result.ec == std::errc::invalid_argument) {
  ------------------
  |  Branch (67:7): [True: 0, False: 1.41k]
  ------------------
   68|      0|    return false;
   69|      0|  }
   70|  1.41k|  if (result.ptr != str.data() + str.size()) {
  ------------------
  |  Branch (70:7): [True: 0, False: 1.41k]
  ------------------
   71|       |    // not all non-whitespace characters consumed
   72|      0|    return false;
   73|      0|  }
   74|       |  // from_chars() with DR 3081's current wording will return max() on
   75|       |  // overflow.  SimpleAtof returns infinity instead.
   76|  1.41k|  if (result.ec == std::errc::result_out_of_range) {
  ------------------
  |  Branch (76:7): [True: 0, False: 1.41k]
  ------------------
   77|      0|    if (*out > 1.0) {
  ------------------
  |  Branch (77:9): [True: 0, False: 0]
  ------------------
   78|      0|      *out = std::numeric_limits<float>::infinity();
   79|      0|    } else if (*out < -1.0) {
  ------------------
  |  Branch (79:16): [True: 0, False: 0]
  ------------------
   80|      0|      *out = -std::numeric_limits<float>::infinity();
   81|      0|    }
   82|      0|  }
   83|  1.41k|  return true;
   84|  1.41k|}
_ZN4absl10SimpleAtodENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEPd:
   86|  1.41k|bool SimpleAtod(absl::string_view str, double* absl_nonnull out) {
   87|  1.41k|  *out = 0.0;
   88|  1.41k|  str = StripAsciiWhitespace(str);
   89|  1.41k|  if (str.empty()) {
  ------------------
  |  Branch (89:7): [True: 0, False: 1.41k]
  ------------------
   90|       |    // absl::from_chars doesn't accept empty strings.
   91|      0|    return false;
   92|      0|  }
   93|       |  // std::from_chars doesn't accept an initial +, but SimpleAtod does, so if one
   94|       |  // is present, skip it, while avoiding accepting "+-0" as valid.
   95|  1.41k|  if (str[0] == '+') {
  ------------------
  |  Branch (95:7): [True: 0, False: 1.41k]
  ------------------
   96|      0|    str.remove_prefix(1);
   97|      0|    if (str.empty() || str[0] == '-') {
  ------------------
  |  Branch (97:9): [True: 0, False: 0]
  |  Branch (97:24): [True: 0, False: 0]
  ------------------
   98|      0|      return false;
   99|      0|    }
  100|      0|  }
  101|  1.41k|  auto result = absl::from_chars(str.data(), str.data() + str.size(), *out);
  102|  1.41k|  if (result.ec == std::errc::invalid_argument) {
  ------------------
  |  Branch (102:7): [True: 0, False: 1.41k]
  ------------------
  103|      0|    return false;
  104|      0|  }
  105|  1.41k|  if (result.ptr != str.data() + str.size()) {
  ------------------
  |  Branch (105:7): [True: 0, False: 1.41k]
  ------------------
  106|       |    // not all non-whitespace characters consumed
  107|      0|    return false;
  108|      0|  }
  109|       |  // from_chars() with DR 3081's current wording will return max() on
  110|       |  // overflow.  SimpleAtod returns infinity instead.
  111|  1.41k|  if (result.ec == std::errc::result_out_of_range) {
  ------------------
  |  Branch (111:7): [True: 0, False: 1.41k]
  ------------------
  112|      0|    if (*out > 1.0) {
  ------------------
  |  Branch (112:9): [True: 0, False: 0]
  ------------------
  113|      0|      *out = std::numeric_limits<double>::infinity();
  114|      0|    } else if (*out < -1.0) {
  ------------------
  |  Branch (114:16): [True: 0, False: 0]
  ------------------
  115|      0|      *out = -std::numeric_limits<double>::infinity();
  116|      0|    }
  117|      0|  }
  118|  1.41k|  return true;
  119|  1.41k|}
_ZN4absl10SimpleAtobENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEPb:
  121|  1.41k|bool SimpleAtob(absl::string_view str, bool* absl_nonnull out) {
  122|  1.41k|  ABSL_RAW_CHECK(out != nullptr, "Output pointer must not be nullptr.");
  ------------------
  |  |   60|  1.41k|  do {                                                                 \
  |  |   61|  1.41k|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|  1.41k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 1.41k]
  |  |  |  |  |  Branch (190:49): [Folded, False: 1.41k]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 1.41k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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.41k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 1.41k]
  |  |  ------------------
  ------------------
  |  Branch (122:3): [Folded, False: 0]
  |  Branch (122:3): [True: 0, Folded]
  |  Branch (122:3): [Folded, False: 0]
  ------------------
  123|  1.41k|  if (EqualsIgnoreCase(str, "true") || EqualsIgnoreCase(str, "t") ||
  ------------------
  |  Branch (123:7): [True: 0, False: 1.41k]
  |  Branch (123:40): [True: 0, False: 1.41k]
  ------------------
  124|  1.41k|      EqualsIgnoreCase(str, "yes") || EqualsIgnoreCase(str, "y") ||
  ------------------
  |  Branch (124:7): [True: 0, False: 1.41k]
  |  Branch (124:39): [True: 0, False: 1.41k]
  ------------------
  125|  1.41k|      EqualsIgnoreCase(str, "1")) {
  ------------------
  |  Branch (125:7): [True: 314, False: 1.10k]
  ------------------
  126|    314|    *out = true;
  127|    314|    return true;
  128|    314|  }
  129|  1.10k|  if (EqualsIgnoreCase(str, "false") || EqualsIgnoreCase(str, "f") ||
  ------------------
  |  Branch (129:7): [True: 0, False: 1.10k]
  |  Branch (129:41): [True: 0, False: 1.10k]
  ------------------
  130|  1.10k|      EqualsIgnoreCase(str, "no") || EqualsIgnoreCase(str, "n") ||
  ------------------
  |  Branch (130:7): [True: 0, False: 1.10k]
  |  Branch (130:38): [True: 0, False: 1.10k]
  ------------------
  131|  1.10k|      EqualsIgnoreCase(str, "0")) {
  ------------------
  |  Branch (131:7): [True: 1.10k, False: 0]
  ------------------
  132|  1.10k|    *out = false;
  133|  1.10k|    return true;
  134|  1.10k|  }
  135|      0|  return false;
  136|  1.10k|}
_ZN4absl16numbers_internal12PutTwoDigitsEjPc:
  332|  11.2k|void numbers_internal::PutTwoDigits(uint32_t i, char* absl_nonnull buf) {
  333|  11.2k|  assert(i < 100);
  ------------------
  |  Branch (333:3): [True: 11.2k, False: 0]
  ------------------
  334|  11.2k|  uint32_t base = kTwoZeroBytes;
  335|  11.2k|  uint32_t div10 = (i * kDivisionBy10Mul) / kDivisionBy10Div;
  336|  11.2k|  uint32_t mod10 = i - 10u * div10;
  337|  11.2k|  base += div10 + (mod10 << 8);
  338|  11.2k|  little_endian::Store16(buf, static_cast<uint16_t>(base));
  339|  11.2k|}
_ZN4absl16numbers_internal15FastIntToBufferEiPc:
  349|  8.47k|    int32_t i, char* absl_nonnull buffer) {
  350|  8.47k|  uint32_t u = static_cast<uint32_t>(i);
  351|  8.47k|  if (i < 0) {
  ------------------
  |  Branch (351:7): [True: 2.37k, False: 6.10k]
  ------------------
  352|  2.37k|    *buffer++ = '-';
  353|       |    // We need to do the negation in modular (i.e., "unsigned")
  354|       |    // arithmetic; MSVC++ apparently warns for plain "-u", so
  355|       |    // we write the equivalent expression "0 - u" instead.
  356|  2.37k|    u = 0 - u;
  357|  2.37k|  }
  358|  8.47k|  buffer = EncodeFullU32(u, buffer);
  359|  8.47k|  *buffer = '\0';
  360|  8.47k|  return buffer;
  361|  8.47k|}
_ZN4absl16numbers_internal15FastIntToBufferENS_7uint128EPc:
  386|  1.39k|    uint128 i, char* absl_nonnull buffer) {
  387|  1.39k|  buffer = EncodeFullU128(i, buffer);
  388|  1.39k|  *buffer = '\0';
  389|  1.39k|  return buffer;
  390|  1.39k|}
_ZN4absl16numbers_internal17SixDigitsToBufferEdPc:
 1018|  2.83k|                                           char* absl_nonnull const buffer) {
 1019|  2.83k|  static_assert(std::numeric_limits<float>::is_iec559,
 1020|  2.83k|                "IEEE-754/IEC-559 support only");
 1021|       |
 1022|  2.83k|  char* out = buffer;  // we write data to out, incrementing as we go, but
 1023|       |                       // FloatToBuffer always returns the address of the buffer
 1024|       |                       // passed in.
 1025|       |
 1026|  2.83k|  if (std::isnan(d)) {
  ------------------
  |  Branch (1026:7): [True: 0, False: 2.83k]
  ------------------
 1027|      0|    strcpy(out, "nan");  // NOLINT(runtime/printf)
 1028|      0|    return 3;
 1029|      0|  }
 1030|  2.83k|  if (d == 0) {  // +0 and -0 are handled here
  ------------------
  |  Branch (1030:7): [True: 36, False: 2.80k]
  ------------------
 1031|     36|    if (std::signbit(d)) *out++ = '-';
  ------------------
  |  Branch (1031:9): [True: 0, False: 36]
  ------------------
 1032|     36|    *out++ = '0';
 1033|     36|    *out = 0;
 1034|     36|    return static_cast<size_t>(out - buffer);
 1035|     36|  }
 1036|  2.80k|  if (d < 0) {
  ------------------
  |  Branch (1036:7): [True: 1.73k, False: 1.06k]
  ------------------
 1037|  1.73k|    *out++ = '-';
 1038|  1.73k|    d = -d;
 1039|  1.73k|  }
 1040|  2.80k|  if (d > std::numeric_limits<double>::max()) {
  ------------------
  |  Branch (1040:7): [True: 0, False: 2.80k]
  ------------------
 1041|      0|    strcpy(out, "inf");  // NOLINT(runtime/printf)
 1042|      0|    return static_cast<size_t>(out + 3 - buffer);
 1043|      0|  }
 1044|       |
 1045|  2.80k|  auto exp_dig = SplitToSix(d);
 1046|  2.80k|  int exp = exp_dig.exponent;
 1047|  2.80k|  const char* digits = exp_dig.digits;
 1048|  2.80k|  out[0] = '0';
 1049|  2.80k|  out[1] = '.';
 1050|  2.80k|  switch (exp) {
  ------------------
  |  Branch (1050:11): [True: 0, False: 2.80k]
  ------------------
 1051|      0|    case 5:
  ------------------
  |  Branch (1051:5): [True: 0, False: 2.80k]
  ------------------
 1052|      0|      memcpy(out, &digits[0], 6), out += 6;
 1053|      0|      *out = 0;
 1054|      0|      return static_cast<size_t>(out - buffer);
 1055|      0|    case 4:
  ------------------
  |  Branch (1055:5): [True: 0, False: 2.80k]
  ------------------
 1056|      0|      memcpy(out, &digits[0], 5), out += 5;
 1057|      0|      if (digits[5] != '0') {
  ------------------
  |  Branch (1057:11): [True: 0, False: 0]
  ------------------
 1058|      0|        *out++ = '.';
 1059|      0|        *out++ = digits[5];
 1060|      0|      }
 1061|      0|      *out = 0;
 1062|      0|      return static_cast<size_t>(out - buffer);
 1063|      0|    case 3:
  ------------------
  |  Branch (1063:5): [True: 0, False: 2.80k]
  ------------------
 1064|      0|      memcpy(out, &digits[0], 4), out += 4;
 1065|      0|      if ((digits[5] | digits[4]) != '0') {
  ------------------
  |  Branch (1065:11): [True: 0, False: 0]
  ------------------
 1066|      0|        *out++ = '.';
 1067|      0|        *out++ = digits[4];
 1068|      0|        if (digits[5] != '0') *out++ = digits[5];
  ------------------
  |  Branch (1068:13): [True: 0, False: 0]
  ------------------
 1069|      0|      }
 1070|      0|      *out = 0;
 1071|      0|      return static_cast<size_t>(out - buffer);
 1072|      0|    case 2:
  ------------------
  |  Branch (1072:5): [True: 0, False: 2.80k]
  ------------------
 1073|      0|      memcpy(out, &digits[0], 3), out += 3;
 1074|      0|      *out++ = '.';
 1075|      0|      memcpy(out, &digits[3], 3);
 1076|      0|      out += 3;
 1077|      0|      while (out[-1] == '0') --out;
  ------------------
  |  Branch (1077:14): [True: 0, False: 0]
  ------------------
 1078|      0|      if (out[-1] == '.') --out;
  ------------------
  |  Branch (1078:11): [True: 0, False: 0]
  ------------------
 1079|      0|      *out = 0;
 1080|      0|      return static_cast<size_t>(out - buffer);
 1081|      0|    case 1:
  ------------------
  |  Branch (1081:5): [True: 0, False: 2.80k]
  ------------------
 1082|      0|      memcpy(out, &digits[0], 2), out += 2;
 1083|      0|      *out++ = '.';
 1084|      0|      memcpy(out, &digits[2], 4);
 1085|      0|      out += 4;
 1086|      0|      while (out[-1] == '0') --out;
  ------------------
  |  Branch (1086:14): [True: 0, False: 0]
  ------------------
 1087|      0|      if (out[-1] == '.') --out;
  ------------------
  |  Branch (1087:11): [True: 0, False: 0]
  ------------------
 1088|      0|      *out = 0;
 1089|      0|      return static_cast<size_t>(out - buffer);
 1090|      0|    case 0:
  ------------------
  |  Branch (1090:5): [True: 0, False: 2.80k]
  ------------------
 1091|      0|      memcpy(out, &digits[0], 1), out += 1;
 1092|      0|      *out++ = '.';
 1093|      0|      memcpy(out, &digits[1], 5);
 1094|      0|      out += 5;
 1095|      0|      while (out[-1] == '0') --out;
  ------------------
  |  Branch (1095:14): [True: 0, False: 0]
  ------------------
 1096|      0|      if (out[-1] == '.') --out;
  ------------------
  |  Branch (1096:11): [True: 0, False: 0]
  ------------------
 1097|      0|      *out = 0;
 1098|      0|      return static_cast<size_t>(out - buffer);
 1099|      0|    case -4:
  ------------------
  |  Branch (1099:5): [True: 0, False: 2.80k]
  ------------------
 1100|      0|      out[2] = '0';
 1101|      0|      ++out;
 1102|      0|      ABSL_FALLTHROUGH_INTENDED;
  ------------------
  |  |  673|      0|#define ABSL_FALLTHROUGH_INTENDED [[fallthrough]]
  ------------------
 1103|      0|    case -3:
  ------------------
  |  Branch (1103:5): [True: 0, False: 2.80k]
  ------------------
 1104|      0|      out[2] = '0';
 1105|      0|      ++out;
 1106|      0|      ABSL_FALLTHROUGH_INTENDED;
  ------------------
  |  |  673|      0|#define ABSL_FALLTHROUGH_INTENDED [[fallthrough]]
  ------------------
 1107|      0|    case -2:
  ------------------
  |  Branch (1107:5): [True: 0, False: 2.80k]
  ------------------
 1108|      0|      out[2] = '0';
 1109|      0|      ++out;
 1110|      0|      ABSL_FALLTHROUGH_INTENDED;
  ------------------
  |  |  673|      0|#define ABSL_FALLTHROUGH_INTENDED [[fallthrough]]
  ------------------
 1111|      0|    case -1:
  ------------------
  |  Branch (1111:5): [True: 0, False: 2.80k]
  ------------------
 1112|      0|      out += 2;
 1113|      0|      memcpy(out, &digits[0], 6);
 1114|      0|      out += 6;
 1115|      0|      while (out[-1] == '0') --out;
  ------------------
  |  Branch (1115:14): [True: 0, False: 0]
  ------------------
 1116|      0|      *out = 0;
 1117|      0|      return static_cast<size_t>(out - buffer);
 1118|  2.80k|  }
 1119|  2.80k|  assert(exp < -4 || exp >= 6);
  ------------------
  |  Branch (1119:3): [True: 0, False: 2.80k]
  |  Branch (1119:3): [True: 2.80k, False: 0]
  |  Branch (1119:3): [True: 2.80k, False: 0]
  ------------------
 1120|  2.80k|  out[0] = digits[0];
 1121|  2.80k|  assert(out[1] == '.');
  ------------------
  |  Branch (1121:3): [True: 2.80k, False: 0]
  ------------------
 1122|  2.80k|  out += 2;
 1123|  2.80k|  memcpy(out, &digits[1], 5), out += 5;
 1124|  3.80k|  while (out[-1] == '0') --out;
  ------------------
  |  Branch (1124:10): [True: 1.00k, False: 2.80k]
  ------------------
 1125|  2.80k|  if (out[-1] == '.') --out;
  ------------------
  |  Branch (1125:7): [True: 131, False: 2.67k]
  ------------------
 1126|  2.80k|  *out++ = 'e';
 1127|  2.80k|  if (exp > 0) {
  ------------------
  |  Branch (1127:7): [True: 2.80k, False: 0]
  ------------------
 1128|  2.80k|    *out++ = '+';
 1129|  2.80k|  } else {
 1130|      0|    *out++ = '-';
 1131|      0|    exp = -exp;
 1132|      0|  }
 1133|  2.80k|  if (exp > 99) {
  ------------------
  |  Branch (1133:7): [True: 1.40k, False: 1.39k]
  ------------------
 1134|  1.40k|    int dig1 = exp / 100;
 1135|  1.40k|    exp -= dig1 * 100;
 1136|  1.40k|    *out++ = '0' + static_cast<char>(dig1);
 1137|  1.40k|  }
 1138|  2.80k|  PutTwoDigits(static_cast<uint32_t>(exp), out);
 1139|  2.80k|  out += 2;
 1140|  2.80k|  *out = 0;
 1141|  2.80k|  return static_cast<size_t>(out - buffer);
 1142|  2.80k|}
_ZN4absl16numbers_internal17safe_strto32_baseENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPii:
 1595|  1.41k|                       int base) {
 1596|  1.41k|  return safe_int_internal<int32_t>(text, value, base);
 1597|  1.41k|}
numbers.cc:_ZN4absl12_GLOBAL__N_113EncodeFullU32EjPc:
  259|  9.87k|    uint32_t n, char* absl_nonnull out_str) {
  260|  9.87k|  if (n < 10) {
  ------------------
  |  Branch (260:7): [True: 2.88k, False: 6.98k]
  ------------------
  261|  2.88k|    *out_str = static_cast<char>('0' + n);
  262|  2.88k|    return out_str + 1;
  263|  2.88k|  }
  264|  6.98k|  if (n < 100'000'000) {
  ------------------
  |  Branch (264:7): [True: 4.37k, False: 2.61k]
  ------------------
  265|  4.37k|    uint64_t bottom = PrepareEightDigits(n);
  266|  4.37k|    ABSL_ASSUME(bottom != 0);
  ------------------
  |  |  269|  4.37k|#define ABSL_ASSUME(cond) assert(cond)
  ------------------
  |  Branch (266:5): [True: 4.37k, False: 0]
  ------------------
  267|       |    // 0 minus 8 to make MSVC happy.
  268|  4.37k|    uint32_t zeroes =
  269|  4.37k|        static_cast<uint32_t>(absl::countr_zero(bottom)) & (0 - 8u);
  270|  4.37k|    little_endian::Store64(out_str, (bottom + kEightZeroBytes) >> zeroes);
  271|  4.37k|    return out_str + sizeof(bottom) - zeroes / 8;
  272|  4.37k|  }
  273|  2.61k|  uint32_t div08 = n / 100'000'000;
  274|  2.61k|  uint32_t mod08 = n % 100'000'000;
  275|  2.61k|  uint64_t bottom = PrepareEightDigits(mod08) + kEightZeroBytes;
  276|  2.61k|  out_str = EncodeHundred(div08, out_str);
  277|  2.61k|  little_endian::Store64(out_str, bottom);
  278|  2.61k|  return out_str + sizeof(bottom);
  279|  6.98k|}
numbers.cc:_ZN4absl12_GLOBAL__N_118PrepareEightDigitsEj:
  230|  12.5k|inline uint64_t PrepareEightDigits(uint32_t i) {
  231|  12.5k|  ABSL_ASSUME(i < 10000'0000);
  ------------------
  |  |  269|  12.5k|#define ABSL_ASSUME(cond) assert(cond)
  ------------------
  |  Branch (231:3): [True: 12.5k, False: 0]
  ------------------
  232|       |  // Prepare 2 blocks of 4 digits "in parallel".
  233|  12.5k|  uint32_t hi = i / 10000;
  234|  12.5k|  uint32_t lo = i % 10000;
  235|  12.5k|  uint64_t merged = hi | (uint64_t{lo} << 32);
  236|  12.5k|  uint64_t div100 = ((merged * kDivisionBy100Mul) / kDivisionBy100Div) &
  237|  12.5k|                    ((0x7Full << 32) | 0x7Full);
  238|  12.5k|  uint64_t mod100 = merged - 100ull * div100;
  239|  12.5k|  uint64_t hundreds = (mod100 << 16) + div100;
  240|  12.5k|  uint64_t tens = (hundreds * kDivisionBy10Mul) / kDivisionBy10Div;
  241|  12.5k|  tens &= (0xFull << 48) | (0xFull << 32) | (0xFull << 16) | 0xFull;
  242|  12.5k|  tens += (hundreds - 10ull * tens) << 8;
  243|  12.5k|  return tens;
  244|  12.5k|}
numbers.cc:_ZN4absl12_GLOBAL__N_113EncodeHundredEjPc:
  180|  2.61k|inline char* EncodeHundred(uint32_t n, char* absl_nonnull out_str) {
  181|  2.61k|  int num_digits = static_cast<int>(n - 10) >> 8;
  182|  2.61k|  uint32_t div10 = (n * kDivisionBy10Mul) / kDivisionBy10Div;
  183|  2.61k|  uint32_t mod10 = n - 10u * div10;
  184|  2.61k|  uint32_t base = kTwoZeroBytes + div10 + (mod10 << 8);
  185|  2.61k|  base >>= num_digits & 8;
  186|  2.61k|  little_endian::Store16(out_str, static_cast<uint16_t>(base));
  187|  2.61k|  return out_str + 2 + num_digits;
  188|  2.61k|}
numbers.cc:_ZN4absl12_GLOBAL__N_113EncodeFullU64EmPc:
  282|  1.39k|    uint64_t i, char* absl_nonnull buffer) {
  283|  1.39k|  if (i <= std::numeric_limits<uint32_t>::max()) {
  ------------------
  |  Branch (283:7): [True: 1.32k, False: 74]
  ------------------
  284|  1.32k|    return EncodeFullU32(static_cast<uint32_t>(i), buffer);
  285|  1.32k|  }
  286|     74|  uint32_t mod08;
  287|     74|  if (i < 1'0000'0000'0000'0000ull) {
  ------------------
  |  Branch (287:7): [True: 74, False: 0]
  ------------------
  288|     74|    uint32_t div08 = static_cast<uint32_t>(i / 100'000'000ull);
  289|     74|    mod08 = static_cast<uint32_t>(i % 100'000'000ull);
  290|     74|    buffer = EncodeFullU32(div08, buffer);
  291|     74|  } else {
  292|      0|    uint64_t div08 = i / 100'000'000ull;
  293|      0|    mod08 = static_cast<uint32_t>(i % 100'000'000ull);
  294|      0|    uint32_t div016 = static_cast<uint32_t>(div08 / 100'000'000ull);
  295|      0|    uint32_t div08mod08 = static_cast<uint32_t>(div08 % 100'000'000ull);
  296|      0|    uint64_t mid_result = PrepareEightDigits(div08mod08) + kEightZeroBytes;
  297|      0|    buffer = EncodeTenThousand(div016, buffer);
  298|      0|    little_endian::Store64(buffer, mid_result);
  299|      0|    buffer += sizeof(mid_result);
  300|      0|  }
  301|     74|  uint64_t mod_result = PrepareEightDigits(mod08) + kEightZeroBytes;
  302|     74|  little_endian::Store64(buffer, mod_result);
  303|     74|  return buffer + sizeof(mod_result);
  304|  1.39k|}
numbers.cc:_ZN4absl12_GLOBAL__N_114EncodeFullU128ENS_7uint128EPc:
  307|  1.39k|    uint128 i, char* absl_nonnull buffer) {
  308|  1.39k|  if (absl::Uint128High64(i) == 0) {
  ------------------
  |  Branch (308:7): [True: 0, False: 1.39k]
  ------------------
  309|      0|    return EncodeFullU64(absl::Uint128Low64(i), buffer);
  310|      0|  }
  311|       |  // We divide the number into 16-digit chunks because `EncodePadded16` is
  312|       |  // optimized to handle 16 digits at a time (as two 8-digit chunks).
  313|  1.39k|  constexpr uint64_t k1e16 = uint64_t{10'000'000'000'000'000};
  314|  1.39k|  uint128 high = i / k1e16;
  315|  1.39k|  uint64_t low = absl::Uint128Low64(i % k1e16);
  316|  1.39k|  uint64_t mid = absl::Uint128Low64(high % k1e16);
  317|  1.39k|  high /= k1e16;
  318|       |
  319|  1.39k|  if (high == 0) {
  ------------------
  |  Branch (319:7): [True: 74, False: 1.32k]
  ------------------
  320|     74|    buffer = EncodeFullU64(mid, buffer);
  321|     74|    buffer = EncodePadded16(low, buffer);
  322|  1.32k|  } else {
  323|  1.32k|    buffer = EncodeFullU64(absl::Uint128Low64(high), buffer);
  324|  1.32k|    buffer = EncodePadded16(mid, buffer);
  325|  1.32k|    buffer = EncodePadded16(low, buffer);
  326|  1.32k|  }
  327|  1.39k|  return buffer;
  328|  1.39k|}
numbers.cc:_ZN4absl12_GLOBAL__N_114EncodePadded16EmPc:
  249|  2.72k|inline char* EncodePadded16(uint64_t v, char* absl_nonnull buffer) {
  250|  2.72k|  constexpr uint64_t k1e8 = 100000000;
  251|  2.72k|  uint32_t hi = static_cast<uint32_t>(v / k1e8);
  252|  2.72k|  uint32_t lo = static_cast<uint32_t>(v % k1e8);
  253|  2.72k|  little_endian::Store64(buffer, PrepareEightDigits(hi) + kEightZeroBytes);
  254|  2.72k|  little_endian::Store64(buffer + 8, PrepareEightDigits(lo) + kEightZeroBytes);
  255|  2.72k|  return buffer + 16;
  256|  2.72k|}
numbers.cc:_ZN4abslL10SplitToSixEd:
  896|  2.80k|static ExpDigits SplitToSix(const double value) {
  897|  2.80k|  ExpDigits exp_dig;
  898|  2.80k|  int exp = 5;
  899|  2.80k|  double d = value;
  900|       |  // First step: calculate a close approximation of the output, where the
  901|       |  // value d will be between 100,000 and 999,999, representing the digits
  902|       |  // in the output ASCII array, and exp is the base-10 exponent.  It would be
  903|       |  // faster to use a table here, and to look up the base-2 exponent of value,
  904|       |  // however value is an IEEE-754 64-bit number, so the table would have 2,000
  905|       |  // entries, which is not cache-friendly.
  906|  2.80k|  if (d >= 999999.5) {
  ------------------
  |  Branch (906:7): [True: 2.80k, False: 0]
  ------------------
  907|  2.80k|    if (d >= 1e+261) exp += 256, d *= 1e-256;
  ------------------
  |  Branch (907:9): [True: 1.40k, False: 1.39k]
  ------------------
  908|  2.80k|    if (d >= 1e+133) exp += 128, d *= 1e-128;
  ------------------
  |  Branch (908:9): [True: 0, False: 2.80k]
  ------------------
  909|  2.80k|    if (d >= 1e+69) exp += 64, d *= 1e-64;
  ------------------
  |  Branch (909:9): [True: 0, False: 2.80k]
  ------------------
  910|  2.80k|    if (d >= 1e+37) exp += 32, d *= 1e-32;
  ------------------
  |  Branch (910:9): [True: 2.40k, False: 398]
  ------------------
  911|  2.80k|    if (d >= 1e+21) exp += 16, d *= 1e-16;
  ------------------
  |  Branch (911:9): [True: 398, False: 2.40k]
  ------------------
  912|  2.80k|    if (d >= 1e+13) exp += 8, d *= 1e-8;
  ------------------
  |  Branch (912:9): [True: 1.61k, False: 1.19k]
  ------------------
  913|  2.80k|    if (d >= 1e+9) exp += 4, d *= 1e-4;
  ------------------
  |  Branch (913:9): [True: 1.50k, False: 1.29k]
  ------------------
  914|  2.80k|    if (d >= 1e+7) exp += 2, d *= 1e-2;
  ------------------
  |  Branch (914:9): [True: 1.43k, False: 1.36k]
  ------------------
  915|  2.80k|    if (d >= 1e+6) exp += 1, d *= 1e-1;
  ------------------
  |  Branch (915:9): [True: 1.93k, False: 863]
  ------------------
  916|  2.80k|  } else {
  917|      0|    if (d < 1e-250) exp -= 256, d *= 1e256;
  ------------------
  |  Branch (917:9): [True: 0, False: 0]
  ------------------
  918|      0|    if (d < 1e-122) exp -= 128, d *= 1e128;
  ------------------
  |  Branch (918:9): [True: 0, False: 0]
  ------------------
  919|      0|    if (d < 1e-58) exp -= 64, d *= 1e64;
  ------------------
  |  Branch (919:9): [True: 0, False: 0]
  ------------------
  920|      0|    if (d < 1e-26) exp -= 32, d *= 1e32;
  ------------------
  |  Branch (920:9): [True: 0, False: 0]
  ------------------
  921|      0|    if (d < 1e-10) exp -= 16, d *= 1e16;
  ------------------
  |  Branch (921:9): [True: 0, False: 0]
  ------------------
  922|      0|    if (d < 1e-2) exp -= 8, d *= 1e8;
  ------------------
  |  Branch (922:9): [True: 0, False: 0]
  ------------------
  923|      0|    if (d < 1e+2) exp -= 4, d *= 1e4;
  ------------------
  |  Branch (923:9): [True: 0, False: 0]
  ------------------
  924|      0|    if (d < 1e+4) exp -= 2, d *= 1e2;
  ------------------
  |  Branch (924:9): [True: 0, False: 0]
  ------------------
  925|      0|    if (d < 1e+5) exp -= 1, d *= 1e1;
  ------------------
  |  Branch (925:9): [True: 0, False: 0]
  ------------------
  926|      0|  }
  927|       |  // At this point, d is in the range [99999.5..999999.5) and exp is in the
  928|       |  // range [-324..308]. Since we need to round d up, we want to add a half
  929|       |  // and truncate.
  930|       |  // However, the technique above may have lost some precision, due to its
  931|       |  // repeated multiplication by constants that each may be off by half a bit
  932|       |  // of precision.  This only matters if we're close to the edge though.
  933|       |  // Since we'd like to know if the fractional part of d is close to a half,
  934|       |  // we multiply it by 65536 and see if the fractional part is close to 32768.
  935|       |  // (The number doesn't have to be a power of two,but powers of two are faster)
  936|  2.80k|  uint64_t d64k = static_cast<uint64_t>(d * 65536);
  937|  2.80k|  uint32_t dddddd;  // A 6-digit decimal integer.
  938|  2.80k|  if ((d64k % 65536) == 32767 || (d64k % 65536) == 32768) {
  ------------------
  |  Branch (938:7): [True: 0, False: 2.80k]
  |  Branch (938:34): [True: 0, False: 2.80k]
  ------------------
  939|       |    // OK, it's fairly likely that precision was lost above, which is
  940|       |    // not a surprise given only 52 mantissa bits are available.  Therefore
  941|       |    // redo the calculation using 128-bit numbers.  (64 bits are not enough).
  942|       |
  943|       |    // Start out with digits rounded down; maybe add one below.
  944|      0|    dddddd = static_cast<uint32_t>(d64k / 65536);
  945|       |
  946|       |    // mantissa is a 64-bit integer representing M.mmm... * 2^63.  The actual
  947|       |    // value we're representing, of course, is M.mmm... * 2^exp2.
  948|      0|    int exp2;
  949|      0|    double m = std::frexp(value, &exp2);
  950|      0|    uint64_t mantissa =
  951|      0|        static_cast<uint64_t>(m * (32768.0 * 65536.0 * 65536.0 * 65536.0));
  952|       |    // std::frexp returns an m value in the range [0.5, 1.0), however we
  953|       |    // can't multiply it by 2^64 and convert to an integer because some FPUs
  954|       |    // throw an exception when converting an number higher than 2^63 into an
  955|       |    // integer - even an unsigned 64-bit integer!  Fortunately it doesn't matter
  956|       |    // since m only has 52 significant bits anyway.
  957|      0|    mantissa <<= 1;
  958|      0|    exp2 -= 64;  // not needed, but nice for debugging
  959|       |
  960|       |    // OK, we are here to compare:
  961|       |    //     (dddddd + 0.5) * 10^(exp-5)  vs.  mantissa * 2^exp2
  962|       |    // so we can round up dddddd if appropriate.  Those values span the full
  963|       |    // range of 600 orders of magnitude of IEE 64-bit floating-point.
  964|       |    // Fortunately, we already know they are very close, so we don't need to
  965|       |    // track the base-2 exponent of both sides.  This greatly simplifies the
  966|       |    // the math since the 2^exp2 calculation is unnecessary and the power-of-10
  967|       |    // calculation can become a power-of-5 instead.
  968|       |
  969|      0|    std::pair<uint64_t, uint64_t> edge, val;
  970|      0|    if (exp >= 6) {
  ------------------
  |  Branch (970:9): [True: 0, False: 0]
  ------------------
  971|       |      // Compare (dddddd + 0.5) * 5 ^ (exp - 5) to mantissa
  972|       |      // Since we're tossing powers of two, 2 * dddddd + 1 is the
  973|       |      // same as dddddd + 0.5
  974|      0|      edge = PowFive(2 * dddddd + 1, exp - 5);
  975|       |
  976|      0|      val.first = mantissa;
  977|      0|      val.second = 0;
  978|      0|    } else {
  979|       |      // We can't compare (dddddd + 0.5) * 5 ^ (exp - 5) to mantissa as we did
  980|       |      // above because (exp - 5) is negative.  So we compare (dddddd + 0.5) to
  981|       |      // mantissa * 5 ^ (5 - exp)
  982|      0|      edge = PowFive(2 * dddddd + 1, 0);
  983|       |
  984|      0|      val = PowFive(mantissa, 5 - exp);
  985|      0|    }
  986|       |    // printf("exp=%d %016lx %016lx vs %016lx %016lx\n", exp, val.first,
  987|       |    //        val.second, edge.first, edge.second);
  988|      0|    if (val > edge) {
  ------------------
  |  Branch (988:9): [True: 0, False: 0]
  ------------------
  989|      0|      dddddd++;
  990|      0|    } else if (val == edge) {
  ------------------
  |  Branch (990:16): [True: 0, False: 0]
  ------------------
  991|      0|      dddddd += (dddddd & 1);
  992|      0|    }
  993|  2.80k|  } else {
  994|       |    // Here, we are not close to the edge.
  995|  2.80k|    dddddd = static_cast<uint32_t>((d64k + 32768) / 65536);
  996|  2.80k|  }
  997|  2.80k|  if (dddddd == 1000000) {
  ------------------
  |  Branch (997:7): [True: 50, False: 2.75k]
  ------------------
  998|     50|    dddddd = 100000;
  999|     50|    exp += 1;
 1000|     50|  }
 1001|  2.80k|  exp_dig.exponent = exp;
 1002|       |
 1003|  2.80k|  uint32_t two_digits = dddddd / 10000;
 1004|  2.80k|  dddddd -= two_digits * 10000;
 1005|  2.80k|  numbers_internal::PutTwoDigits(two_digits, &exp_dig.digits[0]);
 1006|       |
 1007|  2.80k|  two_digits = dddddd / 100;
 1008|  2.80k|  dddddd -= two_digits * 100;
 1009|  2.80k|  numbers_internal::PutTwoDigits(two_digits, &exp_dig.digits[2]);
 1010|       |
 1011|  2.80k|  numbers_internal::PutTwoDigits(dddddd, &exp_dig.digits[4]);
 1012|  2.80k|  return exp_dig;
 1013|  2.80k|}
numbers.cc:_ZN4absl12_GLOBAL__N_124safe_parse_sign_and_baseEPNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPiPb:
 1168|  1.41k|    bool* absl_nonnull negative_ptr /*output*/) {
 1169|  1.41k|  if (text->data() == nullptr) {
  ------------------
  |  Branch (1169:7): [True: 0, False: 1.41k]
  ------------------
 1170|      0|    return false;
 1171|      0|  }
 1172|       |
 1173|  1.41k|  const char* start = text->data();
 1174|  1.41k|  const char* end = start + text->size();
 1175|  1.41k|  int base = *base_ptr;
 1176|       |
 1177|       |  // Consume whitespace.
 1178|  1.41k|  while (start < end &&
  ------------------
  |  Branch (1178:10): [True: 1.41k, False: 0]
  ------------------
 1179|  1.41k|         absl::ascii_isspace(static_cast<unsigned char>(start[0]))) {
  ------------------
  |  Branch (1179:10): [True: 0, False: 1.41k]
  ------------------
 1180|      0|    ++start;
 1181|      0|  }
 1182|  1.41k|  while (start < end &&
  ------------------
  |  Branch (1182:10): [True: 1.41k, False: 0]
  ------------------
 1183|  1.41k|         absl::ascii_isspace(static_cast<unsigned char>(end[-1]))) {
  ------------------
  |  Branch (1183:10): [True: 0, False: 1.41k]
  ------------------
 1184|      0|    --end;
 1185|      0|  }
 1186|  1.41k|  if (start >= end) {
  ------------------
  |  Branch (1186:7): [True: 0, False: 1.41k]
  ------------------
 1187|      0|    return false;
 1188|      0|  }
 1189|       |
 1190|       |  // Consume sign.
 1191|  1.41k|  *negative_ptr = (start[0] == '-');
 1192|  1.41k|  if (*negative_ptr || start[0] == '+') {
  ------------------
  |  Branch (1192:7): [True: 1.18k, False: 234]
  |  Branch (1192:24): [True: 0, False: 234]
  ------------------
 1193|  1.18k|    ++start;
 1194|  1.18k|    if (start >= end) {
  ------------------
  |  Branch (1194:9): [True: 0, False: 1.18k]
  ------------------
 1195|      0|      return false;
 1196|      0|    }
 1197|  1.18k|  }
 1198|       |
 1199|       |  // Consume base-dependent prefix.
 1200|       |  //  base 0: "0x" -> base 16, "0" -> base 8, default -> base 10
 1201|       |  //  base 16: "0x" -> base 16
 1202|       |  // Also validate the base.
 1203|  1.41k|  if (base == 0) {
  ------------------
  |  Branch (1203:7): [True: 0, False: 1.41k]
  ------------------
 1204|      0|    if (end - start >= 2 && start[0] == '0' &&
  ------------------
  |  Branch (1204:9): [True: 0, False: 0]
  |  Branch (1204:29): [True: 0, False: 0]
  ------------------
 1205|      0|        (start[1] == 'x' || start[1] == 'X')) {
  ------------------
  |  Branch (1205:10): [True: 0, False: 0]
  |  Branch (1205:29): [True: 0, False: 0]
  ------------------
 1206|      0|      base = 16;
 1207|      0|      start += 2;
 1208|      0|      if (start >= end) {
  ------------------
  |  Branch (1208:11): [True: 0, False: 0]
  ------------------
 1209|       |        // "0x" with no digits after is invalid.
 1210|      0|        return false;
 1211|      0|      }
 1212|      0|    } else if (end - start >= 1 && start[0] == '0') {
  ------------------
  |  Branch (1212:16): [True: 0, False: 0]
  |  Branch (1212:36): [True: 0, False: 0]
  ------------------
 1213|      0|      base = 8;
 1214|      0|      start += 1;
 1215|      0|    } else {
 1216|      0|      base = 10;
 1217|      0|    }
 1218|  1.41k|  } else if (base == 16) {
  ------------------
  |  Branch (1218:14): [True: 0, False: 1.41k]
  ------------------
 1219|      0|    if (end - start >= 2 && start[0] == '0' &&
  ------------------
  |  Branch (1219:9): [True: 0, False: 0]
  |  Branch (1219:29): [True: 0, False: 0]
  ------------------
 1220|      0|        (start[1] == 'x' || start[1] == 'X')) {
  ------------------
  |  Branch (1220:10): [True: 0, False: 0]
  |  Branch (1220:29): [True: 0, False: 0]
  ------------------
 1221|      0|      start += 2;
 1222|      0|      if (start >= end) {
  ------------------
  |  Branch (1222:11): [True: 0, False: 0]
  ------------------
 1223|       |        // "0x" with no digits after is invalid.
 1224|      0|        return false;
 1225|      0|      }
 1226|      0|    }
 1227|  1.41k|  } else if (base >= 2 && base <= 36) {
  ------------------
  |  Branch (1227:14): [True: 1.41k, False: 0]
  |  Branch (1227:27): [True: 1.41k, False: 0]
  ------------------
 1228|       |    // okay
 1229|  1.41k|  } else {
 1230|      0|    return false;
 1231|      0|  }
 1232|  1.41k|  *text = absl::string_view(start, static_cast<size_t>(end - start));
 1233|  1.41k|  *base_ptr = base;
 1234|  1.41k|  return true;
 1235|  1.41k|}
numbers.cc:_ZN4absl12_GLOBAL__N_117safe_int_internalIiEEbNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPT_i:
 1535|  1.41k|                              IntType* absl_nonnull value_p, int base) {
 1536|  1.41k|  *value_p = 0;
 1537|  1.41k|  bool negative;
 1538|  1.41k|  if (!safe_parse_sign_and_base(&text, &base, &negative)) {
  ------------------
  |  Branch (1538:7): [True: 0, False: 1.41k]
  ------------------
 1539|      0|    return false;
 1540|      0|  }
 1541|  1.41k|  if (!negative) {
  ------------------
  |  Branch (1541:7): [True: 234, False: 1.18k]
  ------------------
 1542|    234|    return safe_parse_positive_int(text, base, value_p);
 1543|  1.18k|  } else {
 1544|  1.18k|    return safe_parse_negative_int(text, base, value_p);
 1545|  1.18k|  }
 1546|  1.41k|}
numbers.cc:_ZN4absl12_GLOBAL__N_123safe_parse_positive_intIiEEbNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEiPT_:
 1453|    234|                                    IntType* absl_nonnull value_p) {
 1454|    234|  IntType value = 0;
 1455|    234|  const IntType vmax = std::numeric_limits<IntType>::max();
 1456|    234|  assert(vmax > 0);
  ------------------
  |  Branch (1456:3): [True: 234, Folded]
  ------------------
 1457|    234|  assert(base >= 0);
  ------------------
  |  Branch (1457:3): [True: 234, False: 0]
  ------------------
 1458|    234|  const IntType base_inttype = static_cast<IntType>(base);
 1459|    234|  assert(vmax >= base_inttype);
  ------------------
  |  Branch (1459:3): [True: 234, False: 0]
  ------------------
 1460|    234|  const IntType vmax_over_base = LookupTables<IntType>::kVmaxOverBase[base];
 1461|    234|  assert(base < 2 ||
  ------------------
  |  Branch (1461:3): [True: 0, False: 234]
  |  Branch (1461:3): [True: 234, False: 0]
  |  Branch (1461:3): [True: 234, False: 0]
  ------------------
 1462|    234|         std::numeric_limits<IntType>::max() / base_inttype == vmax_over_base);
 1463|    234|  const char* start = text.data();
 1464|    234|  const char* end = start + text.size();
 1465|       |  // loop over digits
 1466|  2.37k|  for (; start < end; ++start) {
  ------------------
  |  Branch (1466:10): [True: 2.14k, False: 234]
  ------------------
 1467|  2.14k|    unsigned char c = static_cast<unsigned char>(start[0]);
 1468|  2.14k|    IntType digit = static_cast<IntType>(kAsciiToInt[c]);
 1469|  2.14k|    if (digit >= base_inttype) {
  ------------------
  |  Branch (1469:9): [True: 0, False: 2.14k]
  ------------------
 1470|      0|      *value_p = value;
 1471|      0|      return false;
 1472|      0|    }
 1473|  2.14k|    if (value > vmax_over_base) {
  ------------------
  |  Branch (1473:9): [True: 0, False: 2.14k]
  ------------------
 1474|      0|      *value_p = vmax;
 1475|      0|      return false;
 1476|      0|    }
 1477|  2.14k|    value *= base_inttype;
 1478|  2.14k|    if (value > vmax - digit) {
  ------------------
  |  Branch (1478:9): [True: 0, False: 2.14k]
  ------------------
 1479|      0|      *value_p = vmax;
 1480|      0|      return false;
 1481|      0|    }
 1482|  2.14k|    value += digit;
 1483|  2.14k|  }
 1484|    234|  *value_p = value;
 1485|    234|  return true;
 1486|    234|}
numbers.cc:_ZN4absl12_GLOBAL__N_123safe_parse_negative_intIiEEbNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEiPT_:
 1490|  1.18k|                                    IntType* absl_nonnull value_p) {
 1491|  1.18k|  IntType value = 0;
 1492|  1.18k|  const IntType vmin = std::numeric_limits<IntType>::min();
 1493|  1.18k|  assert(vmin < 0);
  ------------------
  |  Branch (1493:3): [True: 1.18k, Folded]
  ------------------
 1494|  1.18k|  assert(vmin <= 0 - base);
  ------------------
  |  Branch (1494:3): [True: 1.18k, False: 0]
  ------------------
 1495|  1.18k|  IntType vmin_over_base = LookupTables<IntType>::kVminOverBase[base];
 1496|  1.18k|  assert(base < 2 ||
  ------------------
  |  Branch (1496:3): [True: 0, False: 1.18k]
  |  Branch (1496:3): [True: 1.18k, False: 0]
  |  Branch (1496:3): [True: 1.18k, False: 0]
  ------------------
 1497|  1.18k|         std::numeric_limits<IntType>::min() / base == vmin_over_base);
 1498|       |  // 2003 c++ standard [expr.mul]
 1499|       |  // "... the sign of the remainder is implementation-defined."
 1500|       |  // Although (vmin/base)*base + vmin%base is always vmin.
 1501|       |  // 2011 c++ standard tightens the spec but we cannot rely on it.
 1502|       |  // TODO(junyer): Handle this in the lookup table generation.
 1503|  1.18k|  if (vmin % base > 0) {
  ------------------
  |  Branch (1503:7): [True: 0, False: 1.18k]
  ------------------
 1504|      0|    vmin_over_base += 1;
 1505|      0|  }
 1506|  1.18k|  const char* start = text.data();
 1507|  1.18k|  const char* end = start + text.size();
 1508|       |  // loop over digits
 1509|  12.6k|  for (; start < end; ++start) {
  ------------------
  |  Branch (1509:10): [True: 11.4k, False: 1.18k]
  ------------------
 1510|  11.4k|    unsigned char c = static_cast<unsigned char>(start[0]);
 1511|  11.4k|    int digit = kAsciiToInt[c];
 1512|  11.4k|    if (digit >= base) {
  ------------------
  |  Branch (1512:9): [True: 0, False: 11.4k]
  ------------------
 1513|      0|      *value_p = value;
 1514|      0|      return false;
 1515|      0|    }
 1516|  11.4k|    if (value < vmin_over_base) {
  ------------------
  |  Branch (1516:9): [True: 0, False: 11.4k]
  ------------------
 1517|      0|      *value_p = vmin;
 1518|      0|      return false;
 1519|      0|    }
 1520|  11.4k|    value *= base;
 1521|  11.4k|    if (value < vmin + digit) {
  ------------------
  |  Branch (1521:9): [True: 0, False: 11.4k]
  ------------------
 1522|      0|      *value_p = vmin;
 1523|      0|      return false;
 1524|      0|    }
 1525|  11.4k|    value -= digit;
 1526|  11.4k|  }
 1527|  1.18k|  *value_p = value;
 1528|  1.18k|  return true;
 1529|  1.18k|}

_ZN4absl10SimpleAtoiIiEEbNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPT_:
  330|  1.41k|                              int_type* absl_nonnull out) {
  331|  1.41k|  return numbers_internal::safe_strtoi_base(str, out, 10);
  332|  1.41k|}
_ZN4absl16numbers_internal16safe_strtoi_baseIiEEbNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPT_i:
  247|  1.41k|                                    int_type* absl_nonnull out, int base) {
  248|  1.41k|  static_assert(sizeof(*out) == 1 || sizeof(*out) == 2 || sizeof(*out) == 4 ||
  249|  1.41k|                    sizeof(*out) == 8,
  250|  1.41k|                "SimpleAtoi works only with 8, 16, 32, or 64-bit integers.");
  251|  1.41k|  static_assert(!std::is_floating_point<int_type>::value,
  252|  1.41k|                "Use SimpleAtof or SimpleAtod instead.");
  253|  1.41k|  bool parsed;
  254|       |  // These conditions are constexpr bools to suppress MSVC warning C4127.
  255|  1.41k|  constexpr bool kIsSigned = is_signed<int_type>();
  256|  1.41k|  constexpr int kIntTypeSize = sizeof(*out) * 8;
  257|  1.41k|  if (kIsSigned) {
  ------------------
  |  Branch (257:7): [True: 1.41k, Folded]
  ------------------
  258|  1.41k|    if (kIntTypeSize == 64) {
  ------------------
  |  Branch (258:9): [Folded, False: 1.41k]
  ------------------
  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.41k|    } else if (kIntTypeSize == 32) {
  ------------------
  |  Branch (262:16): [True: 1.41k, Folded]
  ------------------
  263|  1.41k|      int32_t val;
  264|  1.41k|      parsed = numbers_internal::safe_strto32_base(s, &val, base);
  265|  1.41k|      *out = static_cast<int_type>(val);
  266|  1.41k|    } 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.41k|  } 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.41k|  return parsed;
  295|  1.41k|}

_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.41k|void StringResizeAndOverwrite(T& str, typename T::size_type n, Op op) {
  187|  1.41k|  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.41k|}
_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.41k|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.41k|  } else if constexpr (strings_internal::has__resize_default_init<T>::value) {
  160|  1.41k|    str.__resize_default_init(n);
  161|  1.41k|    str.__resize_default_init(
  162|  1.41k|        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.41k|#endif
  169|  1.41k|}
str_cat.cc:_ZN4absl24StringResizeAndOverwriteINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEZNS_16strings_internal9CatPiecesESt16initializer_listINS1_17basic_string_viewIcS4_EEEE3$_0EEvRT_NSE_9size_typeET0_:
  186|  1.41k|void StringResizeAndOverwrite(T& str, typename T::size_type n, Op op) {
  187|  1.41k|  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.41k|}
str_cat.cc:_ZN4absl16strings_internal28StringResizeAndOverwriteImplINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEZNS0_9CatPiecesESt16initializer_listINS2_17basic_string_viewIcS5_EEEE3$_0EEvRT_NSE_9size_typeET0_:
  149|  1.41k|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.41k|  } else if constexpr (strings_internal::has__resize_default_init<T>::value) {
  160|  1.41k|    str.__resize_default_init(n);
  161|  1.41k|    str.__resize_default_init(
  162|  1.41k|        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.41k|#endif
  169|  1.41k|}
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.41k|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.41k|  } else if constexpr (strings_internal::has__resize_default_init<T>::value) {
  160|  1.41k|    str.__resize_default_init(n);
  161|  1.41k|    str.__resize_default_init(
  162|  1.41k|        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.41k|#endif
  169|  1.41k|}

_ZN4absl16strings_internal9CatPiecesESt16initializer_listINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEE:
  126|  1.41k|std::string CatPieces(std::initializer_list<absl::string_view> pieces) {
  127|  1.41k|  std::string result;
  128|       |  // Use uint64_t to prevent size_t overflow. We assume it is not possible for
  129|       |  // in memory strings to overflow a uint64_t.
  130|  1.41k|  constexpr uint64_t kMaxSize = uint64_t{std::numeric_limits<size_t>::max()};
  131|  1.41k|  uint64_t total_size = 0;
  132|  7.09k|  for (absl::string_view piece : pieces) {
  ------------------
  |  Branch (132:32): [True: 7.09k, False: 1.41k]
  ------------------
  133|  7.09k|    total_size += piece.size();
  134|  7.09k|  }
  135|  1.41k|  ABSL_INTERNAL_CHECK(total_size <= kMaxSize, "size_t overflow");
  ------------------
  |  |   85|  1.41k|  do {                                                             \
  |  |   86|  1.41k|    if (ABSL_PREDICT_FALSE(!(condition))) {                        \
  |  |  ------------------
  |  |  |  |  190|  1.41k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 1.41k]
  |  |  |  |  |  Branch (190:49): [Folded, False: 1.41k]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 1.41k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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.41k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (91:12): [Folded, False: 1.41k]
  |  |  ------------------
  ------------------
  |  Branch (135:3): [Folded, False: 0]
  |  Branch (135:3): [True: 0, Folded]
  |  Branch (135:3): [Folded, False: 0]
  ------------------
  136|  1.41k|  absl::StringResizeAndOverwrite(result, static_cast<size_t>(total_size),
  137|  1.41k|                                 [&pieces](char* const begin, size_t buf_size) {
  138|  1.41k|                                   char* out = begin;
  139|  1.41k|                                   for (absl::string_view piece : pieces) {
  140|  1.41k|                                     const size_t this_size = piece.size();
  141|  1.41k|                                     if (this_size != 0) {
  142|  1.41k|                                       memcpy(out, piece.data(), this_size);
  143|  1.41k|                                       out += this_size;
  144|  1.41k|                                     }
  145|  1.41k|                                   }
  146|  1.41k|                                   assert(out == begin + buf_size);
  147|  1.41k|                                   return buf_size;
  148|  1.41k|                                 });
  149|  1.41k|  return result;
  150|  1.41k|}
_ZN4absl9StrAppendEPNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEERKNS_8AlphaNumE:
  185|  1.41k|void StrAppend(std::string* absl_nonnull dest, const AlphaNum& a) {
  186|  1.41k|  ASSERT_NO_OVERLAP(*dest, a);
  ------------------
  |  |  158|  1.41k|  assert(((src).size() == 0) ||      \
  |  |  159|  1.41k|         (uintptr_t((src).data() - (dest).data()) > uintptr_t((dest).size())))
  ------------------
  |  Branch (186:3): [True: 1.02k, False: 397]
  |  Branch (186:3): [True: 397, False: 0]
  |  Branch (186:3): [True: 1.41k, False: 0]
  ------------------
  187|  1.41k|  strings_internal::StringAppendAndOverwrite(
  188|  1.41k|      *dest, a.size(), [&a](char* const buf, size_t buf_size) {
  189|  1.41k|        char* out = buf;
  190|  1.41k|        out = Append(out, a);
  191|  1.41k|        assert(out == buf + buf_size);
  192|  1.41k|        return buf_size;
  193|  1.41k|      });
  194|  1.41k|}
str_cat.cc:_ZN4absl12_GLOBAL__N_16AppendEPcRKNS_8AlphaNumE:
   46|  1.41k|inline char* absl_nonnull Append(char* absl_nonnull out, const AlphaNum& x) {
   47|       |  // memcpy is allowed to overwrite arbitrary memory, so doing this after the
   48|       |  // call would force an extra fetch of x.size().
   49|  1.41k|  char* after = out + x.size();
   50|  1.41k|  if (x.size() != 0) {
  ------------------
  |  Branch (50:7): [True: 397, False: 1.02k]
  ------------------
   51|    397|    memcpy(out, x.data(), x.size());
   52|    397|  }
   53|  1.41k|  return after;
   54|  1.41k|}
str_cat.cc:_ZZN4absl16strings_internal9CatPiecesESt16initializer_listINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEENK3$_0clEPcm:
  137|  1.41k|                                 [&pieces](char* const begin, size_t buf_size) {
  138|  1.41k|                                   char* out = begin;
  139|  7.09k|                                   for (absl::string_view piece : pieces) {
  ------------------
  |  Branch (139:65): [True: 7.09k, False: 1.41k]
  ------------------
  140|  7.09k|                                     const size_t this_size = piece.size();
  141|  7.09k|                                     if (this_size != 0) {
  ------------------
  |  Branch (141:42): [True: 6.50k, False: 591]
  ------------------
  142|  6.50k|                                       memcpy(out, piece.data(), this_size);
  143|  6.50k|                                       out += this_size;
  144|  6.50k|                                     }
  145|  7.09k|                                   }
  146|  1.41k|                                   assert(out == begin + buf_size);
  ------------------
  |  Branch (146:36): [True: 1.41k, False: 0]
  ------------------
  147|  1.41k|                                   return buf_size;
  148|  1.41k|                                 });
str_cat.cc:_ZZN4absl9StrAppendEPNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEERKNS_8AlphaNumEENK3$_0clEPcm:
  188|  1.41k|      *dest, a.size(), [&a](char* const buf, size_t buf_size) {
  189|  1.41k|        char* out = buf;
  190|  1.41k|        out = Append(out, a);
  191|  1.41k|        assert(out == buf + buf_size);
  ------------------
  |  Branch (191:9): [True: 1.41k, False: 0]
  ------------------
  192|  1.41k|        return buf_size;
  193|  1.41k|      });

_ZN4absl8AlphaNumC2Ef:
  388|  1.41k|      : piece_(digits_, numbers_internal::SixDigitsToBuffer(f, digits_)) {}
_ZN4absl8AlphaNumC2Ed:
  390|  1.41k|      : piece_(digits_, numbers_internal::SixDigitsToBuffer(f, digits_)) {}
_ZN4absl8AlphaNumC2Ei:
  363|  2.83k|      : piece_(digits_, static_cast<size_t>(
  364|  2.83k|                            numbers_internal::FastIntToBuffer(x, digits_) -
  365|  2.83k|                            &digits_[0])) {}
_ZN4absl8AlphaNumC2INSt3__19allocatorIcEEEERKNS2_12basic_stringIcNS2_11char_traitsIcEET_EE:
  422|  2.83k|      : piece_(str) {}
_ZN4absl6StrCatIJEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_8AlphaNumESA_SA_SA_SA_DpRKT_:
  602|  1.41k|                                        const AlphaNum& e, const AV&... args) {
  603|  1.41k|  return strings_internal::CatPieces(
  604|  1.41k|      {a.Piece(), b.Piece(), c.Piece(), d.Piece(), e.Piece(),
  605|  1.41k|       static_cast<const AlphaNum&>(args).Piece()...});
  606|  1.41k|}
_ZNK4absl8AlphaNum5PieceEv:
  432|  7.09k|  absl::string_view Piece() const { return piece_; }
_ZNK4absl8AlphaNum4sizeEv:
  430|  6.07k|  absl::string_view::size_type size() const { return piece_.size(); }
_ZNK4absl8AlphaNum4dataEv:
  431|    794|  const char* absl_nullable data() const { return piece_.data(); }

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

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

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

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

_ZN4absl4SpanIKNS_19str_format_internal13FormatArgImplEEC2IS3_S3_EESt16initializer_listIS2_E:
  310|  5.67k|      : Span(v.begin(), v.size()) {}
_ZN4absl4SpanIKNS_19str_format_internal13FormatArgImplEEC2EPS3_m:
  230|  5.67k|      : ptr_(array), len_(length) {}
_ZNK4absl4SpanIKNS_19str_format_internal13FormatArgImplEE4sizeEv:
  323|  11.3k|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl4SpanIKNS_19str_format_internal13FormatArgImplEEixEm:
  338|  5.67k|  constexpr reference operator[](size_type i) const noexcept {
  339|  5.67k|    absl::base_internal::HardeningAssertLT(i, size());
  340|  5.67k|    return ptr_[i];
  341|  5.67k|  }
_ZN4absl8MakeSpanITpTnRiJEjLm128EEENS_4SpanIT0_EERAT1__S3_:
  764|  2.80k|    T (&array ABSL_ATTRIBUTE_LIFETIME_BOUND)[N]) noexcept {
  765|  2.80k|  return Span<T>(array, N);
  766|  2.80k|}
_ZN4absl4SpanIjEC2EPjm:
  230|  2.80k|      : ptr_(array), len_(length) {}
_ZNK4absl4SpanIjEixEm:
  338|  3.42M|  constexpr reference operator[](size_type i) const noexcept {
  339|  3.42M|    absl::base_internal::HardeningAssertLT(i, size());
  340|  3.42M|    return ptr_[i];
  341|  3.42M|  }
_ZNK4absl4SpanIjE4sizeEv:
  323|  3.42M|  constexpr size_type size() const noexcept { return len_; }

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