_ZN4absl6c_copyINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERPcEENS1_9enable_ifIXaasr28container_algorithm_internal10IsIteratorINS_12remove_cvrefIT0_E4typeEEE5valuentsr28container_algorithm_internal23IsMultidimensionalArrayIu20__remove_reference_tIT_EEE5valueEu7__decayISC_EE4typeERKSF_OSC_:
  616|  10.8M|c_copy(const InputSequence& input, OutputIterator&& output) {
  617|  10.8M|  return std::copy(container_algorithm_internal::c_begin(input),
  618|  10.8M|                   container_algorithm_internal::c_end(input),
  619|  10.8M|                   std::forward<OutputIterator>(output));
  620|  10.8M|}
_ZN4absl28container_algorithm_internal7c_beginIKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEDTcl5beginclsr3stdE7declvalIRT_EEEESB_:
  111|  10.8M|constexpr ContainerIter<C> c_begin(C& c) {
  112|  10.8M|  return begin(c);
  113|  10.8M|}
_ZN4absl28container_algorithm_internal5c_endIKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEDTcl5beginclsr3stdE7declvalIRT_EEEESB_:
  116|  10.8M|constexpr ContainerIter<C> c_end(C& c) {
  117|  10.8M|  return end(c);
  118|  10.8M|}
_ZN4absl6c_copyINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERPcEENS1_9enable_ifIXaasr28container_algorithm_internal10IsIteratorINS_12remove_cvrefIT0_E4typeEEE5valuentsr28container_algorithm_internal23IsMultidimensionalArrayIu20__remove_reference_tIT_EEE5valueEu7__decayISA_EE4typeERKSD_OSA_:
  616|  10.8M|c_copy(const InputSequence& input, OutputIterator&& output) {
  617|  10.8M|  return std::copy(container_algorithm_internal::c_begin(input),
  618|  10.8M|                   container_algorithm_internal::c_end(input),
  619|  10.8M|                   std::forward<OutputIterator>(output));
  620|  10.8M|}
_ZN4absl28container_algorithm_internal7c_beginIKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEEDTcl5beginclsr3stdE7declvalIRT_EEEES9_:
  111|  10.8M|constexpr ContainerIter<C> c_begin(C& c) {
  112|  10.8M|  return begin(c);
  113|  10.8M|}
_ZN4absl28container_algorithm_internal5c_endIKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEEDTcl5beginclsr3stdE7declvalIRT_EEEES9_:
  116|  10.8M|constexpr ContainerIter<C> c_end(C& c) {
  117|  10.8M|  return end(c);
  118|  10.8M|}

_ZN4absl8bit_castIdmTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3stdE23is_trivially_copyable_vIS4_Esr3stdE23is_trivially_copyable_vIS3_EEiE4typeELi0EEES3_RKS4_:
  187|  1.55k|inline constexpr Dest bit_cast(const Source& source) {
  188|  1.55k|  return __builtin_bit_cast(Dest, source);
  189|  1.55k|}
_ZN4absl8bit_castIfjTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3stdE23is_trivially_copyable_vIS4_Esr3stdE23is_trivially_copyable_vIS3_EEiE4typeELi0EEES3_RKS4_:
  187|  1.55k|inline constexpr Dest bit_cast(const Source& source) {
  188|  1.55k|  return __builtin_bit_cast(Dest, source);
  189|  1.55k|}

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

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

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

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

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

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

_ZN4absl7uint128rSEi:
  632|  6.67k|inline uint128& uint128::operator>>=(int amount) {
  633|  6.67k|  *this = *this >> amount;
  634|  6.67k|  return *this;
  635|  6.67k|}
_ZN4absl7uint128pLES0_:
  637|     79|inline uint128& uint128::operator+=(uint128 other) {
  638|     79|  *this = *this + other;
  639|     79|  return *this;
  640|     79|}
_ZN4absl7uint128dVES0_:
  652|  1.55k|inline uint128& uint128::operator/=(uint128 other) {
  653|  1.55k|  *this = *this / other;
  654|  1.55k|  return *this;
  655|  1.55k|}
_ZN4absl12Uint128Low64ENS_7uint128E:
  662|  7.81k|constexpr uint64_t Uint128Low64(uint128 v) { return v.lo_; }
_ZN4absl13Uint128High64ENS_7uint128E:
  664|  11.1k|constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; }
_ZNK4absl7uint128cvbEv:
  738|  6.67k|constexpr uint128::operator bool() const { return lo_ || hi_; }
  ------------------
  |  Branch (738:51): [True: 3.56k, False: 3.11k]
  |  Branch (738:58): [True: 0, False: 3.11k]
  ------------------
_ZNK4absl7uint128cvjEv:
  771|  6.67k|constexpr uint128::operator unsigned int() const {
  772|  6.67k|  return static_cast<unsigned int>(lo_);
  773|  6.67k|}
_ZNK4absl7uint128cvoEv:
  795|  33.4k|constexpr uint128::operator unsigned __int128() const {
  796|  33.4k|  return (static_cast<unsigned __int128>(hi_) << 64) + lo_;
  797|  33.4k|}
_ZN4absleqENS_7uint128ES0_:
  821|  1.55k|constexpr bool operator==(uint128 lhs, uint128 rhs) {
  822|  1.55k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  823|  1.55k|  return static_cast<unsigned __int128>(lhs) ==
  824|  1.55k|         static_cast<unsigned __int128>(rhs);
  825|       |#else
  826|       |  return (Uint128Low64(lhs) == Uint128Low64(rhs) &&
  827|       |          Uint128High64(lhs) == Uint128High64(rhs));
  828|       |#endif
  829|  1.55k|}
_ZN4absllsENS_7uint128Ei:
  961|  4.67k|constexpr uint128 operator<<(uint128 lhs, int amount) {
  962|  4.67k|#ifdef ABSL_HAVE_INTRINSIC_INT128
  963|  4.67k|  return static_cast<unsigned __int128>(lhs) << amount;
  964|       |#else
  965|       |  // uint64_t shifts of >= 64 are undefined, so we will need some
  966|       |  // special-casing.
  967|       |  return amount >= 64  ? MakeUint128(Uint128Low64(lhs) << (amount - 64), 0)
  968|       |         : amount == 0 ? lhs
  969|       |                       : MakeUint128((Uint128High64(lhs) << amount) |
  970|       |                                         (Uint128Low64(lhs) >> (64 - amount)),
  971|       |                                     Uint128Low64(lhs) << amount);
  972|       |#endif
  973|  4.67k|}
_ZN4abslrsENS_7uint128Ei:
  975|  6.67k|constexpr uint128 operator>>(uint128 lhs, int amount) {
  976|  6.67k|#ifdef ABSL_HAVE_INTRINSIC_INT128
  977|  6.67k|  return static_cast<unsigned __int128>(lhs) >> amount;
  978|       |#else
  979|       |  // uint64_t shifts of >= 64 are undefined, so we will need some
  980|       |  // special-casing.
  981|       |  return amount >= 64  ? MakeUint128(0, Uint128High64(lhs) >> (amount - 64))
  982|       |         : amount == 0 ? lhs
  983|       |                       : MakeUint128(Uint128High64(lhs) >> amount,
  984|       |                                     (Uint128Low64(lhs) >> amount) |
  985|       |                                         (Uint128High64(lhs) << (64 - amount)));
  986|       |#endif
  987|  6.67k|}
_ZN4abslplENS_7uint128ES0_:
 1000|     79|constexpr uint128 operator+(uint128 lhs, uint128 rhs) {
 1001|     79|#if defined(ABSL_HAVE_INTRINSIC_INT128)
 1002|     79|  return static_cast<unsigned __int128>(lhs) +
 1003|     79|         static_cast<unsigned __int128>(rhs);
 1004|       |#else
 1005|       |  return int128_internal::AddResult(
 1006|       |      MakeUint128(Uint128High64(lhs) + Uint128High64(rhs),
 1007|       |                  Uint128Low64(lhs) + Uint128Low64(rhs)),
 1008|       |      lhs);
 1009|       |#endif
 1010|     79|}
_ZN4abslmlENS_7uint128ES0_:
 1060|  3.19k|constexpr uint128 operator*(uint128 lhs, uint128 rhs) {
 1061|       |  // TODO(strel) Remove once alignment issues are resolved and unsigned __int128
 1062|       |  // can be used for uint128 storage.
 1063|  3.19k|  return static_cast<unsigned __int128>(lhs) *
 1064|  3.19k|         static_cast<unsigned __int128>(rhs);
 1065|  3.19k|}
_ZN4absldvENS_7uint128ES0_:
 1067|  3.11k|constexpr uint128 operator/(uint128 lhs, uint128 rhs) {
 1068|  3.11k|  return static_cast<unsigned __int128>(lhs) /
 1069|  3.11k|         static_cast<unsigned __int128>(rhs);
 1070|  3.11k|}
_ZN4abslrmENS_7uint128ES0_:
 1072|  3.11k|constexpr uint128 operator%(uint128 lhs, uint128 rhs) {
 1073|  3.11k|  return static_cast<unsigned __int128>(lhs) %
 1074|  3.11k|         static_cast<unsigned __int128>(rhs);
 1075|  3.11k|}
_ZN4absl7uint128C2Eo:
  693|  20.8k|    : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
  694|  20.8k|      hi_{static_cast<uint64_t>(v >> 64)} {}
_ZN4absl7uint128C2Ei:
  673|  1.55k|    : lo_{static_cast<uint64_t>(v)},
  674|  1.55k|      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {}
  ------------------
  |  Branch (674:11): [True: 0, False: 1.55k]
  ------------------
_ZN4absl7uint128C2Em:
  684|  17.3k|constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {}

_ZN4absl16numeric_internal20CountLeadingZeroes64Em:
  214|  7.85k|CountLeadingZeroes64(uint64_t x) {
  215|  7.85k|#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.85k|  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
  221|  7.85k|                "__builtin_clzll does not take 64-bit arg");
  222|       |
  223|       |  // Handle 0 as a special case because __builtin_clzll(0) is undefined.
  224|  7.85k|  return x == 0 ? 64 : __builtin_clzll(x);
  ------------------
  |  Branch (224:10): [True: 56, False: 7.79k]
  ------------------
  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.85k|}
_ZN4absl16numeric_internal28CountTrailingZeroesNonzero64Em:
  307|  4.86k|CountTrailingZeroesNonzero64(uint64_t x) {
  308|  4.86k|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctzll)
  309|  4.86k|  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
  310|  4.86k|                "__builtin_ctzll does not take 64-bit arg");
  311|  4.86k|  return __builtin_ctzll(x);
  312|       |#elif defined(_MSC_VER) && !defined(__clang__) && \
  313|       |    (defined(_M_X64) || defined(_M_ARM64))
  314|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  315|       |  _BitScanForward64(&result, x);
  316|       |  return result;
  317|       |#elif defined(_MSC_VER) && !defined(__clang__)
  318|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  319|       |  if (static_cast<uint32_t>(x) == 0) {
  320|       |    _BitScanForward(&result, static_cast<unsigned long>(x >> 32));
  321|       |    return result + 32;
  322|       |  }
  323|       |  _BitScanForward(&result, static_cast<unsigned long>(x));
  324|       |  return result;
  325|       |#else
  326|       |  int c = 63;
  327|       |  x &= ~x + 1;
  328|       |  if (x & 0x00000000FFFFFFFF) c -= 32;
  329|       |  if (x & 0x0000FFFF0000FFFF) c -= 16;
  330|       |  if (x & 0x00FF00FF00FF00FF) c -= 8;
  331|       |  if (x & 0x0F0F0F0F0F0F0F0F) c -= 4;
  332|       |  if (x & 0x3333333333333333) c -= 2;
  333|       |  if (x & 0x5555555555555555) c -= 1;
  334|       |  return c;
  335|       |#endif
  336|  4.86k|}
_ZN4absl16numeric_internal18CountLeadingZeroesImEEiT_:
  268|  7.85k|CountLeadingZeroes(T x) {
  269|  7.85k|  static_assert(std::is_unsigned_v<T>, "T must be unsigned");
  270|  7.85k|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  271|  7.85k|                "T must have a power-of-2 size");
  272|  7.85k|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  273|  7.85k|  return sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (273:10): [Folded, False: 7.85k]
  ------------------
  274|  7.85k|             ? CountLeadingZeroes16(static_cast<uint16_t>(x)) -
  275|      0|                   (std::numeric_limits<uint16_t>::digits -
  276|      0|                    std::numeric_limits<T>::digits)
  277|  7.85k|             : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (277:17): [Folded, False: 7.85k]
  ------------------
  278|  7.85k|                    ? CountLeadingZeroes32(static_cast<uint32_t>(x)) -
  279|      0|                          (std::numeric_limits<uint32_t>::digits -
  280|      0|                           std::numeric_limits<T>::digits)
  281|  7.85k|                    : CountLeadingZeroes64(x));
  282|  7.85k|}
_ZN4absl16numeric_internal19CountTrailingZeroesImEEiT_:
  353|  4.86k|CountTrailingZeroes(T x) noexcept {
  354|  4.86k|  static_assert(std::is_unsigned_v<T>, "T must be unsigned");
  355|  4.86k|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  356|  4.86k|                "T must have a power-of-2 size");
  357|  4.86k|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  358|  4.86k|  return x == 0 ? std::numeric_limits<T>::digits
  ------------------
  |  Branch (358:10): [True: 0, False: 4.86k]
  ------------------
  359|  4.86k|                : (sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (359:20): [Folded, False: 4.86k]
  ------------------
  360|  4.86k|                       ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x))
  361|  4.86k|                       : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (361:27): [Folded, False: 4.86k]
  ------------------
  362|  4.86k|                              ? CountTrailingZeroesNonzero32(
  363|      0|                                    static_cast<uint32_t>(x))
  364|  4.86k|                              : CountTrailingZeroesNonzero64(x)));
  365|  4.86k|}

_ZN4absl27StripLeadingAsciiWhitespaceENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  287|  3.17k|absl::string_view StripLeadingAsciiWhitespace(absl::string_view str) {
  288|  3.17k|  auto it = std::find_if_not(str.begin(), str.end(), absl::ascii_isspace);
  289|  3.17k|  return str.substr(static_cast<size_t>(it - str.begin()));
  290|  3.17k|}
_ZN4absl28StripTrailingAsciiWhitespaceENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  297|  3.17k|absl::string_view StripTrailingAsciiWhitespace(absl::string_view str) {
  298|  3.17k|  auto it = std::find_if_not(str.rbegin(), str.rend(), absl::ascii_isspace);
  299|  3.17k|  return str.substr(0, static_cast<size_t>(str.rend() - it));
  300|  3.17k|}
_ZN4absl20StripAsciiWhitespaceENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  307|  3.17k|absl::string_view StripAsciiWhitespace(absl::string_view str) {
  308|  3.17k|  return StripTrailingAsciiWhitespace(StripLeadingAsciiWhitespace(str));
  309|  3.17k|}

_ZN4absl13ascii_isspaceEh:
  103|  9.52k|inline bool ascii_isspace(unsigned char c) {
  104|  9.52k|  return (ascii_internal::kPropertyBits[c] & 0x08) != 0;
  105|  9.52k|}

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

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

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

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

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

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

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

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

_ZN4absl19str_format_internal21UntypedFormatSpecImpl7ExtractINS0_18FormatSpecTemplateIJLNS_23FormatConversionCharSetE654848EEEEEERKS1_RKT_:
   75|  3.17k|  static const UntypedFormatSpecImpl& Extract(const T& s) {
   76|  3.17k|    return s.spec_;
   77|  3.17k|  }
_ZN4absl19str_format_internal18FormatSpecTemplateIJLNS_23FormatConversionCharSetE654848EEEC2EUa9enable_ifIXclL_ZNS0_15ValidFormatImplIJLS2_654848EEEEbNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEfL0p_EEEPKc:
  155|  3.17k|      : Base(s) {}
_ZN4absl19str_format_internal21UntypedFormatSpecImplC2ENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   58|  6.34k|      : data_(s.data()), size_(s.size()) {}
_ZN4absl19str_format_internal21UntypedFormatSpecImpl7ExtractINS0_18FormatSpecTemplateIJLNS_23FormatConversionCharSetE655355EEEEEERKS1_RKT_:
   75|  3.17k|  static const UntypedFormatSpecImpl& Extract(const T& s) {
   76|  3.17k|    return s.spec_;
   77|  3.17k|  }
_ZN4absl19str_format_internal18FormatSpecTemplateIJLNS_23FormatConversionCharSetE655355EEEC2EUa9enable_ifIXclL_ZNS0_15ValidFormatImplIJLS2_655355EEEEbNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEfL0p_EEEPKc:
  155|  3.17k|      : Base(s) {}
_ZNK4absl19str_format_internal15BoundConversion3argEv:
   45|  6.34k|  const FormatArgImpl* arg() const { return arg_; }
_ZN4absl19str_format_internal15BoundConversion7set_argEPKNS0_13FormatArgImplE:
   46|  6.34k|  void set_arg(const FormatArgImpl* a) { arg_ = a; }
_ZNK4absl19str_format_internal21UntypedFormatSpecImpl21has_parsed_conversionEv:
   63|  12.6k|  bool has_parsed_conversion() const { return size_ == ~size_t{}; }
_ZNK4absl19str_format_internal21UntypedFormatSpecImpl3strEv:
   65|  6.34k|  string_view str() const {
   66|  6.34k|    assert(!has_parsed_conversion());
  ------------------
  |  Branch (66:5): [True: 6.34k, False: 0]
  ------------------
   67|  6.34k|    return string_view(static_cast<const char*>(data_), size_);
   68|  6.34k|  }

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

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

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

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

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

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

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

_ZN4absl16EqualsIgnoreCaseENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEES4_:
   34|  14.4k|                      absl::string_view piece2) noexcept {
   35|  14.4k|  return (piece1.size() == piece2.size() &&
  ------------------
  |  Branch (35:11): [True: 8.67k, False: 5.78k]
  ------------------
   36|  8.67k|          0 == absl::strings_internal::memcasecmp(piece1.data(), piece2.data(),
  ------------------
  |  Branch (36:11): [True: 1.58k, False: 7.08k]
  ------------------
   37|  8.67k|                                                  piece1.size()));
   38|       |  // memcasecmp uses absl::ascii_tolower().
   39|  14.4k|}

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

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

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

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

_ZN4absl8AlphaNumC2Ef:
  385|  1.58k|      : piece_(digits_, numbers_internal::SixDigitsToBuffer(
  386|  1.58k|                            static_cast<double>(f), digits_)) {}
_ZN4absl8AlphaNumC2Ed:
  388|  1.58k|      : piece_(digits_, numbers_internal::SixDigitsToBuffer(f, digits_)) {}
_ZN4absl8AlphaNumC2Ei:
  360|  3.17k|      : piece_(digits_, static_cast<size_t>(
  361|  3.17k|                            numbers_internal::FastIntToBuffer(x, digits_) -
  362|  3.17k|                            &digits_[0])) {}
_ZN4absl8AlphaNumC2INSt3__19allocatorIcEEEERKNS2_12basic_stringIcNS2_11char_traitsIcEET_EE:
  419|  3.17k|      : piece_(str) {}
_ZN4absl6StrCatIJEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_8AlphaNumESA_SA_SA_SA_DpRKT_:
  597|  1.58k|                                        const AlphaNum& e, const AV&... args) {
  598|  1.58k|  return strings_internal::CatPieces(
  599|  1.58k|      {a.Piece(), b.Piece(), c.Piece(), d.Piece(), e.Piece(),
  600|  1.58k|       static_cast<const AlphaNum&>(args).Piece()...});
  601|  1.58k|}
_ZNK4absl8AlphaNum5PieceEv:
  429|  7.93k|  absl::string_view Piece() const { return piece_; }
_ZNK4absl8AlphaNum4sizeEv:
  427|  6.71k|  absl::string_view::size_type size() const { return piece_.size(); }
_ZNK4absl8AlphaNum4dataEv:
  428|    740|  const char* absl_nullable data() const { return piece_.data(); }

_ZN4absl9StrFormatIJfEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_19str_format_internal18FormatSpecTemplateIJXspclsr19str_format_internalE14ArgumentToConvIT_EEEEEEDpRKSA_:
  360|  1.58k|                                    const Args&... args) {
  361|  1.58k|  return str_format_internal::FormatPack(
  362|  1.58k|      str_format_internal::UntypedFormatSpecImpl::Extract(format),
  363|  1.58k|      {str_format_internal::FormatArgImpl(args)...});
  364|  1.58k|}
_ZN4absl17UntypedFormatSpecC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  112|  6.34k|  explicit UntypedFormatSpec(string_view s) : spec_(s) {}
_ZN4absl9StrFormatIJdEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_19str_format_internal18FormatSpecTemplateIJXspclsr19str_format_internalE14ArgumentToConvIT_EEEEEEDpRKSA_:
  360|  1.58k|                                    const Args&... args) {
  361|  1.58k|  return str_format_internal::FormatPack(
  362|  1.58k|      str_format_internal::UntypedFormatSpecImpl::Extract(format),
  363|  1.58k|      {str_format_internal::FormatArgImpl(args)...});
  364|  1.58k|}
_ZN4absl9StrFormatIJiEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_19str_format_internal18FormatSpecTemplateIJXspclsr19str_format_internalE14ArgumentToConvIT_EEEEEEDpRKSA_:
  360|  1.58k|                                    const Args&... args) {
  361|  1.58k|  return str_format_internal::FormatPack(
  362|  1.58k|      str_format_internal::UntypedFormatSpecImpl::Extract(format),
  363|  1.58k|      {str_format_internal::FormatArgImpl(args)...});
  364|  1.58k|}
_ZN4absl9StrFormatIJbEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_19str_format_internal18FormatSpecTemplateIJXspclsr19str_format_internalE14ArgumentToConvIT_EEEEEEDpRKSA_:
  360|  1.58k|                                    const Args&... args) {
  361|  1.58k|  return str_format_internal::FormatPack(
  362|  1.58k|      str_format_internal::UntypedFormatSpecImpl::Extract(format),
  363|  1.58k|      {str_format_internal::FormatArgImpl(args)...});
  364|  1.58k|}

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

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

_ZN4absl8StrSplitIPKcEENS_16strings_internal8SplitterINS3_15SelectDelimiterIT_E4typeENS_10AllowEmptyENSt3__117basic_string_viewIcNSA_11char_traitsIcEEEEEENS3_23ConvertibleToStringViewES6_:
  545|  1.58k|StrSplit(strings_internal::ConvertibleToStringView text, Delimiter d) {
  546|  1.58k|  using DelimiterType =
  547|  1.58k|      typename strings_internal::SelectDelimiter<Delimiter>::type;
  548|  1.58k|  return strings_internal::Splitter<DelimiterType, AllowEmpty,
  549|  1.58k|                                    absl::string_view>(
  550|  1.58k|      text.value(), DelimiterType(d), AllowEmpty());
  551|  1.58k|}
_ZNK4absl10AllowEmptyclENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  351|  10.8M|  bool operator()(absl::string_view) const { return true; }

_ZN4absl4SpanIKNS_19str_format_internal13FormatArgImplEEC2IS3_S3_EESt16initializer_listIS2_E:
  304|  6.34k|      : Span(v.begin(), v.size()) {}
_ZN4absl4SpanIKNS_19str_format_internal13FormatArgImplEEC2EPS3_m:
  224|  6.34k|      : ptr_(array), len_(length) {}
_ZNK4absl4SpanIKNS_19str_format_internal13FormatArgImplEE4sizeEv:
  317|  12.6k|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl4SpanIKNS_19str_format_internal13FormatArgImplEEixEm:
  332|  6.34k|  constexpr reference operator[](size_type i) const noexcept {
  333|  6.34k|    absl::base_internal::HardeningAssertLT(i, size());
  334|  6.34k|    return ptr_[i];
  335|  6.34k|  }
_ZN4absl8MakeSpanITpTnRiJEjLm128EEENS_4SpanIT0_EERAT1__S3_:
  750|  3.11k|    T (&array ABSL_ATTRIBUTE_LIFETIME_BOUND)[N]) noexcept {
  751|  3.11k|  return Span<T>(array, N);
  752|  3.11k|}
_ZN4absl4SpanIjEC2EPjm:
  224|  3.11k|      : ptr_(array), len_(length) {}
_ZNK4absl4SpanIjEixEm:
  332|  3.79M|  constexpr reference operator[](size_type i) const noexcept {
  333|  3.79M|    absl::base_internal::HardeningAssertLT(i, size());
  334|  3.79M|    return ptr_[i];
  335|  3.79M|  }
_ZNK4absl4SpanIjE4sizeEv:
  317|  3.79M|  constexpr size_type size() const noexcept { return len_; }

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