_ZN3fmt3v116detail13ignore_unusedIJbEEEvDpRKT_:
  363|    343|template <typename... T> FMT_CONSTEXPR void ignore_unused(const T&...) {}
_ZNK3fmt3v116detail6bufferIcE8capacityEv:
 1788|    248|  constexpr auto capacity() const noexcept -> size_t { return capacity_; }
_ZN3fmt3v116detail6bufferIcEC2EPFvRS3_mEPcmm:
 1760|  5.01k|      : ptr_(p), size_(sz), capacity_(cap), grow_(grow) {}
_ZN3fmt3v116detail6bufferIcE3setEPcm:
 1766|  2.96k|  FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept {
 1767|  2.96k|    ptr_ = buf_data;
 1768|  2.96k|    capacity_ = buf_capacity;
 1769|  2.96k|  }
_ZN3fmt3v116detail6bufferIcE4dataEv:
 1791|  6.18k|  FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; }
_ZNK3fmt3v116detail6bufferIcE4sizeEv:
 1785|  8.65k|  constexpr auto size() const noexcept -> size_t { return size_; }
_ZN3fmt3v1117basic_string_viewIcEC2EPKcm:
  532|    184|      : data_(s), size_(count) {}
_ZN3fmt3v116detail6bufferIcE9push_backERKc:
 1812|  65.1k|  FMT_CONSTEXPR void push_back(const T& value) {
 1813|  65.1k|    try_reserve(size_ + 1);
 1814|  65.1k|    ptr_[size_++] = value;
 1815|  65.1k|  }
_ZN3fmt3v116detail6bufferIcE11try_reserveEm:
 1808|  71.9k|  FMT_CONSTEXPR void try_reserve(size_t new_capacity) {
 1809|  71.9k|    if (new_capacity > capacity_) grow_(*this, new_capacity);
  ------------------
  |  Branch (1809:9): [True: 0, False: 71.9k]
  ------------------
 1810|  71.9k|  }
_ZN3fmt3v1117basic_string_viewIcEC2EPKc:
  540|  2.22k|  FMT_CONSTEXPR20 basic_string_view(const Char* s) : data_(s) {
  541|  2.22k|#if FMT_HAS_BUILTIN(__builtin_strlen) || FMT_GCC_VERSION || FMT_CLANG_VERSION
  542|  2.22k|    if (std::is_same<Char, char>::value) {
  ------------------
  |  Branch (542:9): [Folded - Ignored]
  ------------------
  543|  2.22k|      size_ = __builtin_strlen(detail::narrow(s));
  544|  2.22k|      return;
  545|  2.22k|    }
  546|      0|#endif
  547|      0|    size_t len = 0;
  548|      0|    while (*s++) ++len;
  ------------------
  |  Branch (548:12): [True: 0, False: 0]
  ------------------
  549|      0|    size_ = len;
  550|      0|  }
_ZN3fmt3v116detail6narrowEPKc:
  467|  2.22k|constexpr FMT_ALWAYS_INLINE const char* narrow(const char* s) { return s; }
_ZN3fmt3v119format_toINSt3__120back_insert_iteratorINS0_19basic_memory_bufferIcLm500ENS0_6detail9allocatorIcEEEEEEJRdETnNS2_9enable_ifIXsr6detail18is_output_iteratorINS2_9remove_cvINS2_16remove_referenceIT_E4typeEE4typeEcEE5valueEiE4typeELi0EEESI_OSE_NS0_7fstringIJDpT0_EE1tEDpOSN_:
 2851|  2.04k|    -> remove_cvref_t<OutputIt> {
 2852|  2.04k|  return vformat_to(out, fmt.str, vargs<T...>{{args...}});
 2853|  2.04k|}
_ZN3fmt3v1110vformat_toIRNSt3__120back_insert_iteratorINS0_19basic_memory_bufferIcLm500ENS0_6detail9allocatorIcEEEEEETnNS2_9enable_ifIXsr6detail18is_output_iteratorINS2_9remove_cvINS2_16remove_referenceIT_E4typeEE4typeEcEE5valueEiE4typeELi0EEESI_OSE_NS0_17basic_string_viewIcEENS0_17basic_format_argsINS0_7contextEEE:
 2831|  2.04k|    -> remove_cvref_t<OutputIt> {
 2832|  2.04k|  auto&& buf = detail::get_buffer<char>(out);
 2833|  2.04k|  detail::vformat_to(buf, fmt, args, {});
 2834|  2.04k|  return detail::get_iterator(buf, out);
 2835|  2.04k|}
_ZN3fmt3v116detail10get_bufferIcNSt3__120back_insert_iteratorINS0_19basic_memory_bufferIcLm500ENS1_9allocatorIcEEEEEETnNS3_9enable_ifIXntsr18is_buffer_appenderIT0_EE5valueEiE4typeELi0EEENS1_15iterator_bufferISB_T_NS1_13buffer_traitsEEESB_:
 2079|  2.04k|auto get_buffer(OutputIt out) -> iterator_buffer<OutputIt, T> {
 2080|  2.04k|  return iterator_buffer<OutputIt, T>(out);
 2081|  2.04k|}
_ZN3fmt3v116detail15iterator_bufferINSt3__120back_insert_iteratorINS0_19basic_memory_bufferIcLm500ENS1_9allocatorIcEEEEEEcNS1_13buffer_traitsEEC2ES9_m:
 1891|  2.04k|      : Traits(n), buffer<T>(grow, data_, 0, buffer_size), out_(out) {}
_ZN3fmt3v116detail13buffer_traitsC2Em:
 1849|  2.04k|  constexpr explicit buffer_traits(size_t) {}
_ZN3fmt3v116detail15iterator_bufferINSt3__120back_insert_iteratorINS0_19basic_memory_bufferIcLm500ENS1_9allocatorIcEEEEEEcNS1_13buffer_traitsEE5flushEv:
 1881|  4.08k|  void flush() {
 1882|  4.08k|    auto size = this->size();
 1883|  4.08k|    this->clear();
 1884|  4.08k|    const T* begin = data_;
 1885|  4.08k|    const T* end = begin + this->limit(size);
 1886|  60.3k|    while (begin != end) *out_++ = *begin++;
  ------------------
  |  Branch (1886:12): [True: 56.2k, False: 4.08k]
  ------------------
 1887|  4.08k|  }
_ZN3fmt3v116detail6bufferIcE5clearEv:
 1795|  4.08k|  FMT_CONSTEXPR void clear() { size_ = 0; }
_ZNK3fmt3v116detail13buffer_traits5limitEm:
 1851|  4.08k|  constexpr auto limit(size_t size) const -> size_t { return size; }
_ZN3fmt3v116detail10locale_refC2Ev:
 2303|  2.96k|  constexpr locale_ref() : locale_(nullptr) {}
_ZN3fmt3v116detail12get_iteratorINS1_15iterator_bufferINSt3__120back_insert_iteratorINS0_19basic_memory_bufferIcLm500ENS1_9allocatorIcEEEEEEcNS1_13buffer_traitsEEESA_EEDTcldtfp_3outEERT_T0_:
 2089|  2.04k|auto get_iterator(Buf& buf, OutputIt) -> decltype(buf.out()) {
 2090|  2.04k|  return buf.out();
 2091|  2.04k|}
_ZN3fmt3v116detail15iterator_bufferINSt3__120back_insert_iteratorINS0_19basic_memory_bufferIcLm500ENS1_9allocatorIcEEEEEEcNS1_13buffer_traitsEE3outEv:
 1902|  2.04k|  auto out() -> OutputIt {
 1903|  2.04k|    flush();
 1904|  2.04k|    return out_;
 1905|  2.04k|  }
_ZN3fmt3v116detail15iterator_bufferINSt3__120back_insert_iteratorINS0_19basic_memory_bufferIcLm500ENS1_9allocatorIcEEEEEEcNS1_13buffer_traitsEED2Ev:
 1896|  2.04k|  ~iterator_buffer() {
 1897|       |    // Don't crash if flush fails during unwinding.
 1898|  2.04k|    FMT_TRY { flush(); }
  ------------------
  |  |  157|  2.04k|#  define FMT_TRY try
  ------------------
 1899|  2.04k|    FMT_CATCH(...) {}
 1900|  2.04k|  }
_ZN3fmt3v116detail5valueINS0_7contextEEC2Ed:
 2183|  2.04k|  constexpr FMT_INLINE value(double x FMT_BUILTIN) : double_value(x) {}
_ZN3fmt3v1117basic_format_argsINS0_7contextEEC2ILi1ELi0ELy10ETnNSt3__19enable_ifIXleT_LNS0_6detail3$_1E15EEiE4typeELi0EEERKNS7_16format_arg_storeIS2_XT_EXT0_EXT1_EEE:
 2597|  2.04k|      : desc_(DESC | (NUM_NAMED_ARGS != 0 ? +detail::has_named_args_bit : 0)),
  ------------------
  |  Branch (2597:23): [Folded - Ignored]
  ------------------
 2598|  2.04k|        values_(s.args) {}
_ZN3fmt3v117fstringIJRdEEC2INS0_17basic_string_viewIcEETnNSt3__19enable_ifIXsr3std14is_convertibleIRKT_S6_EE5valueEiE4typeELi0EEESB_:
 2741|  2.04k|  FMT_CONSTEVAL FMT_ALWAYS_INLINE fstring(const S& s) : str(s) {
 2742|  2.04k|    auto sv = string_view(str);
 2743|  2.04k|    if (FMT_USE_CONSTEVAL)
  ------------------
  |  |  118|  2.04k|#  define FMT_USE_CONSTEVAL 0
  |  |  ------------------
  |  |  |  Branch (118:29): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2744|      0|      detail::parse_format_string<char>(sv, checker(sv, arg_pack()));
 2745|       |#ifdef FMT_ENFORCE_COMPILE_STRING
 2746|       |    static_assert(
 2747|       |        FMT_USE_CONSTEVAL && sizeof(s) != 0,
 2748|       |        "FMT_ENFORCE_COMPILE_STRING requires format strings to use FMT_STRING");
 2749|       |#endif
 2750|  2.04k|  }
_ZN3fmt3v11neENS0_17basic_string_viewIcEES2_:
  601|    184|  friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool {
  602|    184|    return lhs.compare(rhs) != 0;
  603|    184|  }
_ZNK3fmt3v1117basic_string_viewIcE7compareES2_:
  590|    184|  FMT_CONSTEXPR auto compare(basic_string_view other) const -> int {
  591|    184|    int result =
  592|    184|        detail::compare(data_, other.data_, min_of(size_, other.size_));
  593|    184|    if (result != 0) return result;
  ------------------
  |  Branch (593:9): [True: 0, False: 184]
  ------------------
  594|    184|    return size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
  ------------------
  |  Branch (594:12): [True: 184, False: 0]
  |  Branch (594:40): [True: 0, False: 0]
  ------------------
  595|    184|  }
_ZN3fmt3v116detail7compareIcEEiPKT_S5_m:
  471|    184|    -> int {
  472|    184|  if (!is_constant_evaluated() && sizeof(Char) == 1) return memcmp(s1, s2, n);
  ------------------
  |  Branch (472:7): [Folded - Ignored]
  |  Branch (472:35): [Folded - Ignored]
  ------------------
  473|      0|  for (; n != 0; ++s1, ++s2, --n) {
  ------------------
  |  Branch (473:10): [True: 0, False: 0]
  ------------------
  474|      0|    if (*s1 < *s2) return -1;
  ------------------
  |  Branch (474:9): [True: 0, False: 0]
  ------------------
  475|      0|    if (*s1 > *s2) return 1;
  ------------------
  |  Branch (475:9): [True: 0, False: 0]
  ------------------
  476|      0|  }
  477|      0|  return 0;
  478|      0|}
_ZN3fmt3v116min_ofImEET_S2_S2_:
  352|   178k|template <typename T> constexpr auto min_of(T a, T b) -> T {
  353|   178k|  return a < b ? a : b;
  ------------------
  |  Branch (353:10): [True: 177k, False: 184]
  ------------------
  354|   178k|}
_ZN3fmt3v116detail6bufferIcE3endEv:
 1779|  1.85k|  auto end() noexcept -> T* { return ptr_ + size_; }
_ZN3fmt3v119monostateC2Ev:
  340|  2.04k|  constexpr monostate() {}
_ZNK3fmt3v1111basic_specs4typeEv:
  755|  7.41k|  constexpr auto type() const -> presentation_type {
  756|  7.41k|    return static_cast<presentation_type>(data_ & type_mask);
  757|  7.41k|  }
_ZN3fmt3v1111basic_specs8set_typeENS0_17presentation_typeE:
  758|  1.02k|  FMT_CONSTEXPR void set_type(presentation_type t) {
  759|  1.02k|    data_ = (data_ & ~type_mask) | static_cast<unsigned>(t);
  760|  1.02k|  }
_ZNK3fmt3v1111basic_specs5alignEv:
  762|  1.96k|  constexpr auto align() const -> align {
  763|  1.96k|    return static_cast<fmt::align>((data_ & align_mask) >> align_shift);
  764|  1.96k|  }
_ZN3fmt3v1111basic_specs21set_dynamic_precisionENS0_11arg_id_kindE:
  780|  1.02k|  FMT_CONSTEXPR void set_dynamic_precision(arg_id_kind p) {
  781|  1.02k|    data_ = (data_ & ~precision_mask) |
  782|  1.02k|            (static_cast<unsigned>(p) << precision_shift);
  783|  1.02k|  }
_ZNK3fmt3v1111basic_specs7dynamicEv:
  785|  1.02k|  constexpr bool dynamic() const {
  786|  1.02k|    return (data_ & (width_mask | precision_mask)) != 0;
  787|  1.02k|  }
_ZNK3fmt3v1111basic_specs4signEv:
  789|    561|  constexpr auto sign() const -> sign {
  790|    561|    return static_cast<fmt::sign>((data_ & sign_mask) >> sign_shift);
  791|    561|  }
_ZNK3fmt3v1111basic_specs5upperEv:
  796|  1.18k|  constexpr auto upper() const -> bool { return (data_ & uppercase_mask) != 0; }
_ZNK3fmt3v1111basic_specs3altEv:
  799|  2.93k|  constexpr auto alt() const -> bool { return (data_ & alternate_mask) != 0; }
_ZNK3fmt3v1111basic_specs9localizedEv:
  803|  3.54k|  constexpr auto localized() const -> bool {
  804|  3.54k|    return (data_ & localized_mask) != 0;
  805|  3.54k|  }
_ZNK3fmt3v1111basic_specs9fill_sizeEv:
  808|  1.22k|  constexpr auto fill_size() const -> size_t {
  809|  1.22k|    return (data_ & fill_size_mask) >> fill_size_shift;
  810|  1.22k|  }
_ZN3fmt3v1112format_specsC2Ev:
  861|  1.02k|  constexpr format_specs() : width(0), precision(-1) {}
_ZN3fmt3v116max_ofIiEET_S2_S2_:
  355|  1.24k|template <typename T> constexpr auto max_of(T a, T b) -> T {
  356|  1.24k|  return a > b ? a : b;
  ------------------
  |  Branch (356:10): [True: 0, False: 1.24k]
  ------------------
  357|  1.24k|}
_ZN3fmt3v116detail11to_unsignedIiEENSt3__113make_unsignedIT_E4typeES5_:
  437|   176k|FMT_CONSTEXPR auto to_unsigned(Int value) -> make_unsigned_t<Int> {
  438|   176k|  FMT_ASSERT(std::is_unsigned<Int>::value || value >= 0, "negative value");
  ------------------
  |  |  397|   352k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:7): [Folded - Ignored]
  |  |  |  Branch (397:7): [True: 176k, False: 0]
  |  |  ------------------
  |  |  398|   176k|         ? (void)0                                                          \
  |  |  399|   176k|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
  439|   176k|  return static_cast<make_unsigned_t<Int>>(value);
  440|   176k|}
_ZN3fmt3v117contextC2ENS0_14basic_appenderIcEENS0_17basic_format_argsIS1_EENS0_6detail10locale_refE:
 2671|  1.02k|      : out_(out), args_(args), loc_(loc) {}
_ZNK3fmt3v1117basic_format_argsINS0_7contextEE9is_packedEv:
 2570|  2.04k|  constexpr auto is_packed() const -> bool {
 2571|  2.04k|    return (desc_ & detail::is_unpacked_bit) == 0;
 2572|  2.04k|  }
_ZNK3fmt3v1117basic_format_argsINS0_7contextEE4typeEi:
 2577|  2.04k|  FMT_CONSTEXPR auto type(int index) const -> detail::type {
 2578|  2.04k|    int shift = index * detail::packed_arg_bits;
 2579|  2.04k|    unsigned mask = (1 << detail::packed_arg_bits) - 1;
 2580|  2.04k|    return static_cast<detail::type>((desc_ >> shift) & mask);
 2581|  2.04k|  }
_ZNK3fmt3v1117basic_format_argsINS0_7contextEE3getEi:
 2614|  2.04k|  FMT_CONSTEXPR auto get(int id) const -> format_arg {
 2615|  2.04k|    auto arg = format_arg();
 2616|  2.04k|    if (!is_packed()) {
  ------------------
  |  Branch (2616:9): [True: 0, False: 2.04k]
  ------------------
 2617|      0|      if (id < max_size()) arg = args_[id];
  ------------------
  |  Branch (2617:11): [True: 0, False: 0]
  ------------------
 2618|      0|      return arg;
 2619|      0|    }
 2620|  2.04k|    if (static_cast<unsigned>(id) >= detail::max_packed_args) return arg;
  ------------------
  |  Branch (2620:9): [True: 0, False: 2.04k]
  ------------------
 2621|  2.04k|    arg.type_ = type(id);
 2622|  2.04k|    if (arg.type_ != detail::type::none_type) arg.value_ = values_[id];
  ------------------
  |  Branch (2622:9): [True: 2.04k, False: 0]
  ------------------
 2623|  2.04k|    return arg;
 2624|  2.04k|  }
_ZNK3fmt3v117context3argEi:
 2676|  1.02k|  FMT_CONSTEXPR auto arg(int id) const -> format_arg { return args_.get(id); }
_ZNK3fmt3v117context3outEv:
 2686|  3.06k|  FMT_CONSTEXPR auto out() const -> iterator { return out_; }
_ZNK3fmt3v117context6localeEv:
 2691|  1.02k|  FMT_CONSTEXPR auto locale() const -> detail::locale_ref { return loc_; }
_ZN3fmt3v116detail2inENS1_4typeEi:
 1015|  2.04k|constexpr auto in(type t, int set) -> bool {
 1016|  2.04k|  return ((set >> static_cast<int>(t)) & 1) != 0;
 1017|  2.04k|}
_ZN3fmt3v116detail11parse_alignEc:
 1314|  1.02k|FMT_CONSTEXPR inline auto parse_align(char c) -> align {
 1315|  1.02k|  switch (c) {
  ------------------
  |  Branch (1315:11): [True: 1.02k, False: 0]
  ------------------
 1316|      0|  case '<': return align::left;
  ------------------
  |  Branch (1316:3): [True: 0, False: 1.02k]
  ------------------
 1317|      0|  case '>': return align::right;
  ------------------
  |  Branch (1317:3): [True: 0, False: 1.02k]
  ------------------
 1318|      0|  case '^': return align::center;
  ------------------
  |  Branch (1318:3): [True: 0, False: 1.02k]
  ------------------
 1319|  1.02k|  }
 1320|  1.02k|  return align::none;
 1321|  1.02k|}
_ZN3fmt3v116detail11to_unsignedIlEENSt3__113make_unsignedIT_E4typeES5_:
  437|  2.44k|FMT_CONSTEXPR auto to_unsigned(Int value) -> make_unsigned_t<Int> {
  438|  2.44k|  FMT_ASSERT(std::is_unsigned<Int>::value || value >= 0, "negative value");
  ------------------
  |  |  397|  4.88k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:7): [Folded - Ignored]
  |  |  |  Branch (397:7): [True: 2.44k, False: 0]
  |  |  ------------------
  |  |  398|  2.44k|         ? (void)0                                                          \
  |  |  399|  2.44k|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
  439|  2.44k|  return static_cast<make_unsigned_t<Int>>(value);
  440|  2.44k|}
_ZNK3fmt3v1117basic_string_viewIcE4dataEv:
  561|  2.04k|  constexpr auto data() const noexcept -> const Char* { return data_; }
_ZNK3fmt3v1117basic_string_viewIcE4sizeEv:
  564|  3.06k|  constexpr auto size() const noexcept -> size_t { return size_; }
_ZNK3fmt3v116detail6bufferIjEixIiEERKjT_:
 1843|   682k|  FMT_CONSTEXPR auto operator[](Idx index) const -> const T& {
 1844|   682k|    return ptr_[index];
 1845|   682k|  }
_ZN3fmt3v116detail6bufferIjEixIiEERjT_:
 1839|  1.90M|  template <typename Idx> FMT_CONSTEXPR auto operator[](Idx index) -> T& {
 1840|  1.90M|    return ptr_[index];
 1841|  1.90M|  }
_ZNK3fmt3v116detail6bufferIjE4sizeEv:
 1785|  1.83M|  constexpr auto size() const noexcept -> size_t { return size_; }
_ZN3fmt3v116detail6bufferIjE11try_reserveEm:
 1808|   180k|  FMT_CONSTEXPR void try_reserve(size_t new_capacity) {
 1809|   180k|    if (new_capacity > capacity_) grow_(*this, new_capacity);
  ------------------
  |  Branch (1809:9): [True: 0, False: 180k]
  ------------------
 1810|   180k|  }
_ZN3fmt3v116detail6bufferIjE10try_resizeEm:
 1799|   175k|  FMT_CONSTEXPR void try_resize(size_t count) {
 1800|   175k|    try_reserve(count);
 1801|   175k|    size_ = min_of(count, capacity_);
 1802|   175k|  }
_ZNK3fmt3v116detail6bufferIjEixImEERKjT_:
 1843|   828k|  FMT_CONSTEXPR auto operator[](Idx index) const -> const T& {
 1844|   828k|    return ptr_[index];
 1845|   828k|  }
_ZN3fmt3v116detail6bufferIjEixImEERjT_:
 1839|   976k|  template <typename Idx> FMT_CONSTEXPR auto operator[](Idx index) -> T& {
 1840|   976k|    return ptr_[index];
 1841|   976k|  }
_ZN3fmt3v116detail6bufferIjE9push_backERKj:
 1812|  4.79k|  FMT_CONSTEXPR void push_back(const T& value) {
 1813|  4.79k|    try_reserve(size_ + 1);
 1814|  4.79k|    ptr_[size_++] = value;
 1815|  4.79k|  }
_ZN3fmt3v116detail6bufferIjE3setEPjm:
 1766|  7.80k|  FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept {
 1767|  7.80k|    ptr_ = buf_data;
 1768|  7.80k|    capacity_ = buf_capacity;
 1769|  7.80k|  }
_ZNK3fmt3v116detail6bufferIjE4dataEv:
 1792|    475|  FMT_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; }
_ZN3fmt3v116detail6bufferIjE4dataEv:
 1791|  12.5k|  FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; }
_ZN3fmt3v116detail4copyIjPKjPjTnNSt3__19enable_ifIXntsr23is_back_insert_iteratorIT1_EE5valueEiE4typeELi0EEES8_T0_SB_S8_:
 2056|    475|FMT_CONSTEXPR auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt {
 2057|  6.24k|  while (begin != end) *out++ = static_cast<T>(*begin++);
  ------------------
  |  Branch (2057:10): [True: 5.76k, False: 475]
  ------------------
 2058|    475|  return out;
 2059|    475|}
_ZN3fmt3v116min_ofIiEET_S2_S2_:
  352|  2.69k|template <typename T> constexpr auto min_of(T a, T b) -> T {
  353|  2.69k|  return a < b ? a : b;
  ------------------
  |  Branch (353:10): [True: 529, False: 2.16k]
  ------------------
  354|  2.69k|}
_ZN3fmt3v116detail6bufferIcE10try_resizeEm:
 1799|  2.09k|  FMT_CONSTEXPR void try_resize(size_t count) {
 1800|  2.09k|    try_reserve(count);
 1801|  2.09k|    size_ = min_of(count, capacity_);
 1802|  2.09k|  }
_ZN3fmt3v116detail6bufferIcEixIiEERcT_:
 1839|  46.5k|  template <typename Idx> FMT_CONSTEXPR auto operator[](Idx index) -> T& {
 1840|  46.5k|    return ptr_[index];
 1841|  46.5k|  }
_ZN3fmt3v116detail6bufferIcEixImEERcT_:
 1839|  12.1k|  template <typename Idx> FMT_CONSTEXPR auto operator[](Idx index) -> T& {
 1840|  12.1k|    return ptr_[index];
 1841|  12.1k|  }
_ZN3fmt3v116detail8to_asciiIcTnNSt3__19enable_ifIXsr3std11is_integralIT_EE5valueEiE4typeELi0EEEcS5_:
 1277|  3.06k|constexpr auto to_ascii(Char c) -> char {
 1278|  3.06k|  return c <= 0xff ? static_cast<char>(c) : '\0';
  ------------------
  |  Branch (1278:10): [True: 3.06k, False: 0]
  ------------------
 1279|  3.06k|}
_ZZN3fmt3v116detail18parse_format_specsIcEEPKT_S5_S5_RNS1_20dynamic_format_specsIS3_EERNS0_13parse_contextIS3_EENS1_4typeEENUt_clENS1_5stateEb:
 1456|  1.02k|    FMT_CONSTEXPR void operator()(state s, bool valid = true) {
 1457|  1.02k|      if (current_state >= s || !valid)
  ------------------
  |  Branch (1457:11): [True: 0, False: 1.02k]
  |  Branch (1457:33): [True: 0, False: 1.02k]
  ------------------
 1458|      0|        report_error("invalid format specifier");
 1459|  1.02k|      current_state = s;
 1460|  1.02k|    }
_ZZN3fmt3v116detail18parse_format_specsIcEEPKT_S5_S5_RNS1_20dynamic_format_specsIS3_EERNS0_13parse_contextIS3_EENS1_4typeEENUt0_clENS0_17presentation_typeEi:
 1470|  1.02k|    FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* {
 1471|  1.02k|      if (!in(arg_type, set)) report_error("invalid format specifier");
  ------------------
  |  Branch (1471:11): [True: 0, False: 1.02k]
  ------------------
 1472|  1.02k|      specs.set_type(pres_type);
 1473|  1.02k|      return begin + 1;
 1474|  1.02k|    }
_ZN3fmt3v116detail21parse_nonnegative_intIcEEiRPKT_S5_i:
 1293|  1.02k|                                         int error_value) noexcept -> int {
 1294|  1.02k|  FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
  ------------------
  |  |  397|  4.08k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:7): [True: 1.02k, False: 0]
  |  |  |  Branch (397:7): [True: 1.02k, False: 0]
  |  |  |  Branch (397:7): [True: 1.02k, False: 0]
  |  |  ------------------
  |  |  398|  1.02k|         ? (void)0                                                          \
  |  |  399|  1.02k|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1295|  1.02k|  unsigned value = 0, prev = 0;
 1296|  1.02k|  auto p = begin;
 1297|  2.04k|  do {
 1298|  2.04k|    prev = value;
 1299|  2.04k|    value = value * 10 + unsigned(*p - '0');
 1300|  2.04k|    ++p;
 1301|  2.04k|  } while (p != end && '0' <= *p && *p <= '9');
  ------------------
  |  Branch (1301:12): [True: 2.04k, False: 0]
  |  Branch (1301:24): [True: 2.04k, False: 0]
  |  Branch (1301:37): [True: 1.02k, False: 1.02k]
  ------------------
 1302|  1.02k|  auto num_digits = p - begin;
 1303|  1.02k|  begin = p;
 1304|  1.02k|  int digits10 = static_cast<int>(sizeof(int) * CHAR_BIT * 3 / 10);
 1305|  1.02k|  if (num_digits <= digits10) return static_cast<int>(value);
  ------------------
  |  Branch (1305:7): [True: 1.02k, False: 0]
  ------------------
 1306|       |  // Check for overflow.
 1307|      0|  unsigned max = INT_MAX;
 1308|      0|  return num_digits == digits10 + 1 &&
  ------------------
  |  Branch (1308:10): [True: 0, False: 0]
  ------------------
 1309|      0|                 prev * 10ull + unsigned(p[-1] - '0') <= max
  ------------------
  |  Branch (1309:18): [True: 0, False: 0]
  ------------------
 1310|      0|             ? static_cast<int>(value)
 1311|      0|             : error_value;
 1312|  1.02k|}
_ZN3fmt3v1113parse_contextIcE15do_check_arg_idEi:
 2432|  1.02k|FMT_CONSTEXPR void parse_context<Char>::do_check_arg_id(int arg_id) {
 2433|       |  // Argument id is only checked at compile time during parsing because
 2434|       |  // formatting has its own validation.
 2435|  1.02k|  if (detail::is_constant_evaluated() && use_constexpr_cast) {
  ------------------
  |  Branch (2435:7): [Folded - Ignored]
  |  Branch (2435:42): [Folded - Ignored]
  ------------------
 2436|      0|    auto ctx = static_cast<detail::compile_parse_context<Char>*>(this);
 2437|      0|    if (arg_id >= ctx->num_args()) report_error("argument not found");
  ------------------
  |  Branch (2437:9): [True: 0, False: 0]
  ------------------
 2438|      0|  }
 2439|  1.02k|}
_ZN3fmt3v1113parse_contextIcE11next_arg_idEv:
  899|  1.02k|  FMT_CONSTEXPR auto next_arg_id() -> int {
  900|  1.02k|    if (next_arg_id_ < 0) {
  ------------------
  |  Branch (900:9): [True: 0, False: 1.02k]
  ------------------
  901|      0|      report_error("cannot switch from manual to automatic argument indexing");
  902|      0|      return 0;
  903|      0|    }
  904|  1.02k|    int id = next_arg_id_++;
  905|  1.02k|    do_check_arg_id(id);
  906|  1.02k|    return id;
  907|  1.02k|  }
_ZN3fmt3v116detail18parse_dynamic_specIcEENS1_25parse_dynamic_spec_resultIT_EEPKS4_S7_RiRNS1_7arg_refIS4_EERNS0_13parse_contextIS4_EE:
 1383|  1.02k|    -> parse_dynamic_spec_result<Char> {
 1384|  1.02k|  FMT_ASSERT(begin != end, "");
  ------------------
  |  |  397|  1.02k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:6): [True: 1.02k, False: 0]
  |  |  ------------------
  |  |  398|  1.02k|         ? (void)0                                                          \
  |  |  399|  1.02k|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1385|  1.02k|  auto kind = arg_id_kind::none;
 1386|  1.02k|  if ('0' <= *begin && *begin <= '9') {
  ------------------
  |  Branch (1386:7): [True: 1.02k, False: 0]
  |  Branch (1386:24): [True: 1.02k, False: 0]
  ------------------
 1387|  1.02k|    int val = parse_nonnegative_int(begin, end, -1);
 1388|  1.02k|    if (val == -1) report_error("number is too big");
  ------------------
  |  Branch (1388:9): [True: 0, False: 1.02k]
  ------------------
 1389|  1.02k|    value = val;
 1390|  1.02k|  } else {
 1391|      0|    if (*begin == '{') {
  ------------------
  |  Branch (1391:9): [True: 0, False: 0]
  ------------------
 1392|      0|      ++begin;
 1393|      0|      if (begin != end) {
  ------------------
  |  Branch (1393:11): [True: 0, False: 0]
  ------------------
 1394|      0|        Char c = *begin;
 1395|      0|        if (c == '}' || c == ':') {
  ------------------
  |  Branch (1395:13): [True: 0, False: 0]
  |  Branch (1395:25): [True: 0, False: 0]
  ------------------
 1396|      0|          int id = ctx.next_arg_id();
 1397|      0|          ref = id;
 1398|      0|          kind = arg_id_kind::index;
 1399|      0|          ctx.check_dynamic_spec(id);
 1400|      0|        } else {
 1401|      0|          begin = parse_arg_id(begin, end,
 1402|      0|                               dynamic_spec_handler<Char>{ctx, ref, kind});
 1403|      0|        }
 1404|      0|      }
 1405|      0|      if (begin != end && *begin == '}') return {++begin, kind};
  ------------------
  |  Branch (1405:11): [True: 0, False: 0]
  |  Branch (1405:27): [True: 0, False: 0]
  ------------------
 1406|      0|    }
 1407|      0|    report_error("invalid format string");
 1408|      0|  }
 1409|  1.02k|  return {begin, kind};
 1410|  1.02k|}
_ZN3fmt3v116detail15parse_precisionIcEEPKT_S5_S5_RNS0_12format_specsERNS1_7arg_refIS3_EERNS0_13parse_contextIS3_EE:
 1425|  1.02k|                                   parse_context<Char>& ctx) -> const Char* {
 1426|  1.02k|  ++begin;
 1427|  1.02k|  if (begin == end) {
  ------------------
  |  Branch (1427:7): [True: 0, False: 1.02k]
  ------------------
 1428|      0|    report_error("invalid precision");
 1429|      0|    return begin;
 1430|      0|  }
 1431|  1.02k|  auto result =
 1432|  1.02k|      parse_dynamic_spec(begin, end, specs.precision, precision_ref, ctx);
 1433|  1.02k|  specs.set_dynamic_precision(result.kind);
 1434|  1.02k|  return result.end;
 1435|  1.02k|}
_ZN3fmt3v116detail18parse_format_specsIcEEPKT_S5_S5_RNS1_20dynamic_format_specsIS3_EERNS0_13parse_contextIS3_EENS1_4typeE:
 1444|  1.02k|    -> const Char* {
 1445|  1.02k|  auto c = '\0';
 1446|  1.02k|  if (end - begin > 1) {
  ------------------
  |  Branch (1446:7): [True: 1.02k, False: 0]
  ------------------
 1447|  1.02k|    auto next = to_ascii(begin[1]);
 1448|  1.02k|    c = parse_align(next) == align::none ? to_ascii(*begin) : '\0';
  ------------------
  |  Branch (1448:9): [True: 1.02k, False: 0]
  ------------------
 1449|  1.02k|  } else {
 1450|      0|    if (begin == end) return begin;
  ------------------
  |  Branch (1450:9): [True: 0, False: 0]
  ------------------
 1451|      0|    c = to_ascii(*begin);
 1452|      0|  }
 1453|       |
 1454|  1.02k|  struct {
 1455|  1.02k|    state current_state = state::start;
 1456|  1.02k|    FMT_CONSTEXPR void operator()(state s, bool valid = true) {
 1457|  1.02k|      if (current_state >= s || !valid)
 1458|  1.02k|        report_error("invalid format specifier");
 1459|  1.02k|      current_state = s;
 1460|  1.02k|    }
 1461|  1.02k|  } enter_state;
 1462|       |
 1463|  1.02k|  using pres = presentation_type;
 1464|  1.02k|  constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
 1465|  1.02k|  struct {
 1466|  1.02k|    const Char*& begin;
 1467|  1.02k|    format_specs& specs;
 1468|  1.02k|    type arg_type;
 1469|       |
 1470|  1.02k|    FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* {
 1471|  1.02k|      if (!in(arg_type, set)) report_error("invalid format specifier");
 1472|  1.02k|      specs.set_type(pres_type);
 1473|  1.02k|      return begin + 1;
 1474|  1.02k|    }
 1475|  1.02k|  } parse_presentation_type{begin, specs, arg_type};
 1476|       |
 1477|  2.04k|  for (;;) {
 1478|  2.04k|    switch (c) {
 1479|      0|    case '<':
  ------------------
  |  Branch (1479:5): [True: 0, False: 2.04k]
  ------------------
 1480|      0|    case '>':
  ------------------
  |  Branch (1480:5): [True: 0, False: 2.04k]
  ------------------
 1481|      0|    case '^':
  ------------------
  |  Branch (1481:5): [True: 0, False: 2.04k]
  ------------------
 1482|      0|      enter_state(state::align);
 1483|      0|      specs.set_align(parse_align(c));
 1484|      0|      ++begin;
 1485|      0|      break;
 1486|      0|    case '+':
  ------------------
  |  Branch (1486:5): [True: 0, False: 2.04k]
  ------------------
 1487|      0|    case ' ':
  ------------------
  |  Branch (1487:5): [True: 0, False: 2.04k]
  ------------------
 1488|      0|      specs.set_sign(c == ' ' ? sign::space : sign::plus);
  ------------------
  |  Branch (1488:22): [True: 0, False: 0]
  ------------------
 1489|      0|      FMT_FALLTHROUGH;
  ------------------
  |  |  181|      0|#  define FMT_FALLTHROUGH [[clang::fallthrough]]
  ------------------
 1490|      0|    case '-':
  ------------------
  |  Branch (1490:5): [True: 0, False: 2.04k]
  ------------------
 1491|      0|      enter_state(state::sign, in(arg_type, sint_set | float_set));
 1492|      0|      ++begin;
 1493|      0|      break;
 1494|      0|    case '#':
  ------------------
  |  Branch (1494:5): [True: 0, False: 2.04k]
  ------------------
 1495|      0|      enter_state(state::hash, is_arithmetic_type(arg_type));
 1496|      0|      specs.set_alt();
 1497|      0|      ++begin;
 1498|      0|      break;
 1499|      0|    case '0':
  ------------------
  |  Branch (1499:5): [True: 0, False: 2.04k]
  ------------------
 1500|      0|      enter_state(state::zero);
 1501|      0|      if (!is_arithmetic_type(arg_type))
  ------------------
  |  Branch (1501:11): [True: 0, False: 0]
  ------------------
 1502|      0|        report_error("format specifier requires numeric argument");
 1503|      0|      if (specs.align() == align::none) {
  ------------------
  |  Branch (1503:11): [True: 0, False: 0]
  ------------------
 1504|       |        // Ignore 0 if align is specified for compatibility with std::format.
 1505|      0|        specs.set_align(align::numeric);
 1506|      0|        specs.set_fill('0');
 1507|      0|      }
 1508|      0|      ++begin;
 1509|      0|      break;
 1510|       |      // clang-format off
 1511|      0|    case '1': case '2': case '3': case '4': case '5':
  ------------------
  |  Branch (1511:5): [True: 0, False: 2.04k]
  |  Branch (1511:15): [True: 0, False: 2.04k]
  |  Branch (1511:25): [True: 0, False: 2.04k]
  |  Branch (1511:35): [True: 0, False: 2.04k]
  |  Branch (1511:45): [True: 0, False: 2.04k]
  ------------------
 1512|      0|    case '6': case '7': case '8': case '9': case '{':
  ------------------
  |  Branch (1512:5): [True: 0, False: 2.04k]
  |  Branch (1512:15): [True: 0, False: 2.04k]
  |  Branch (1512:25): [True: 0, False: 2.04k]
  |  Branch (1512:35): [True: 0, False: 2.04k]
  |  Branch (1512:45): [True: 0, False: 2.04k]
  ------------------
 1513|       |      // clang-format on
 1514|      0|      enter_state(state::width);
 1515|      0|      begin = parse_width(begin, end, specs, specs.width_ref, ctx);
 1516|      0|      break;
 1517|  1.02k|    case '.':
  ------------------
  |  Branch (1517:5): [True: 1.02k, False: 1.02k]
  ------------------
 1518|  1.02k|      enter_state(state::precision,
 1519|  1.02k|                  in(arg_type, float_set | string_set | cstring_set));
 1520|  1.02k|      begin = parse_precision(begin, end, specs, specs.precision_ref, ctx);
 1521|  1.02k|      break;
 1522|      0|    case 'L':
  ------------------
  |  Branch (1522:5): [True: 0, False: 2.04k]
  ------------------
 1523|      0|      enter_state(state::locale, is_arithmetic_type(arg_type));
 1524|      0|      specs.set_localized();
 1525|      0|      ++begin;
 1526|      0|      break;
 1527|      0|    case 'd': return parse_presentation_type(pres::dec, integral_set);
  ------------------
  |  Branch (1527:5): [True: 0, False: 2.04k]
  ------------------
 1528|      0|    case 'X': specs.set_upper(); FMT_FALLTHROUGH;
  ------------------
  |  |  181|      0|#  define FMT_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  |  Branch (1528:5): [True: 0, False: 2.04k]
  ------------------
 1529|      0|    case 'x': return parse_presentation_type(pres::hex, integral_set);
  ------------------
  |  Branch (1529:5): [True: 0, False: 2.04k]
  ------------------
 1530|      0|    case 'o': return parse_presentation_type(pres::oct, integral_set);
  ------------------
  |  Branch (1530:5): [True: 0, False: 2.04k]
  ------------------
 1531|      0|    case 'B': specs.set_upper(); FMT_FALLTHROUGH;
  ------------------
  |  |  181|      0|#  define FMT_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  |  Branch (1531:5): [True: 0, False: 2.04k]
  ------------------
 1532|      0|    case 'b': return parse_presentation_type(pres::bin, integral_set);
  ------------------
  |  Branch (1532:5): [True: 0, False: 2.04k]
  ------------------
 1533|      0|    case 'E': specs.set_upper(); FMT_FALLTHROUGH;
  ------------------
  |  |  181|      0|#  define FMT_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  |  Branch (1533:5): [True: 0, False: 2.04k]
  ------------------
 1534|      0|    case 'e': return parse_presentation_type(pres::exp, float_set);
  ------------------
  |  Branch (1534:5): [True: 0, False: 2.04k]
  ------------------
 1535|      0|    case 'F': specs.set_upper(); FMT_FALLTHROUGH;
  ------------------
  |  |  181|      0|#  define FMT_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  |  Branch (1535:5): [True: 0, False: 2.04k]
  ------------------
 1536|      0|    case 'f': return parse_presentation_type(pres::fixed, float_set);
  ------------------
  |  Branch (1536:5): [True: 0, False: 2.04k]
  ------------------
 1537|      0|    case 'G': specs.set_upper(); FMT_FALLTHROUGH;
  ------------------
  |  |  181|      0|#  define FMT_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  |  Branch (1537:5): [True: 0, False: 2.04k]
  ------------------
 1538|  1.02k|    case 'g': return parse_presentation_type(pres::general, float_set);
  ------------------
  |  Branch (1538:5): [True: 1.02k, False: 1.02k]
  ------------------
 1539|      0|    case 'A': specs.set_upper(); FMT_FALLTHROUGH;
  ------------------
  |  |  181|      0|#  define FMT_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  |  Branch (1539:5): [True: 0, False: 2.04k]
  ------------------
 1540|      0|    case 'a': return parse_presentation_type(pres::hexfloat, float_set);
  ------------------
  |  Branch (1540:5): [True: 0, False: 2.04k]
  ------------------
 1541|      0|    case 'c':
  ------------------
  |  Branch (1541:5): [True: 0, False: 2.04k]
  ------------------
 1542|      0|      if (arg_type == type::bool_type) report_error("invalid format specifier");
  ------------------
  |  Branch (1542:11): [True: 0, False: 0]
  ------------------
 1543|      0|      return parse_presentation_type(pres::chr, integral_set);
 1544|      0|    case 's':
  ------------------
  |  Branch (1544:5): [True: 0, False: 2.04k]
  ------------------
 1545|      0|      return parse_presentation_type(pres::string,
 1546|      0|                                     bool_set | string_set | cstring_set);
 1547|      0|    case 'p':
  ------------------
  |  Branch (1547:5): [True: 0, False: 2.04k]
  ------------------
 1548|      0|      return parse_presentation_type(pres::pointer, pointer_set | cstring_set);
 1549|      0|    case '?':
  ------------------
  |  Branch (1549:5): [True: 0, False: 2.04k]
  ------------------
 1550|      0|      return parse_presentation_type(pres::debug,
 1551|      0|                                     char_set | string_set | cstring_set);
 1552|      0|    case '}': return begin;
  ------------------
  |  Branch (1552:5): [True: 0, False: 2.04k]
  ------------------
 1553|      0|    default:  {
  ------------------
  |  Branch (1553:5): [True: 0, False: 2.04k]
  ------------------
 1554|      0|      if (*begin == '}') return begin;
  ------------------
  |  Branch (1554:11): [True: 0, False: 0]
  ------------------
 1555|       |      // Parse fill and alignment.
 1556|      0|      auto fill_end = begin + code_point_length(begin);
 1557|      0|      if (end - fill_end <= 0) {
  ------------------
  |  Branch (1557:11): [True: 0, False: 0]
  ------------------
 1558|      0|        report_error("invalid format specifier");
 1559|      0|        return begin;
 1560|      0|      }
 1561|      0|      if (*begin == '{') {
  ------------------
  |  Branch (1561:11): [True: 0, False: 0]
  ------------------
 1562|      0|        report_error("invalid fill character '{'");
 1563|      0|        return begin;
 1564|      0|      }
 1565|      0|      auto alignment = parse_align(to_ascii(*fill_end));
 1566|      0|      enter_state(state::align, alignment != align::none);
 1567|      0|      specs.set_fill(
 1568|      0|          basic_string_view<Char>(begin, to_unsigned(fill_end - begin)));
 1569|      0|      specs.set_align(alignment);
 1570|      0|      begin = fill_end + 1;
 1571|      0|    }
 1572|  2.04k|    }
 1573|  1.02k|    if (begin == end) return begin;
  ------------------
  |  Branch (1573:9): [True: 0, False: 1.02k]
  ------------------
 1574|  1.02k|    c = to_ascii(*begin);
 1575|  1.02k|  }
 1576|  1.02k|}
_ZN3fmt3v1114basic_appenderIcEppEi:
 2467|  7.01k|  FMT_CONSTEXPR20 auto operator++(int) -> basic_appender { return *this; }
_ZN3fmt3v1114basic_appenderIcEdeEv:
 2465|  7.01k|  FMT_CONSTEXPR20 auto operator*() -> basic_appender& { return *this; }
_ZN3fmt3v1114basic_appenderIcEaSEc:
 2461|  7.01k|  FMT_CONSTEXPR20 auto operator=(T c) -> basic_appender& {
 2462|  7.01k|    container->push_back(c);
 2463|  7.01k|    return *this;
 2464|  7.01k|  }
_ZNK3fmt3v116detail6bufferIjE8capacityEv:
 1788|  4.10k|  constexpr auto capacity() const noexcept -> size_t { return capacity_; }
_ZN3fmt3v116detail4copyIjPjS3_TnNSt3__19enable_ifIXntsr23is_back_insert_iteratorIT1_EE5valueEiE4typeELi0EEES6_T0_S9_S6_:
 2056|  4.10k|FMT_CONSTEXPR auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt {
 2057|  14.2k|  while (begin != end) *out++ = static_cast<T>(*begin++);
  ------------------
  |  Branch (2057:10): [True: 10.1k, False: 4.10k]
  ------------------
 2058|  4.10k|  return out;
 2059|  4.10k|}
_ZN3fmt3v116detail13get_containerINS0_14basic_appenderIcEEEERNT_14container_typeES5_:
  500|  6.77k|    typename OutputIt::container_type& {
  501|  6.77k|  struct accessor : OutputIt {
  502|  6.77k|    FMT_CONSTEXPR20 accessor(OutputIt base) : OutputIt(base) {}
  503|  6.77k|    using OutputIt::container;
  504|  6.77k|  };
  505|  6.77k|  return *accessor(it).container;
  506|  6.77k|}
_ZN3fmt3v116detail4copyIcPcNS0_14basic_appenderIcEETnNSt3__19enable_ifIXaasr23is_back_insert_iteratorIT1_EE5valuesr41has_back_insert_iterator_container_appendIS8_T0_EE5valueEiE4typeELi0EEES8_S9_S9_S8_:
 2038|    679|    -> OutputIt {
 2039|    679|  get_container(out).append(begin, end);
 2040|    679|  return out;
 2041|    679|}
_ZN3fmt3v116detail6bufferIcE6appendIcEEvPKT_S7_:
 1825|  4.48k|      append(const U* begin, const U* end) {
 1826|  6.92k|    while (begin != end) {
  ------------------
  |  Branch (1826:12): [True: 2.44k, False: 4.48k]
  ------------------
 1827|  2.44k|      auto count = to_unsigned(end - begin);
 1828|  2.44k|      try_reserve(size_ + count);
 1829|  2.44k|      auto free_cap = capacity_ - size_;
 1830|  2.44k|      if (free_cap < count) count = free_cap;
  ------------------
  |  Branch (1830:11): [True: 0, False: 2.44k]
  ------------------
 1831|       |      // A loop is faster than memcpy on small sizes.
 1832|  2.44k|      T* out = ptr_ + size_;
 1833|  48.8k|      for (size_t i = 0; i < count; ++i) out[i] = begin[i];
  ------------------
  |  Branch (1833:26): [True: 46.4k, False: 2.44k]
  ------------------
 1834|  2.44k|      size_ += count;
 1835|  2.44k|      begin += count;
 1836|  2.44k|    }
 1837|  4.48k|  }
_ZN3fmt3v1114basic_appenderIcEC2ERNS0_6detail6bufferIcEE:
 2459|  2.04k|  FMT_CONSTEXPR basic_appender(detail::buffer<T>& buf) : container(&buf) {}
_ZN3fmt3v1116basic_format_argINS0_7contextEEC2Ev:
 2494|  2.04k|  constexpr basic_format_arg() : type_(detail::type::none_type) {}
_ZN3fmt3v116detail5valueINS0_7contextEEC2Ev:
 2149|  2.04k|  constexpr FMT_INLINE value() : no_value() {}
_ZNK3fmt3v1116basic_format_argINS0_7contextEE5visitINS0_6detail21default_arg_formatterIcEEEEDTclfp_Li0EEEOT_:
 2512|  1.02k|  FMT_CONSTEXPR FMT_INLINE auto visit(Visitor&& vis) const -> decltype(vis(0)) {
 2513|  1.02k|    using detail::map;
 2514|  1.02k|    switch (type_) {
  ------------------
  |  Branch (2514:13): [True: 0, False: 1.02k]
  ------------------
 2515|      0|    case detail::type::none_type:        break;
  ------------------
  |  Branch (2515:5): [True: 0, False: 1.02k]
  ------------------
 2516|      0|    case detail::type::int_type:         return vis(value_.int_value);
  ------------------
  |  Branch (2516:5): [True: 0, False: 1.02k]
  ------------------
 2517|      0|    case detail::type::uint_type:        return vis(value_.uint_value);
  ------------------
  |  Branch (2517:5): [True: 0, False: 1.02k]
  ------------------
 2518|      0|    case detail::type::long_long_type:   return vis(value_.long_long_value);
  ------------------
  |  Branch (2518:5): [True: 0, False: 1.02k]
  ------------------
 2519|      0|    case detail::type::ulong_long_type:  return vis(value_.ulong_long_value);
  ------------------
  |  Branch (2519:5): [True: 0, False: 1.02k]
  ------------------
 2520|      0|    case detail::type::int128_type:      return vis(map(value_.int128_value));
  ------------------
  |  Branch (2520:5): [True: 0, False: 1.02k]
  ------------------
 2521|      0|    case detail::type::uint128_type:     return vis(map(value_.uint128_value));
  ------------------
  |  Branch (2521:5): [True: 0, False: 1.02k]
  ------------------
 2522|      0|    case detail::type::bool_type:        return vis(value_.bool_value);
  ------------------
  |  Branch (2522:5): [True: 0, False: 1.02k]
  ------------------
 2523|      0|    case detail::type::char_type:        return vis(value_.char_value);
  ------------------
  |  Branch (2523:5): [True: 0, False: 1.02k]
  ------------------
 2524|      0|    case detail::type::float_type:       return vis(value_.float_value);
  ------------------
  |  Branch (2524:5): [True: 0, False: 1.02k]
  ------------------
 2525|  1.02k|    case detail::type::double_type:      return vis(value_.double_value);
  ------------------
  |  Branch (2525:5): [True: 1.02k, False: 0]
  ------------------
 2526|      0|    case detail::type::long_double_type: return vis(value_.long_double_value);
  ------------------
  |  Branch (2526:5): [True: 0, False: 1.02k]
  ------------------
 2527|      0|    case detail::type::cstring_type:     return vis(value_.string.data);
  ------------------
  |  Branch (2527:5): [True: 0, False: 1.02k]
  ------------------
 2528|      0|    case detail::type::string_type:      return vis(value_.string.str());
  ------------------
  |  Branch (2528:5): [True: 0, False: 1.02k]
  ------------------
 2529|      0|    case detail::type::pointer_type:     return vis(value_.pointer);
  ------------------
  |  Branch (2529:5): [True: 0, False: 1.02k]
  ------------------
 2530|      0|    case detail::type::custom_type:      return vis(handle(value_.custom));
  ------------------
  |  Branch (2530:5): [True: 0, False: 1.02k]
  ------------------
 2531|  1.02k|    }
 2532|      0|    return vis(monostate());
 2533|  1.02k|  }
_ZZN3fmt3v116detail13get_containerINS0_14basic_appenderIcEEEERNT_14container_typeES5_EN8accessorC2ES4_:
  502|  6.77k|    FMT_CONSTEXPR20 accessor(OutputIt base) : OutputIt(base) {}
_ZNK3fmt3v1111basic_specs9fill_unitIcEET_v:
  821|    188|  template <typename Char> constexpr auto fill_unit() const -> Char {
  822|    188|    using uchar = unsigned char;
  823|    188|    return static_cast<Char>(static_cast<uchar>(fill_data_[0]) |
  824|    188|                             (static_cast<uchar>(fill_data_[1]) << 8) |
  825|    188|                             (static_cast<uchar>(fill_data_[2]) << 16));
  826|    188|  }
_ZN3fmt3v116detail4copyIcPKcNS0_14basic_appenderIcEETnNSt3__19enable_ifIXaasr23is_back_insert_iteratorIT1_EE5valuesr41has_back_insert_iterator_container_appendIS9_T0_EE5valueEiE4typeELi0EEES9_SA_SA_S9_:
 2038|  3.80k|    -> OutputIt {
 2039|  3.80k|  get_container(out).append(begin, end);
 2040|  3.80k|  return out;
 2041|  3.80k|}
_ZN3fmt3v116detail6bufferIjEC2EPFvRS3_mEPjmm:
 1760|  7.80k|      : ptr_(p), size_(sz), capacity_(cap), grow_(grow) {}
_ZN3fmt3v116detail19parse_format_stringIcNS1_14format_handlerIcEEEEvNS0_17basic_string_viewIT_EEOT0_:
 1627|  1.02k|                                       Handler&& handler) {
 1628|  1.02k|  auto begin = fmt.data(), end = begin + fmt.size();
 1629|  1.02k|  auto p = begin;
 1630|  2.04k|  while (p != end) {
  ------------------
  |  Branch (1630:10): [True: 1.02k, False: 1.02k]
  ------------------
 1631|  1.02k|    auto c = *p++;
 1632|  1.02k|    if (c == '{') {
  ------------------
  |  Branch (1632:9): [True: 1.02k, False: 0]
  ------------------
 1633|  1.02k|      handler.on_text(begin, p - 1);
 1634|  1.02k|      begin = p = parse_replacement_field(p - 1, end, handler);
 1635|  1.02k|    } else if (c == '}') {
  ------------------
  |  Branch (1635:16): [True: 0, False: 0]
  ------------------
 1636|      0|      if (p == end || *p != '}')
  ------------------
  |  Branch (1636:11): [True: 0, False: 0]
  |  Branch (1636:23): [True: 0, False: 0]
  ------------------
 1637|      0|        return handler.on_error("unmatched '}' in format string");
 1638|      0|      handler.on_text(begin, p);
 1639|      0|      begin = ++p;
 1640|      0|    }
 1641|  1.02k|  }
 1642|  1.02k|  handler.on_text(begin, end);
 1643|  1.02k|}
_ZN3fmt3v116detail23parse_replacement_fieldIcRNS1_14format_handlerIcEEEEPKT_S8_S8_OT0_:
 1582|  1.02k|    -> const Char* {
 1583|  1.02k|  ++begin;
 1584|  1.02k|  if (begin == end) {
  ------------------
  |  Branch (1584:7): [True: 0, False: 1.02k]
  ------------------
 1585|      0|    handler.on_error("invalid format string");
 1586|      0|    return end;
 1587|      0|  }
 1588|  1.02k|  int arg_id = 0;
 1589|  1.02k|  switch (*begin) {
 1590|      0|  case '}':
  ------------------
  |  Branch (1590:3): [True: 0, False: 1.02k]
  ------------------
 1591|      0|    handler.on_replacement_field(handler.on_arg_id(), begin);
 1592|      0|    return begin + 1;
 1593|      0|  case '{': handler.on_text(begin, begin + 1); return begin + 1;
  ------------------
  |  Branch (1593:3): [True: 0, False: 1.02k]
  ------------------
 1594|  1.02k|  case ':': arg_id = handler.on_arg_id(); break;
  ------------------
  |  Branch (1594:3): [True: 1.02k, False: 0]
  ------------------
 1595|      0|  default:  {
  ------------------
  |  Branch (1595:3): [True: 0, False: 1.02k]
  ------------------
 1596|      0|    struct id_adapter {
 1597|      0|      Handler& handler;
 1598|      0|      int arg_id;
 1599|       |
 1600|      0|      FMT_CONSTEXPR void on_index(int id) { arg_id = handler.on_arg_id(id); }
 1601|      0|      FMT_CONSTEXPR void on_name(basic_string_view<Char> id) {
 1602|      0|        arg_id = handler.on_arg_id(id);
 1603|      0|      }
 1604|      0|    } adapter = {handler, 0};
 1605|      0|    begin = parse_arg_id(begin, end, adapter);
 1606|      0|    arg_id = adapter.arg_id;
 1607|      0|    Char c = begin != end ? *begin : Char();
  ------------------
  |  Branch (1607:14): [True: 0, False: 0]
  ------------------
 1608|      0|    if (c == '}') {
  ------------------
  |  Branch (1608:9): [True: 0, False: 0]
  ------------------
 1609|      0|      handler.on_replacement_field(arg_id, begin);
 1610|      0|      return begin + 1;
 1611|      0|    }
 1612|      0|    if (c != ':') {
  ------------------
  |  Branch (1612:9): [True: 0, False: 0]
  ------------------
 1613|      0|      handler.on_error("missing '}' in format string");
 1614|      0|      return end;
 1615|      0|    }
 1616|      0|    break;
 1617|      0|  }
 1618|  1.02k|  }
 1619|  1.02k|  begin = handler.on_format_specs(arg_id, begin + 1, end);
 1620|  1.02k|  if (begin == end || *begin != '}')
  ------------------
  |  Branch (1620:7): [True: 0, False: 1.02k]
  |  Branch (1620:23): [True: 0, False: 1.02k]
  ------------------
 1621|      0|    return handler.on_error("unknown format specifier"), end;
 1622|  1.02k|  return begin + 1;
 1623|  1.02k|}
_ZNK3fmt3v1116basic_format_argINS0_7contextEEcvbEv:
 2501|  1.02k|  constexpr explicit operator bool() const noexcept {
 2502|  1.02k|    return type_ != detail::type::none_type;
 2503|  1.02k|  }
_ZN3fmt3v1116basic_format_argINS0_7contextEE13format_customEPKcRNS0_13parse_contextIcEERS2_:
 2537|  1.02k|      -> bool {
 2538|  1.02k|    if (type_ != detail::type::custom_type) return false;
  ------------------
  |  Branch (2538:9): [True: 1.02k, False: 0]
  ------------------
 2539|      0|    parse_ctx.advance_to(parse_begin);
 2540|      0|    value_.custom.format(value_.custom.value, parse_ctx, ctx);
 2541|      0|    return true;
 2542|  1.02k|  }
_ZN3fmt3v116detail7arg_refIcEC2Ei:
 1260|  2.04k|  FMT_CONSTEXPR arg_ref(int idx = 0) : index(idx) {}
_ZNK3fmt3v1116basic_format_argINS0_7contextEE4typeEv:
 2504|  1.02k|  auto type() const -> detail::type { return type_; }
_ZNK3fmt3v1116basic_format_argINS0_7contextEE5visitINS0_6detail13arg_formatterIcEEEEDTclfp_Li0EEEOT_:
 2512|  1.02k|  FMT_CONSTEXPR FMT_INLINE auto visit(Visitor&& vis) const -> decltype(vis(0)) {
 2513|  1.02k|    using detail::map;
 2514|  1.02k|    switch (type_) {
  ------------------
  |  Branch (2514:13): [True: 0, False: 1.02k]
  ------------------
 2515|      0|    case detail::type::none_type:        break;
  ------------------
  |  Branch (2515:5): [True: 0, False: 1.02k]
  ------------------
 2516|      0|    case detail::type::int_type:         return vis(value_.int_value);
  ------------------
  |  Branch (2516:5): [True: 0, False: 1.02k]
  ------------------
 2517|      0|    case detail::type::uint_type:        return vis(value_.uint_value);
  ------------------
  |  Branch (2517:5): [True: 0, False: 1.02k]
  ------------------
 2518|      0|    case detail::type::long_long_type:   return vis(value_.long_long_value);
  ------------------
  |  Branch (2518:5): [True: 0, False: 1.02k]
  ------------------
 2519|      0|    case detail::type::ulong_long_type:  return vis(value_.ulong_long_value);
  ------------------
  |  Branch (2519:5): [True: 0, False: 1.02k]
  ------------------
 2520|      0|    case detail::type::int128_type:      return vis(map(value_.int128_value));
  ------------------
  |  Branch (2520:5): [True: 0, False: 1.02k]
  ------------------
 2521|      0|    case detail::type::uint128_type:     return vis(map(value_.uint128_value));
  ------------------
  |  Branch (2521:5): [True: 0, False: 1.02k]
  ------------------
 2522|      0|    case detail::type::bool_type:        return vis(value_.bool_value);
  ------------------
  |  Branch (2522:5): [True: 0, False: 1.02k]
  ------------------
 2523|      0|    case detail::type::char_type:        return vis(value_.char_value);
  ------------------
  |  Branch (2523:5): [True: 0, False: 1.02k]
  ------------------
 2524|      0|    case detail::type::float_type:       return vis(value_.float_value);
  ------------------
  |  Branch (2524:5): [True: 0, False: 1.02k]
  ------------------
 2525|  1.02k|    case detail::type::double_type:      return vis(value_.double_value);
  ------------------
  |  Branch (2525:5): [True: 1.02k, False: 0]
  ------------------
 2526|      0|    case detail::type::long_double_type: return vis(value_.long_double_value);
  ------------------
  |  Branch (2526:5): [True: 0, False: 1.02k]
  ------------------
 2527|      0|    case detail::type::cstring_type:     return vis(value_.string.data);
  ------------------
  |  Branch (2527:5): [True: 0, False: 1.02k]
  ------------------
 2528|      0|    case detail::type::string_type:      return vis(value_.string.str());
  ------------------
  |  Branch (2528:5): [True: 0, False: 1.02k]
  ------------------
 2529|      0|    case detail::type::pointer_type:     return vis(value_.pointer);
  ------------------
  |  Branch (2529:5): [True: 0, False: 1.02k]
  ------------------
 2530|      0|    case detail::type::custom_type:      return vis(handle(value_.custom));
  ------------------
  |  Branch (2530:5): [True: 0, False: 1.02k]
  ------------------
 2531|  1.02k|    }
 2532|      0|    return vis(monostate());
 2533|  1.02k|  }
_ZN3fmt3v1113parse_contextIcEC2ENS0_17basic_string_viewIcEEi:
  883|  1.02k|      : fmt_(fmt), next_arg_id_(next_arg_id) {}

_ZN3fmt3v116detail9dragonbox16get_cached_powerEi:
 1139|    925|FMT_FUNC auto get_cached_power(int k) noexcept -> uint128_fallback {
 1140|    925|  return cache_accessor<double>::get_cached_power(k);
 1141|    925|}
_ZN3fmt3v116detail10vformat_toERNS1_6bufferIcEENS0_17basic_string_viewIcEENS0_17basic_format_argsINS0_7contextEEENS1_10locale_refE:
 1453|  2.04k|                         locale_ref loc) {
 1454|  2.04k|  auto out = appender(buf);
 1455|  2.04k|  if (fmt.size() == 2 && equal2(fmt.data(), "{}"))
  ------------------
  |  Branch (1455:7): [True: 1.02k, False: 1.02k]
  |  Branch (1455:26): [True: 1.02k, False: 0]
  ------------------
 1456|  1.02k|    return args.get(0).visit(default_arg_formatter<char>{out});
 1457|  1.02k|  parse_format_string(
 1458|  1.02k|      fmt, format_handler<char>{parse_context<char>(fmt), {out, args, loc}});
 1459|  1.02k|}
_ZN3fmt3v116detail9dragonbox10to_decimalIdEENS2_10decimal_fpIT_EES5_:
 1259|    927|template <typename T> auto to_decimal(T x) noexcept -> decimal_fp<T> {
 1260|       |  // Step 1: integer promotion & Schubfach multiplier calculation.
 1261|       |
 1262|    927|  using carrier_uint = typename float_info<T>::carrier_uint;
 1263|    927|  using cache_entry_type = typename cache_accessor<T>::cache_entry_type;
 1264|    927|  auto br = bit_cast<carrier_uint>(x);
 1265|       |
 1266|       |  // Extract significand bits and exponent bits.
 1267|    927|  const carrier_uint significand_mask =
 1268|    927|      (static_cast<carrier_uint>(1) << num_significand_bits<T>()) - 1;
 1269|    927|  carrier_uint significand = (br & significand_mask);
 1270|    927|  int exponent =
 1271|    927|      static_cast<int>((br & exponent_mask<T>()) >> num_significand_bits<T>());
 1272|       |
 1273|    927|  if (exponent != 0) {  // Check if normal.
  ------------------
  |  Branch (1273:7): [True: 805, False: 122]
  ------------------
 1274|    805|    exponent -= exponent_bias<T>() + num_significand_bits<T>();
 1275|       |
 1276|       |    // Shorter interval case; proceed like Schubfach.
 1277|       |    // In fact, when exponent == 1 and significand == 0, the interval is
 1278|       |    // regular. However, it can be shown that the end-results are anyway same.
 1279|    805|    if (significand == 0) return shorter_interval_case<T>(exponent);
  ------------------
  |  Branch (1279:9): [True: 146, False: 659]
  ------------------
 1280|       |
 1281|    659|    significand |= (static_cast<carrier_uint>(1) << num_significand_bits<T>());
 1282|    659|  } else {
 1283|       |    // Subnormal case; the interval is always regular.
 1284|    122|    if (significand == 0) return {0, 0};
  ------------------
  |  Branch (1284:9): [True: 2, False: 120]
  ------------------
 1285|    120|    exponent =
 1286|    120|        std::numeric_limits<T>::min_exponent - num_significand_bits<T>() - 1;
 1287|    120|  }
 1288|       |
 1289|    779|  const bool include_left_endpoint = (significand % 2 == 0);
 1290|    779|  const bool include_right_endpoint = include_left_endpoint;
 1291|       |
 1292|       |  // Compute k and beta.
 1293|    779|  const int minus_k = floor_log10_pow2(exponent) - float_info<T>::kappa;
 1294|    779|  const cache_entry_type cache = cache_accessor<T>::get_cached_power(-minus_k);
 1295|    779|  const int beta = exponent + floor_log2_pow10(-minus_k);
 1296|       |
 1297|       |  // Compute zi and deltai.
 1298|       |  // 10^kappa <= deltai < 10^(kappa + 1)
 1299|    779|  const uint32_t deltai = cache_accessor<T>::compute_delta(cache, beta);
 1300|    779|  const carrier_uint two_fc = significand << 1;
 1301|       |
 1302|       |  // For the case of binary32, the result of integer check is not correct for
 1303|       |  // 29711844 * 2^-82
 1304|       |  // = 6.1442653300000000008655037797566933477355632930994033813476... * 10^-18
 1305|       |  // and 29711844 * 2^-81
 1306|       |  // = 1.2288530660000000001731007559513386695471126586198806762695... * 10^-17,
 1307|       |  // and they are the unique counterexamples. However, since 29711844 is even,
 1308|       |  // this does not cause any problem for the endpoints calculations; it can only
 1309|       |  // cause a problem when we need to perform integer check for the center.
 1310|       |  // Fortunately, with these inputs, that branch is never executed, so we are
 1311|       |  // fine.
 1312|    779|  const typename cache_accessor<T>::compute_mul_result z_mul =
 1313|    779|      cache_accessor<T>::compute_mul((two_fc | 1) << beta, cache);
 1314|       |
 1315|       |  // Step 2: Try larger divisor; remove trailing zeros if necessary.
 1316|       |
 1317|       |  // Using an upper bound on zi, we might be able to optimize the division
 1318|       |  // better than the compiler; we are computing zi / big_divisor here.
 1319|    779|  decimal_fp<T> ret_value;
 1320|    779|  ret_value.significand = divide_by_10_to_kappa_plus_1(z_mul.result);
 1321|    779|  uint32_t r = static_cast<uint32_t>(z_mul.result - float_info<T>::big_divisor *
 1322|    779|                                                        ret_value.significand);
 1323|       |
 1324|    779|  if (r < deltai) {
  ------------------
  |  Branch (1324:7): [True: 360, False: 419]
  ------------------
 1325|       |    // Exclude the right endpoint if necessary.
 1326|    360|    if (r == 0 && (z_mul.is_integer & !include_right_endpoint)) {
  ------------------
  |  Branch (1326:9): [True: 6, False: 354]
  |  Branch (1326:19): [True: 2, False: 4]
  ------------------
 1327|      2|      --ret_value.significand;
 1328|      2|      r = float_info<T>::big_divisor;
 1329|      2|      goto small_divisor_case_label;
 1330|      2|    }
 1331|    419|  } else if (r > deltai) {
  ------------------
  |  Branch (1331:14): [True: 345, False: 74]
  ------------------
 1332|    345|    goto small_divisor_case_label;
 1333|    345|  } else {
 1334|       |    // r == deltai; compare fractional parts.
 1335|     74|    const typename cache_accessor<T>::compute_mul_parity_result x_mul =
 1336|     74|        cache_accessor<T>::compute_mul_parity(two_fc - 1, cache, beta);
 1337|       |
 1338|     74|    if (!(x_mul.parity | (x_mul.is_integer & include_left_endpoint)))
  ------------------
  |  Branch (1338:9): [True: 34, False: 40]
  ------------------
 1339|     34|      goto small_divisor_case_label;
 1340|     74|  }
 1341|    398|  ret_value.exponent = minus_k + float_info<T>::kappa + 1;
 1342|       |
 1343|       |  // We may need to remove trailing zeros.
 1344|    398|  ret_value.exponent += remove_trailing_zeros(ret_value.significand);
 1345|    398|  return ret_value;
 1346|       |
 1347|       |  // Step 3: Find the significand with the smaller divisor.
 1348|       |
 1349|    381|small_divisor_case_label:
 1350|    381|  ret_value.significand *= 10;
 1351|    381|  ret_value.exponent = minus_k + float_info<T>::kappa;
 1352|       |
 1353|    381|  uint32_t dist = r - (deltai / 2) + (float_info<T>::small_divisor / 2);
 1354|    381|  const bool approx_y_parity =
 1355|    381|      ((dist ^ (float_info<T>::small_divisor / 2)) & 1) != 0;
 1356|       |
 1357|       |  // Is dist divisible by 10^kappa?
 1358|    381|  const bool divisible_by_small_divisor =
 1359|    381|      check_divisibility_and_divide_by_pow10<float_info<T>::kappa>(dist);
 1360|       |
 1361|       |  // Add dist / 10^kappa to the significand.
 1362|    381|  ret_value.significand += dist;
 1363|       |
 1364|    381|  if (!divisible_by_small_divisor) return ret_value;
  ------------------
  |  Branch (1364:7): [True: 304, False: 77]
  ------------------
 1365|       |
 1366|       |  // Check z^(f) >= epsilon^(f).
 1367|       |  // We have either yi == zi - epsiloni or yi == (zi - epsiloni) - 1,
 1368|       |  // where yi == zi - epsiloni if and only if z^(f) >= epsilon^(f).
 1369|       |  // Since there are only 2 possibilities, we only need to care about the
 1370|       |  // parity. Also, zi and r should have the same parity since the divisor
 1371|       |  // is an even number.
 1372|     77|  const auto y_mul = cache_accessor<T>::compute_mul_parity(two_fc, cache, beta);
 1373|       |
 1374|       |  // If z^(f) >= epsilon^(f), we might have a tie when z^(f) == epsilon^(f),
 1375|       |  // or equivalently, when y is an integer.
 1376|     77|  if (y_mul.parity != approx_y_parity)
  ------------------
  |  Branch (1376:7): [True: 11, False: 66]
  ------------------
 1377|     11|    --ret_value.significand;
 1378|     66|  else if (y_mul.is_integer & (ret_value.significand % 2 != 0))
  ------------------
  |  Branch (1378:12): [True: 3, False: 63]
  ------------------
 1379|      3|    --ret_value.significand;
 1380|     77|  return ret_value;
 1381|    381|}
_ZN3fmt3v116detail9dragonbox14cache_accessorIdE16get_cached_powerEi:
  369|  1.85k|  static auto get_cached_power(int k) noexcept -> uint128_fallback {
  370|  1.85k|    FMT_ASSERT(k >= float_info<double>::min_k && k <= float_info<double>::max_k,
  ------------------
  |  |  397|  3.70k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:7): [True: 1.85k, False: 0]
  |  |  |  Branch (397:7): [True: 1.85k, False: 0]
  |  |  ------------------
  |  |  398|  1.85k|         ? (void)0                                                          \
  |  |  399|  1.85k|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
  371|  1.85k|               "k is out of range");
  372|       |
  373|  1.85k|    static constexpr const uint128_fallback pow10_significands[] = {
  374|       |#if FMT_USE_FULL_CACHE_DRAGONBOX
  375|       |      {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
  376|       |      {0x9faacf3df73609b1, 0x77b191618c54e9ad},
  377|       |      {0xc795830d75038c1d, 0xd59df5b9ef6a2418},
  378|       |      {0xf97ae3d0d2446f25, 0x4b0573286b44ad1e},
  379|       |      {0x9becce62836ac577, 0x4ee367f9430aec33},
  380|       |      {0xc2e801fb244576d5, 0x229c41f793cda740},
  381|       |      {0xf3a20279ed56d48a, 0x6b43527578c11110},
  382|       |      {0x9845418c345644d6, 0x830a13896b78aaaa},
  383|       |      {0xbe5691ef416bd60c, 0x23cc986bc656d554},
  384|       |      {0xedec366b11c6cb8f, 0x2cbfbe86b7ec8aa9},
  385|       |      {0x94b3a202eb1c3f39, 0x7bf7d71432f3d6aa},
  386|       |      {0xb9e08a83a5e34f07, 0xdaf5ccd93fb0cc54},
  387|       |      {0xe858ad248f5c22c9, 0xd1b3400f8f9cff69},
  388|       |      {0x91376c36d99995be, 0x23100809b9c21fa2},
  389|       |      {0xb58547448ffffb2d, 0xabd40a0c2832a78b},
  390|       |      {0xe2e69915b3fff9f9, 0x16c90c8f323f516d},
  391|       |      {0x8dd01fad907ffc3b, 0xae3da7d97f6792e4},
  392|       |      {0xb1442798f49ffb4a, 0x99cd11cfdf41779d},
  393|       |      {0xdd95317f31c7fa1d, 0x40405643d711d584},
  394|       |      {0x8a7d3eef7f1cfc52, 0x482835ea666b2573},
  395|       |      {0xad1c8eab5ee43b66, 0xda3243650005eed0},
  396|       |      {0xd863b256369d4a40, 0x90bed43e40076a83},
  397|       |      {0x873e4f75e2224e68, 0x5a7744a6e804a292},
  398|       |      {0xa90de3535aaae202, 0x711515d0a205cb37},
  399|       |      {0xd3515c2831559a83, 0x0d5a5b44ca873e04},
  400|       |      {0x8412d9991ed58091, 0xe858790afe9486c3},
  401|       |      {0xa5178fff668ae0b6, 0x626e974dbe39a873},
  402|       |      {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
  403|       |      {0x80fa687f881c7f8e, 0x7ce66634bc9d0b9a},
  404|       |      {0xa139029f6a239f72, 0x1c1fffc1ebc44e81},
  405|       |      {0xc987434744ac874e, 0xa327ffb266b56221},
  406|       |      {0xfbe9141915d7a922, 0x4bf1ff9f0062baa9},
  407|       |      {0x9d71ac8fada6c9b5, 0x6f773fc3603db4aa},
  408|       |      {0xc4ce17b399107c22, 0xcb550fb4384d21d4},
  409|       |      {0xf6019da07f549b2b, 0x7e2a53a146606a49},
  410|       |      {0x99c102844f94e0fb, 0x2eda7444cbfc426e},
  411|       |      {0xc0314325637a1939, 0xfa911155fefb5309},
  412|       |      {0xf03d93eebc589f88, 0x793555ab7eba27cb},
  413|       |      {0x96267c7535b763b5, 0x4bc1558b2f3458df},
  414|       |      {0xbbb01b9283253ca2, 0x9eb1aaedfb016f17},
  415|       |      {0xea9c227723ee8bcb, 0x465e15a979c1cadd},
  416|       |      {0x92a1958a7675175f, 0x0bfacd89ec191eca},
  417|       |      {0xb749faed14125d36, 0xcef980ec671f667c},
  418|       |      {0xe51c79a85916f484, 0x82b7e12780e7401b},
  419|       |      {0x8f31cc0937ae58d2, 0xd1b2ecb8b0908811},
  420|       |      {0xb2fe3f0b8599ef07, 0x861fa7e6dcb4aa16},
  421|       |      {0xdfbdcece67006ac9, 0x67a791e093e1d49b},
  422|       |      {0x8bd6a141006042bd, 0xe0c8bb2c5c6d24e1},
  423|       |      {0xaecc49914078536d, 0x58fae9f773886e19},
  424|       |      {0xda7f5bf590966848, 0xaf39a475506a899f},
  425|       |      {0x888f99797a5e012d, 0x6d8406c952429604},
  426|       |      {0xaab37fd7d8f58178, 0xc8e5087ba6d33b84},
  427|       |      {0xd5605fcdcf32e1d6, 0xfb1e4a9a90880a65},
  428|       |      {0x855c3be0a17fcd26, 0x5cf2eea09a550680},
  429|       |      {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},
  430|       |      {0xd0601d8efc57b08b, 0xf13b94daf124da27},
  431|       |      {0x823c12795db6ce57, 0x76c53d08d6b70859},
  432|       |      {0xa2cb1717b52481ed, 0x54768c4b0c64ca6f},
  433|       |      {0xcb7ddcdda26da268, 0xa9942f5dcf7dfd0a},
  434|       |      {0xfe5d54150b090b02, 0xd3f93b35435d7c4d},
  435|       |      {0x9efa548d26e5a6e1, 0xc47bc5014a1a6db0},
  436|       |      {0xc6b8e9b0709f109a, 0x359ab6419ca1091c},
  437|       |      {0xf867241c8cc6d4c0, 0xc30163d203c94b63},
  438|       |      {0x9b407691d7fc44f8, 0x79e0de63425dcf1e},
  439|       |      {0xc21094364dfb5636, 0x985915fc12f542e5},
  440|       |      {0xf294b943e17a2bc4, 0x3e6f5b7b17b2939e},
  441|       |      {0x979cf3ca6cec5b5a, 0xa705992ceecf9c43},
  442|       |      {0xbd8430bd08277231, 0x50c6ff782a838354},
  443|       |      {0xece53cec4a314ebd, 0xa4f8bf5635246429},
  444|       |      {0x940f4613ae5ed136, 0x871b7795e136be9a},
  445|       |      {0xb913179899f68584, 0x28e2557b59846e40},
  446|       |      {0xe757dd7ec07426e5, 0x331aeada2fe589d0},
  447|       |      {0x9096ea6f3848984f, 0x3ff0d2c85def7622},
  448|       |      {0xb4bca50b065abe63, 0x0fed077a756b53aa},
  449|       |      {0xe1ebce4dc7f16dfb, 0xd3e8495912c62895},
  450|       |      {0x8d3360f09cf6e4bd, 0x64712dd7abbbd95d},
  451|       |      {0xb080392cc4349dec, 0xbd8d794d96aacfb4},
  452|       |      {0xdca04777f541c567, 0xecf0d7a0fc5583a1},
  453|       |      {0x89e42caaf9491b60, 0xf41686c49db57245},
  454|       |      {0xac5d37d5b79b6239, 0x311c2875c522ced6},
  455|       |      {0xd77485cb25823ac7, 0x7d633293366b828c},
  456|       |      {0x86a8d39ef77164bc, 0xae5dff9c02033198},
  457|       |      {0xa8530886b54dbdeb, 0xd9f57f830283fdfd},
  458|       |      {0xd267caa862a12d66, 0xd072df63c324fd7c},
  459|       |      {0x8380dea93da4bc60, 0x4247cb9e59f71e6e},
  460|       |      {0xa46116538d0deb78, 0x52d9be85f074e609},
  461|       |      {0xcd795be870516656, 0x67902e276c921f8c},
  462|       |      {0x806bd9714632dff6, 0x00ba1cd8a3db53b7},
  463|       |      {0xa086cfcd97bf97f3, 0x80e8a40eccd228a5},
  464|       |      {0xc8a883c0fdaf7df0, 0x6122cd128006b2ce},
  465|       |      {0xfad2a4b13d1b5d6c, 0x796b805720085f82},
  466|       |      {0x9cc3a6eec6311a63, 0xcbe3303674053bb1},
  467|       |      {0xc3f490aa77bd60fc, 0xbedbfc4411068a9d},
  468|       |      {0xf4f1b4d515acb93b, 0xee92fb5515482d45},
  469|       |      {0x991711052d8bf3c5, 0x751bdd152d4d1c4b},
  470|       |      {0xbf5cd54678eef0b6, 0xd262d45a78a0635e},
  471|       |      {0xef340a98172aace4, 0x86fb897116c87c35},
  472|       |      {0x9580869f0e7aac0e, 0xd45d35e6ae3d4da1},
  473|       |      {0xbae0a846d2195712, 0x8974836059cca10a},
  474|       |      {0xe998d258869facd7, 0x2bd1a438703fc94c},
  475|       |      {0x91ff83775423cc06, 0x7b6306a34627ddd0},
  476|       |      {0xb67f6455292cbf08, 0x1a3bc84c17b1d543},
  477|       |      {0xe41f3d6a7377eeca, 0x20caba5f1d9e4a94},
  478|       |      {0x8e938662882af53e, 0x547eb47b7282ee9d},
  479|       |      {0xb23867fb2a35b28d, 0xe99e619a4f23aa44},
  480|       |      {0xdec681f9f4c31f31, 0x6405fa00e2ec94d5},
  481|       |      {0x8b3c113c38f9f37e, 0xde83bc408dd3dd05},
  482|       |      {0xae0b158b4738705e, 0x9624ab50b148d446},
  483|       |      {0xd98ddaee19068c76, 0x3badd624dd9b0958},
  484|       |      {0x87f8a8d4cfa417c9, 0xe54ca5d70a80e5d7},
  485|       |      {0xa9f6d30a038d1dbc, 0x5e9fcf4ccd211f4d},
  486|       |      {0xd47487cc8470652b, 0x7647c32000696720},
  487|       |      {0x84c8d4dfd2c63f3b, 0x29ecd9f40041e074},
  488|       |      {0xa5fb0a17c777cf09, 0xf468107100525891},
  489|       |      {0xcf79cc9db955c2cc, 0x7182148d4066eeb5},
  490|       |      {0x81ac1fe293d599bf, 0xc6f14cd848405531},
  491|       |      {0xa21727db38cb002f, 0xb8ada00e5a506a7d},
  492|       |      {0xca9cf1d206fdc03b, 0xa6d90811f0e4851d},
  493|       |      {0xfd442e4688bd304a, 0x908f4a166d1da664},
  494|       |      {0x9e4a9cec15763e2e, 0x9a598e4e043287ff},
  495|       |      {0xc5dd44271ad3cdba, 0x40eff1e1853f29fe},
  496|       |      {0xf7549530e188c128, 0xd12bee59e68ef47d},
  497|       |      {0x9a94dd3e8cf578b9, 0x82bb74f8301958cf},
  498|       |      {0xc13a148e3032d6e7, 0xe36a52363c1faf02},
  499|       |      {0xf18899b1bc3f8ca1, 0xdc44e6c3cb279ac2},
  500|       |      {0x96f5600f15a7b7e5, 0x29ab103a5ef8c0ba},
  501|       |      {0xbcb2b812db11a5de, 0x7415d448f6b6f0e8},
  502|       |      {0xebdf661791d60f56, 0x111b495b3464ad22},
  503|       |      {0x936b9fcebb25c995, 0xcab10dd900beec35},
  504|       |      {0xb84687c269ef3bfb, 0x3d5d514f40eea743},
  505|       |      {0xe65829b3046b0afa, 0x0cb4a5a3112a5113},
  506|       |      {0x8ff71a0fe2c2e6dc, 0x47f0e785eaba72ac},
  507|       |      {0xb3f4e093db73a093, 0x59ed216765690f57},
  508|       |      {0xe0f218b8d25088b8, 0x306869c13ec3532d},
  509|       |      {0x8c974f7383725573, 0x1e414218c73a13fc},
  510|       |      {0xafbd2350644eeacf, 0xe5d1929ef90898fb},
  511|       |      {0xdbac6c247d62a583, 0xdf45f746b74abf3a},
  512|       |      {0x894bc396ce5da772, 0x6b8bba8c328eb784},
  513|       |      {0xab9eb47c81f5114f, 0x066ea92f3f326565},
  514|       |      {0xd686619ba27255a2, 0xc80a537b0efefebe},
  515|       |      {0x8613fd0145877585, 0xbd06742ce95f5f37},
  516|       |      {0xa798fc4196e952e7, 0x2c48113823b73705},
  517|       |      {0xd17f3b51fca3a7a0, 0xf75a15862ca504c6},
  518|       |      {0x82ef85133de648c4, 0x9a984d73dbe722fc},
  519|       |      {0xa3ab66580d5fdaf5, 0xc13e60d0d2e0ebbb},
  520|       |      {0xcc963fee10b7d1b3, 0x318df905079926a9},
  521|       |      {0xffbbcfe994e5c61f, 0xfdf17746497f7053},
  522|       |      {0x9fd561f1fd0f9bd3, 0xfeb6ea8bedefa634},
  523|       |      {0xc7caba6e7c5382c8, 0xfe64a52ee96b8fc1},
  524|       |      {0xf9bd690a1b68637b, 0x3dfdce7aa3c673b1},
  525|       |      {0x9c1661a651213e2d, 0x06bea10ca65c084f},
  526|       |      {0xc31bfa0fe5698db8, 0x486e494fcff30a63},
  527|       |      {0xf3e2f893dec3f126, 0x5a89dba3c3efccfb},
  528|       |      {0x986ddb5c6b3a76b7, 0xf89629465a75e01d},
  529|       |      {0xbe89523386091465, 0xf6bbb397f1135824},
  530|       |      {0xee2ba6c0678b597f, 0x746aa07ded582e2d},
  531|       |      {0x94db483840b717ef, 0xa8c2a44eb4571cdd},
  532|       |      {0xba121a4650e4ddeb, 0x92f34d62616ce414},
  533|       |      {0xe896a0d7e51e1566, 0x77b020baf9c81d18},
  534|       |      {0x915e2486ef32cd60, 0x0ace1474dc1d122f},
  535|       |      {0xb5b5ada8aaff80b8, 0x0d819992132456bb},
  536|       |      {0xe3231912d5bf60e6, 0x10e1fff697ed6c6a},
  537|       |      {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},
  538|       |      {0xb1736b96b6fd83b3, 0xbd308ff8a6b17cb3},
  539|       |      {0xddd0467c64bce4a0, 0xac7cb3f6d05ddbdf},
  540|       |      {0x8aa22c0dbef60ee4, 0x6bcdf07a423aa96c},
  541|       |      {0xad4ab7112eb3929d, 0x86c16c98d2c953c7},
  542|       |      {0xd89d64d57a607744, 0xe871c7bf077ba8b8},
  543|       |      {0x87625f056c7c4a8b, 0x11471cd764ad4973},
  544|       |      {0xa93af6c6c79b5d2d, 0xd598e40d3dd89bd0},
  545|       |      {0xd389b47879823479, 0x4aff1d108d4ec2c4},
  546|       |      {0x843610cb4bf160cb, 0xcedf722a585139bb},
  547|       |      {0xa54394fe1eedb8fe, 0xc2974eb4ee658829},
  548|       |      {0xce947a3da6a9273e, 0x733d226229feea33},
  549|       |      {0x811ccc668829b887, 0x0806357d5a3f5260},
  550|       |      {0xa163ff802a3426a8, 0xca07c2dcb0cf26f8},
  551|       |      {0xc9bcff6034c13052, 0xfc89b393dd02f0b6},
  552|       |      {0xfc2c3f3841f17c67, 0xbbac2078d443ace3},
  553|       |      {0x9d9ba7832936edc0, 0xd54b944b84aa4c0e},
  554|       |      {0xc5029163f384a931, 0x0a9e795e65d4df12},
  555|       |      {0xf64335bcf065d37d, 0x4d4617b5ff4a16d6},
  556|       |      {0x99ea0196163fa42e, 0x504bced1bf8e4e46},
  557|       |      {0xc06481fb9bcf8d39, 0xe45ec2862f71e1d7},
  558|       |      {0xf07da27a82c37088, 0x5d767327bb4e5a4d},
  559|       |      {0x964e858c91ba2655, 0x3a6a07f8d510f870},
  560|       |      {0xbbe226efb628afea, 0x890489f70a55368c},
  561|       |      {0xeadab0aba3b2dbe5, 0x2b45ac74ccea842f},
  562|       |      {0x92c8ae6b464fc96f, 0x3b0b8bc90012929e},
  563|       |      {0xb77ada0617e3bbcb, 0x09ce6ebb40173745},
  564|       |      {0xe55990879ddcaabd, 0xcc420a6a101d0516},
  565|       |      {0x8f57fa54c2a9eab6, 0x9fa946824a12232e},
  566|       |      {0xb32df8e9f3546564, 0x47939822dc96abfa},
  567|       |      {0xdff9772470297ebd, 0x59787e2b93bc56f8},
  568|       |      {0x8bfbea76c619ef36, 0x57eb4edb3c55b65b},
  569|       |      {0xaefae51477a06b03, 0xede622920b6b23f2},
  570|       |      {0xdab99e59958885c4, 0xe95fab368e45ecee},
  571|       |      {0x88b402f7fd75539b, 0x11dbcb0218ebb415},
  572|       |      {0xaae103b5fcd2a881, 0xd652bdc29f26a11a},
  573|       |      {0xd59944a37c0752a2, 0x4be76d3346f04960},
  574|       |      {0x857fcae62d8493a5, 0x6f70a4400c562ddc},
  575|       |      {0xa6dfbd9fb8e5b88e, 0xcb4ccd500f6bb953},
  576|       |      {0xd097ad07a71f26b2, 0x7e2000a41346a7a8},
  577|       |      {0x825ecc24c873782f, 0x8ed400668c0c28c9},
  578|       |      {0xa2f67f2dfa90563b, 0x728900802f0f32fb},
  579|       |      {0xcbb41ef979346bca, 0x4f2b40a03ad2ffba},
  580|       |      {0xfea126b7d78186bc, 0xe2f610c84987bfa9},
  581|       |      {0x9f24b832e6b0f436, 0x0dd9ca7d2df4d7ca},
  582|       |      {0xc6ede63fa05d3143, 0x91503d1c79720dbc},
  583|       |      {0xf8a95fcf88747d94, 0x75a44c6397ce912b},
  584|       |      {0x9b69dbe1b548ce7c, 0xc986afbe3ee11abb},
  585|       |      {0xc24452da229b021b, 0xfbe85badce996169},
  586|       |      {0xf2d56790ab41c2a2, 0xfae27299423fb9c4},
  587|       |      {0x97c560ba6b0919a5, 0xdccd879fc967d41b},
  588|       |      {0xbdb6b8e905cb600f, 0x5400e987bbc1c921},
  589|       |      {0xed246723473e3813, 0x290123e9aab23b69},
  590|       |      {0x9436c0760c86e30b, 0xf9a0b6720aaf6522},
  591|       |      {0xb94470938fa89bce, 0xf808e40e8d5b3e6a},
  592|       |      {0xe7958cb87392c2c2, 0xb60b1d1230b20e05},
  593|       |      {0x90bd77f3483bb9b9, 0xb1c6f22b5e6f48c3},
  594|       |      {0xb4ecd5f01a4aa828, 0x1e38aeb6360b1af4},
  595|       |      {0xe2280b6c20dd5232, 0x25c6da63c38de1b1},
  596|       |      {0x8d590723948a535f, 0x579c487e5a38ad0f},
  597|       |      {0xb0af48ec79ace837, 0x2d835a9df0c6d852},
  598|       |      {0xdcdb1b2798182244, 0xf8e431456cf88e66},
  599|       |      {0x8a08f0f8bf0f156b, 0x1b8e9ecb641b5900},
  600|       |      {0xac8b2d36eed2dac5, 0xe272467e3d222f40},
  601|       |      {0xd7adf884aa879177, 0x5b0ed81dcc6abb10},
  602|       |      {0x86ccbb52ea94baea, 0x98e947129fc2b4ea},
  603|       |      {0xa87fea27a539e9a5, 0x3f2398d747b36225},
  604|       |      {0xd29fe4b18e88640e, 0x8eec7f0d19a03aae},
  605|       |      {0x83a3eeeef9153e89, 0x1953cf68300424ad},
  606|       |      {0xa48ceaaab75a8e2b, 0x5fa8c3423c052dd8},
  607|       |      {0xcdb02555653131b6, 0x3792f412cb06794e},
  608|       |      {0x808e17555f3ebf11, 0xe2bbd88bbee40bd1},
  609|       |      {0xa0b19d2ab70e6ed6, 0x5b6aceaeae9d0ec5},
  610|       |      {0xc8de047564d20a8b, 0xf245825a5a445276},
  611|       |      {0xfb158592be068d2e, 0xeed6e2f0f0d56713},
  612|       |      {0x9ced737bb6c4183d, 0x55464dd69685606c},
  613|       |      {0xc428d05aa4751e4c, 0xaa97e14c3c26b887},
  614|       |      {0xf53304714d9265df, 0xd53dd99f4b3066a9},
  615|       |      {0x993fe2c6d07b7fab, 0xe546a8038efe402a},
  616|       |      {0xbf8fdb78849a5f96, 0xde98520472bdd034},
  617|       |      {0xef73d256a5c0f77c, 0x963e66858f6d4441},
  618|       |      {0x95a8637627989aad, 0xdde7001379a44aa9},
  619|       |      {0xbb127c53b17ec159, 0x5560c018580d5d53},
  620|       |      {0xe9d71b689dde71af, 0xaab8f01e6e10b4a7},
  621|       |      {0x9226712162ab070d, 0xcab3961304ca70e9},
  622|       |      {0xb6b00d69bb55c8d1, 0x3d607b97c5fd0d23},
  623|       |      {0xe45c10c42a2b3b05, 0x8cb89a7db77c506b},
  624|       |      {0x8eb98a7a9a5b04e3, 0x77f3608e92adb243},
  625|       |      {0xb267ed1940f1c61c, 0x55f038b237591ed4},
  626|       |      {0xdf01e85f912e37a3, 0x6b6c46dec52f6689},
  627|       |      {0x8b61313bbabce2c6, 0x2323ac4b3b3da016},
  628|       |      {0xae397d8aa96c1b77, 0xabec975e0a0d081b},
  629|       |      {0xd9c7dced53c72255, 0x96e7bd358c904a22},
  630|       |      {0x881cea14545c7575, 0x7e50d64177da2e55},
  631|       |      {0xaa242499697392d2, 0xdde50bd1d5d0b9ea},
  632|       |      {0xd4ad2dbfc3d07787, 0x955e4ec64b44e865},
  633|       |      {0x84ec3c97da624ab4, 0xbd5af13bef0b113f},
  634|       |      {0xa6274bbdd0fadd61, 0xecb1ad8aeacdd58f},
  635|       |      {0xcfb11ead453994ba, 0x67de18eda5814af3},
  636|       |      {0x81ceb32c4b43fcf4, 0x80eacf948770ced8},
  637|       |      {0xa2425ff75e14fc31, 0xa1258379a94d028e},
  638|       |      {0xcad2f7f5359a3b3e, 0x096ee45813a04331},
  639|       |      {0xfd87b5f28300ca0d, 0x8bca9d6e188853fd},
  640|       |      {0x9e74d1b791e07e48, 0x775ea264cf55347e},
  641|       |      {0xc612062576589dda, 0x95364afe032a819e},
  642|       |      {0xf79687aed3eec551, 0x3a83ddbd83f52205},
  643|       |      {0x9abe14cd44753b52, 0xc4926a9672793543},
  644|       |      {0xc16d9a0095928a27, 0x75b7053c0f178294},
  645|       |      {0xf1c90080baf72cb1, 0x5324c68b12dd6339},
  646|       |      {0x971da05074da7bee, 0xd3f6fc16ebca5e04},
  647|       |      {0xbce5086492111aea, 0x88f4bb1ca6bcf585},
  648|       |      {0xec1e4a7db69561a5, 0x2b31e9e3d06c32e6},
  649|       |      {0x9392ee8e921d5d07, 0x3aff322e62439fd0},
  650|       |      {0xb877aa3236a4b449, 0x09befeb9fad487c3},
  651|       |      {0xe69594bec44de15b, 0x4c2ebe687989a9b4},
  652|       |      {0x901d7cf73ab0acd9, 0x0f9d37014bf60a11},
  653|       |      {0xb424dc35095cd80f, 0x538484c19ef38c95},
  654|       |      {0xe12e13424bb40e13, 0x2865a5f206b06fba},
  655|       |      {0x8cbccc096f5088cb, 0xf93f87b7442e45d4},
  656|       |      {0xafebff0bcb24aafe, 0xf78f69a51539d749},
  657|       |      {0xdbe6fecebdedd5be, 0xb573440e5a884d1c},
  658|       |      {0x89705f4136b4a597, 0x31680a88f8953031},
  659|       |      {0xabcc77118461cefc, 0xfdc20d2b36ba7c3e},
  660|       |      {0xd6bf94d5e57a42bc, 0x3d32907604691b4d},
  661|       |      {0x8637bd05af6c69b5, 0xa63f9a49c2c1b110},
  662|       |      {0xa7c5ac471b478423, 0x0fcf80dc33721d54},
  663|       |      {0xd1b71758e219652b, 0xd3c36113404ea4a9},
  664|       |      {0x83126e978d4fdf3b, 0x645a1cac083126ea},
  665|       |      {0xa3d70a3d70a3d70a, 0x3d70a3d70a3d70a4},
  666|       |      {0xcccccccccccccccc, 0xcccccccccccccccd},
  667|       |      {0x8000000000000000, 0x0000000000000000},
  668|       |      {0xa000000000000000, 0x0000000000000000},
  669|       |      {0xc800000000000000, 0x0000000000000000},
  670|       |      {0xfa00000000000000, 0x0000000000000000},
  671|       |      {0x9c40000000000000, 0x0000000000000000},
  672|       |      {0xc350000000000000, 0x0000000000000000},
  673|       |      {0xf424000000000000, 0x0000000000000000},
  674|       |      {0x9896800000000000, 0x0000000000000000},
  675|       |      {0xbebc200000000000, 0x0000000000000000},
  676|       |      {0xee6b280000000000, 0x0000000000000000},
  677|       |      {0x9502f90000000000, 0x0000000000000000},
  678|       |      {0xba43b74000000000, 0x0000000000000000},
  679|       |      {0xe8d4a51000000000, 0x0000000000000000},
  680|       |      {0x9184e72a00000000, 0x0000000000000000},
  681|       |      {0xb5e620f480000000, 0x0000000000000000},
  682|       |      {0xe35fa931a0000000, 0x0000000000000000},
  683|       |      {0x8e1bc9bf04000000, 0x0000000000000000},
  684|       |      {0xb1a2bc2ec5000000, 0x0000000000000000},
  685|       |      {0xde0b6b3a76400000, 0x0000000000000000},
  686|       |      {0x8ac7230489e80000, 0x0000000000000000},
  687|       |      {0xad78ebc5ac620000, 0x0000000000000000},
  688|       |      {0xd8d726b7177a8000, 0x0000000000000000},
  689|       |      {0x878678326eac9000, 0x0000000000000000},
  690|       |      {0xa968163f0a57b400, 0x0000000000000000},
  691|       |      {0xd3c21bcecceda100, 0x0000000000000000},
  692|       |      {0x84595161401484a0, 0x0000000000000000},
  693|       |      {0xa56fa5b99019a5c8, 0x0000000000000000},
  694|       |      {0xcecb8f27f4200f3a, 0x0000000000000000},
  695|       |      {0x813f3978f8940984, 0x4000000000000000},
  696|       |      {0xa18f07d736b90be5, 0x5000000000000000},
  697|       |      {0xc9f2c9cd04674ede, 0xa400000000000000},
  698|       |      {0xfc6f7c4045812296, 0x4d00000000000000},
  699|       |      {0x9dc5ada82b70b59d, 0xf020000000000000},
  700|       |      {0xc5371912364ce305, 0x6c28000000000000},
  701|       |      {0xf684df56c3e01bc6, 0xc732000000000000},
  702|       |      {0x9a130b963a6c115c, 0x3c7f400000000000},
  703|       |      {0xc097ce7bc90715b3, 0x4b9f100000000000},
  704|       |      {0xf0bdc21abb48db20, 0x1e86d40000000000},
  705|       |      {0x96769950b50d88f4, 0x1314448000000000},
  706|       |      {0xbc143fa4e250eb31, 0x17d955a000000000},
  707|       |      {0xeb194f8e1ae525fd, 0x5dcfab0800000000},
  708|       |      {0x92efd1b8d0cf37be, 0x5aa1cae500000000},
  709|       |      {0xb7abc627050305ad, 0xf14a3d9e40000000},
  710|       |      {0xe596b7b0c643c719, 0x6d9ccd05d0000000},
  711|       |      {0x8f7e32ce7bea5c6f, 0xe4820023a2000000},
  712|       |      {0xb35dbf821ae4f38b, 0xdda2802c8a800000},
  713|       |      {0xe0352f62a19e306e, 0xd50b2037ad200000},
  714|       |      {0x8c213d9da502de45, 0x4526f422cc340000},
  715|       |      {0xaf298d050e4395d6, 0x9670b12b7f410000},
  716|       |      {0xdaf3f04651d47b4c, 0x3c0cdd765f114000},
  717|       |      {0x88d8762bf324cd0f, 0xa5880a69fb6ac800},
  718|       |      {0xab0e93b6efee0053, 0x8eea0d047a457a00},
  719|       |      {0xd5d238a4abe98068, 0x72a4904598d6d880},
  720|       |      {0x85a36366eb71f041, 0x47a6da2b7f864750},
  721|       |      {0xa70c3c40a64e6c51, 0x999090b65f67d924},
  722|       |      {0xd0cf4b50cfe20765, 0xfff4b4e3f741cf6d},
  723|       |      {0x82818f1281ed449f, 0xbff8f10e7a8921a5},
  724|       |      {0xa321f2d7226895c7, 0xaff72d52192b6a0e},
  725|       |      {0xcbea6f8ceb02bb39, 0x9bf4f8a69f764491},
  726|       |      {0xfee50b7025c36a08, 0x02f236d04753d5b5},
  727|       |      {0x9f4f2726179a2245, 0x01d762422c946591},
  728|       |      {0xc722f0ef9d80aad6, 0x424d3ad2b7b97ef6},
  729|       |      {0xf8ebad2b84e0d58b, 0xd2e0898765a7deb3},
  730|       |      {0x9b934c3b330c8577, 0x63cc55f49f88eb30},
  731|       |      {0xc2781f49ffcfa6d5, 0x3cbf6b71c76b25fc},
  732|       |      {0xf316271c7fc3908a, 0x8bef464e3945ef7b},
  733|       |      {0x97edd871cfda3a56, 0x97758bf0e3cbb5ad},
  734|       |      {0xbde94e8e43d0c8ec, 0x3d52eeed1cbea318},
  735|       |      {0xed63a231d4c4fb27, 0x4ca7aaa863ee4bde},
  736|       |      {0x945e455f24fb1cf8, 0x8fe8caa93e74ef6b},
  737|       |      {0xb975d6b6ee39e436, 0xb3e2fd538e122b45},
  738|       |      {0xe7d34c64a9c85d44, 0x60dbbca87196b617},
  739|       |      {0x90e40fbeea1d3a4a, 0xbc8955e946fe31ce},
  740|       |      {0xb51d13aea4a488dd, 0x6babab6398bdbe42},
  741|       |      {0xe264589a4dcdab14, 0xc696963c7eed2dd2},
  742|       |      {0x8d7eb76070a08aec, 0xfc1e1de5cf543ca3},
  743|       |      {0xb0de65388cc8ada8, 0x3b25a55f43294bcc},
  744|       |      {0xdd15fe86affad912, 0x49ef0eb713f39ebf},
  745|       |      {0x8a2dbf142dfcc7ab, 0x6e3569326c784338},
  746|       |      {0xacb92ed9397bf996, 0x49c2c37f07965405},
  747|       |      {0xd7e77a8f87daf7fb, 0xdc33745ec97be907},
  748|       |      {0x86f0ac99b4e8dafd, 0x69a028bb3ded71a4},
  749|       |      {0xa8acd7c0222311bc, 0xc40832ea0d68ce0d},
  750|       |      {0xd2d80db02aabd62b, 0xf50a3fa490c30191},
  751|       |      {0x83c7088e1aab65db, 0x792667c6da79e0fb},
  752|       |      {0xa4b8cab1a1563f52, 0x577001b891185939},
  753|       |      {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87},
  754|       |      {0x80b05e5ac60b6178, 0x544f8158315b05b5},
  755|       |      {0xa0dc75f1778e39d6, 0x696361ae3db1c722},
  756|       |      {0xc913936dd571c84c, 0x03bc3a19cd1e38ea},
  757|       |      {0xfb5878494ace3a5f, 0x04ab48a04065c724},
  758|       |      {0x9d174b2dcec0e47b, 0x62eb0d64283f9c77},
  759|       |      {0xc45d1df942711d9a, 0x3ba5d0bd324f8395},
  760|       |      {0xf5746577930d6500, 0xca8f44ec7ee3647a},
  761|       |      {0x9968bf6abbe85f20, 0x7e998b13cf4e1ecc},
  762|       |      {0xbfc2ef456ae276e8, 0x9e3fedd8c321a67f},
  763|       |      {0xefb3ab16c59b14a2, 0xc5cfe94ef3ea101f},
  764|       |      {0x95d04aee3b80ece5, 0xbba1f1d158724a13},
  765|       |      {0xbb445da9ca61281f, 0x2a8a6e45ae8edc98},
  766|       |      {0xea1575143cf97226, 0xf52d09d71a3293be},
  767|       |      {0x924d692ca61be758, 0x593c2626705f9c57},
  768|       |      {0xb6e0c377cfa2e12e, 0x6f8b2fb00c77836d},
  769|       |      {0xe498f455c38b997a, 0x0b6dfb9c0f956448},
  770|       |      {0x8edf98b59a373fec, 0x4724bd4189bd5ead},
  771|       |      {0xb2977ee300c50fe7, 0x58edec91ec2cb658},
  772|       |      {0xdf3d5e9bc0f653e1, 0x2f2967b66737e3ee},
  773|       |      {0x8b865b215899f46c, 0xbd79e0d20082ee75},
  774|       |      {0xae67f1e9aec07187, 0xecd8590680a3aa12},
  775|       |      {0xda01ee641a708de9, 0xe80e6f4820cc9496},
  776|       |      {0x884134fe908658b2, 0x3109058d147fdcde},
  777|       |      {0xaa51823e34a7eede, 0xbd4b46f0599fd416},
  778|       |      {0xd4e5e2cdc1d1ea96, 0x6c9e18ac7007c91b},
  779|       |      {0x850fadc09923329e, 0x03e2cf6bc604ddb1},
  780|       |      {0xa6539930bf6bff45, 0x84db8346b786151d},
  781|       |      {0xcfe87f7cef46ff16, 0xe612641865679a64},
  782|       |      {0x81f14fae158c5f6e, 0x4fcb7e8f3f60c07f},
  783|       |      {0xa26da3999aef7749, 0xe3be5e330f38f09e},
  784|       |      {0xcb090c8001ab551c, 0x5cadf5bfd3072cc6},
  785|       |      {0xfdcb4fa002162a63, 0x73d9732fc7c8f7f7},
  786|       |      {0x9e9f11c4014dda7e, 0x2867e7fddcdd9afb},
  787|       |      {0xc646d63501a1511d, 0xb281e1fd541501b9},
  788|       |      {0xf7d88bc24209a565, 0x1f225a7ca91a4227},
  789|       |      {0x9ae757596946075f, 0x3375788de9b06959},
  790|       |      {0xc1a12d2fc3978937, 0x0052d6b1641c83af},
  791|       |      {0xf209787bb47d6b84, 0xc0678c5dbd23a49b},
  792|       |      {0x9745eb4d50ce6332, 0xf840b7ba963646e1},
  793|       |      {0xbd176620a501fbff, 0xb650e5a93bc3d899},
  794|       |      {0xec5d3fa8ce427aff, 0xa3e51f138ab4cebf},
  795|       |      {0x93ba47c980e98cdf, 0xc66f336c36b10138},
  796|       |      {0xb8a8d9bbe123f017, 0xb80b0047445d4185},
  797|       |      {0xe6d3102ad96cec1d, 0xa60dc059157491e6},
  798|       |      {0x9043ea1ac7e41392, 0x87c89837ad68db30},
  799|       |      {0xb454e4a179dd1877, 0x29babe4598c311fc},
  800|       |      {0xe16a1dc9d8545e94, 0xf4296dd6fef3d67b},
  801|       |      {0x8ce2529e2734bb1d, 0x1899e4a65f58660d},
  802|       |      {0xb01ae745b101e9e4, 0x5ec05dcff72e7f90},
  803|       |      {0xdc21a1171d42645d, 0x76707543f4fa1f74},
  804|       |      {0x899504ae72497eba, 0x6a06494a791c53a9},
  805|       |      {0xabfa45da0edbde69, 0x0487db9d17636893},
  806|       |      {0xd6f8d7509292d603, 0x45a9d2845d3c42b7},
  807|       |      {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3},
  808|       |      {0xa7f26836f282b732, 0x8e6cac7768d7141f},
  809|       |      {0xd1ef0244af2364ff, 0x3207d795430cd927},
  810|       |      {0x8335616aed761f1f, 0x7f44e6bd49e807b9},
  811|       |      {0xa402b9c5a8d3a6e7, 0x5f16206c9c6209a7},
  812|       |      {0xcd036837130890a1, 0x36dba887c37a8c10},
  813|       |      {0x802221226be55a64, 0xc2494954da2c978a},
  814|       |      {0xa02aa96b06deb0fd, 0xf2db9baa10b7bd6d},
  815|       |      {0xc83553c5c8965d3d, 0x6f92829494e5acc8},
  816|       |      {0xfa42a8b73abbf48c, 0xcb772339ba1f17fa},
  817|       |      {0x9c69a97284b578d7, 0xff2a760414536efc},
  818|       |      {0xc38413cf25e2d70d, 0xfef5138519684abb},
  819|       |      {0xf46518c2ef5b8cd1, 0x7eb258665fc25d6a},
  820|       |      {0x98bf2f79d5993802, 0xef2f773ffbd97a62},
  821|       |      {0xbeeefb584aff8603, 0xaafb550ffacfd8fb},
  822|       |      {0xeeaaba2e5dbf6784, 0x95ba2a53f983cf39},
  823|       |      {0x952ab45cfa97a0b2, 0xdd945a747bf26184},
  824|       |      {0xba756174393d88df, 0x94f971119aeef9e5},
  825|       |      {0xe912b9d1478ceb17, 0x7a37cd5601aab85e},
  826|       |      {0x91abb422ccb812ee, 0xac62e055c10ab33b},
  827|       |      {0xb616a12b7fe617aa, 0x577b986b314d600a},
  828|       |      {0xe39c49765fdf9d94, 0xed5a7e85fda0b80c},
  829|       |      {0x8e41ade9fbebc27d, 0x14588f13be847308},
  830|       |      {0xb1d219647ae6b31c, 0x596eb2d8ae258fc9},
  831|       |      {0xde469fbd99a05fe3, 0x6fca5f8ed9aef3bc},
  832|       |      {0x8aec23d680043bee, 0x25de7bb9480d5855},
  833|       |      {0xada72ccc20054ae9, 0xaf561aa79a10ae6b},
  834|       |      {0xd910f7ff28069da4, 0x1b2ba1518094da05},
  835|       |      {0x87aa9aff79042286, 0x90fb44d2f05d0843},
  836|       |      {0xa99541bf57452b28, 0x353a1607ac744a54},
  837|       |      {0xd3fa922f2d1675f2, 0x42889b8997915ce9},
  838|       |      {0x847c9b5d7c2e09b7, 0x69956135febada12},
  839|       |      {0xa59bc234db398c25, 0x43fab9837e699096},
  840|       |      {0xcf02b2c21207ef2e, 0x94f967e45e03f4bc},
  841|       |      {0x8161afb94b44f57d, 0x1d1be0eebac278f6},
  842|       |      {0xa1ba1ba79e1632dc, 0x6462d92a69731733},
  843|       |      {0xca28a291859bbf93, 0x7d7b8f7503cfdcff},
  844|       |      {0xfcb2cb35e702af78, 0x5cda735244c3d43f},
  845|       |      {0x9defbf01b061adab, 0x3a0888136afa64a8},
  846|       |      {0xc56baec21c7a1916, 0x088aaa1845b8fdd1},
  847|       |      {0xf6c69a72a3989f5b, 0x8aad549e57273d46},
  848|       |      {0x9a3c2087a63f6399, 0x36ac54e2f678864c},
  849|       |      {0xc0cb28a98fcf3c7f, 0x84576a1bb416a7de},
  850|       |      {0xf0fdf2d3f3c30b9f, 0x656d44a2a11c51d6},
  851|       |      {0x969eb7c47859e743, 0x9f644ae5a4b1b326},
  852|       |      {0xbc4665b596706114, 0x873d5d9f0dde1fef},
  853|       |      {0xeb57ff22fc0c7959, 0xa90cb506d155a7eb},
  854|       |      {0x9316ff75dd87cbd8, 0x09a7f12442d588f3},
  855|       |      {0xb7dcbf5354e9bece, 0x0c11ed6d538aeb30},
  856|       |      {0xe5d3ef282a242e81, 0x8f1668c8a86da5fb},
  857|       |      {0x8fa475791a569d10, 0xf96e017d694487bd},
  858|       |      {0xb38d92d760ec4455, 0x37c981dcc395a9ad},
  859|       |      {0xe070f78d3927556a, 0x85bbe253f47b1418},
  860|       |      {0x8c469ab843b89562, 0x93956d7478ccec8f},
  861|       |      {0xaf58416654a6babb, 0x387ac8d1970027b3},
  862|       |      {0xdb2e51bfe9d0696a, 0x06997b05fcc0319f},
  863|       |      {0x88fcf317f22241e2, 0x441fece3bdf81f04},
  864|       |      {0xab3c2fddeeaad25a, 0xd527e81cad7626c4},
  865|       |      {0xd60b3bd56a5586f1, 0x8a71e223d8d3b075},
  866|       |      {0x85c7056562757456, 0xf6872d5667844e4a},
  867|       |      {0xa738c6bebb12d16c, 0xb428f8ac016561dc},
  868|       |      {0xd106f86e69d785c7, 0xe13336d701beba53},
  869|       |      {0x82a45b450226b39c, 0xecc0024661173474},
  870|       |      {0xa34d721642b06084, 0x27f002d7f95d0191},
  871|       |      {0xcc20ce9bd35c78a5, 0x31ec038df7b441f5},
  872|       |      {0xff290242c83396ce, 0x7e67047175a15272},
  873|       |      {0x9f79a169bd203e41, 0x0f0062c6e984d387},
  874|       |      {0xc75809c42c684dd1, 0x52c07b78a3e60869},
  875|       |      {0xf92e0c3537826145, 0xa7709a56ccdf8a83},
  876|       |      {0x9bbcc7a142b17ccb, 0x88a66076400bb692},
  877|       |      {0xc2abf989935ddbfe, 0x6acff893d00ea436},
  878|       |      {0xf356f7ebf83552fe, 0x0583f6b8c4124d44},
  879|       |      {0x98165af37b2153de, 0xc3727a337a8b704b},
  880|       |      {0xbe1bf1b059e9a8d6, 0x744f18c0592e4c5d},
  881|       |      {0xeda2ee1c7064130c, 0x1162def06f79df74},
  882|       |      {0x9485d4d1c63e8be7, 0x8addcb5645ac2ba9},
  883|       |      {0xb9a74a0637ce2ee1, 0x6d953e2bd7173693},
  884|       |      {0xe8111c87c5c1ba99, 0xc8fa8db6ccdd0438},
  885|       |      {0x910ab1d4db9914a0, 0x1d9c9892400a22a3},
  886|       |      {0xb54d5e4a127f59c8, 0x2503beb6d00cab4c},
  887|       |      {0xe2a0b5dc971f303a, 0x2e44ae64840fd61e},
  888|       |      {0x8da471a9de737e24, 0x5ceaecfed289e5d3},
  889|       |      {0xb10d8e1456105dad, 0x7425a83e872c5f48},
  890|       |      {0xdd50f1996b947518, 0xd12f124e28f7771a},
  891|       |      {0x8a5296ffe33cc92f, 0x82bd6b70d99aaa70},
  892|       |      {0xace73cbfdc0bfb7b, 0x636cc64d1001550c},
  893|       |      {0xd8210befd30efa5a, 0x3c47f7e05401aa4f},
  894|       |      {0x8714a775e3e95c78, 0x65acfaec34810a72},
  895|       |      {0xa8d9d1535ce3b396, 0x7f1839a741a14d0e},
  896|       |      {0xd31045a8341ca07c, 0x1ede48111209a051},
  897|       |      {0x83ea2b892091e44d, 0x934aed0aab460433},
  898|       |      {0xa4e4b66b68b65d60, 0xf81da84d56178540},
  899|       |      {0xce1de40642e3f4b9, 0x36251260ab9d668f},
  900|       |      {0x80d2ae83e9ce78f3, 0xc1d72b7c6b42601a},
  901|       |      {0xa1075a24e4421730, 0xb24cf65b8612f820},
  902|       |      {0xc94930ae1d529cfc, 0xdee033f26797b628},
  903|       |      {0xfb9b7cd9a4a7443c, 0x169840ef017da3b2},
  904|       |      {0x9d412e0806e88aa5, 0x8e1f289560ee864f},
  905|       |      {0xc491798a08a2ad4e, 0xf1a6f2bab92a27e3},
  906|       |      {0xf5b5d7ec8acb58a2, 0xae10af696774b1dc},
  907|       |      {0x9991a6f3d6bf1765, 0xacca6da1e0a8ef2a},
  908|       |      {0xbff610b0cc6edd3f, 0x17fd090a58d32af4},
  909|       |      {0xeff394dcff8a948e, 0xddfc4b4cef07f5b1},
  910|       |      {0x95f83d0a1fb69cd9, 0x4abdaf101564f98f},
  911|       |      {0xbb764c4ca7a4440f, 0x9d6d1ad41abe37f2},
  912|       |      {0xea53df5fd18d5513, 0x84c86189216dc5ee},
  913|       |      {0x92746b9be2f8552c, 0x32fd3cf5b4e49bb5},
  914|       |      {0xb7118682dbb66a77, 0x3fbc8c33221dc2a2},
  915|       |      {0xe4d5e82392a40515, 0x0fabaf3feaa5334b},
  916|       |      {0x8f05b1163ba6832d, 0x29cb4d87f2a7400f},
  917|       |      {0xb2c71d5bca9023f8, 0x743e20e9ef511013},
  918|       |      {0xdf78e4b2bd342cf6, 0x914da9246b255417},
  919|       |      {0x8bab8eefb6409c1a, 0x1ad089b6c2f7548f},
  920|       |      {0xae9672aba3d0c320, 0xa184ac2473b529b2},
  921|       |      {0xda3c0f568cc4f3e8, 0xc9e5d72d90a2741f},
  922|       |      {0x8865899617fb1871, 0x7e2fa67c7a658893},
  923|       |      {0xaa7eebfb9df9de8d, 0xddbb901b98feeab8},
  924|       |      {0xd51ea6fa85785631, 0x552a74227f3ea566},
  925|       |      {0x8533285c936b35de, 0xd53a88958f872760},
  926|       |      {0xa67ff273b8460356, 0x8a892abaf368f138},
  927|       |      {0xd01fef10a657842c, 0x2d2b7569b0432d86},
  928|       |      {0x8213f56a67f6b29b, 0x9c3b29620e29fc74},
  929|       |      {0xa298f2c501f45f42, 0x8349f3ba91b47b90},
  930|       |      {0xcb3f2f7642717713, 0x241c70a936219a74},
  931|       |      {0xfe0efb53d30dd4d7, 0xed238cd383aa0111},
  932|       |      {0x9ec95d1463e8a506, 0xf4363804324a40ab},
  933|       |      {0xc67bb4597ce2ce48, 0xb143c6053edcd0d6},
  934|       |      {0xf81aa16fdc1b81da, 0xdd94b7868e94050b},
  935|       |      {0x9b10a4e5e9913128, 0xca7cf2b4191c8327},
  936|       |      {0xc1d4ce1f63f57d72, 0xfd1c2f611f63a3f1},
  937|       |      {0xf24a01a73cf2dccf, 0xbc633b39673c8ced},
  938|       |      {0x976e41088617ca01, 0xd5be0503e085d814},
  939|       |      {0xbd49d14aa79dbc82, 0x4b2d8644d8a74e19},
  940|       |      {0xec9c459d51852ba2, 0xddf8e7d60ed1219f},
  941|       |      {0x93e1ab8252f33b45, 0xcabb90e5c942b504},
  942|       |      {0xb8da1662e7b00a17, 0x3d6a751f3b936244},
  943|       |      {0xe7109bfba19c0c9d, 0x0cc512670a783ad5},
  944|       |      {0x906a617d450187e2, 0x27fb2b80668b24c6},
  945|       |      {0xb484f9dc9641e9da, 0xb1f9f660802dedf7},
  946|       |      {0xe1a63853bbd26451, 0x5e7873f8a0396974},
  947|       |      {0x8d07e33455637eb2, 0xdb0b487b6423e1e9},
  948|       |      {0xb049dc016abc5e5f, 0x91ce1a9a3d2cda63},
  949|       |      {0xdc5c5301c56b75f7, 0x7641a140cc7810fc},
  950|       |      {0x89b9b3e11b6329ba, 0xa9e904c87fcb0a9e},
  951|       |      {0xac2820d9623bf429, 0x546345fa9fbdcd45},
  952|       |      {0xd732290fbacaf133, 0xa97c177947ad4096},
  953|       |      {0x867f59a9d4bed6c0, 0x49ed8eabcccc485e},
  954|       |      {0xa81f301449ee8c70, 0x5c68f256bfff5a75},
  955|       |      {0xd226fc195c6a2f8c, 0x73832eec6fff3112},
  956|       |      {0x83585d8fd9c25db7, 0xc831fd53c5ff7eac},
  957|       |      {0xa42e74f3d032f525, 0xba3e7ca8b77f5e56},
  958|       |      {0xcd3a1230c43fb26f, 0x28ce1bd2e55f35ec},
  959|       |      {0x80444b5e7aa7cf85, 0x7980d163cf5b81b4},
  960|       |      {0xa0555e361951c366, 0xd7e105bcc3326220},
  961|       |      {0xc86ab5c39fa63440, 0x8dd9472bf3fefaa8},
  962|       |      {0xfa856334878fc150, 0xb14f98f6f0feb952},
  963|       |      {0x9c935e00d4b9d8d2, 0x6ed1bf9a569f33d4},
  964|       |      {0xc3b8358109e84f07, 0x0a862f80ec4700c9},
  965|       |      {0xf4a642e14c6262c8, 0xcd27bb612758c0fb},
  966|       |      {0x98e7e9cccfbd7dbd, 0x8038d51cb897789d},
  967|       |      {0xbf21e44003acdd2c, 0xe0470a63e6bd56c4},
  968|       |      {0xeeea5d5004981478, 0x1858ccfce06cac75},
  969|       |      {0x95527a5202df0ccb, 0x0f37801e0c43ebc9},
  970|       |      {0xbaa718e68396cffd, 0xd30560258f54e6bb},
  971|       |      {0xe950df20247c83fd, 0x47c6b82ef32a206a},
  972|       |      {0x91d28b7416cdd27e, 0x4cdc331d57fa5442},
  973|       |      {0xb6472e511c81471d, 0xe0133fe4adf8e953},
  974|       |      {0xe3d8f9e563a198e5, 0x58180fddd97723a7},
  975|       |      {0x8e679c2f5e44ff8f, 0x570f09eaa7ea7649},
  976|       |      {0xb201833b35d63f73, 0x2cd2cc6551e513db},
  977|       |      {0xde81e40a034bcf4f, 0xf8077f7ea65e58d2},
  978|       |      {0x8b112e86420f6191, 0xfb04afaf27faf783},
  979|       |      {0xadd57a27d29339f6, 0x79c5db9af1f9b564},
  980|       |      {0xd94ad8b1c7380874, 0x18375281ae7822bd},
  981|       |      {0x87cec76f1c830548, 0x8f2293910d0b15b6},
  982|       |      {0xa9c2794ae3a3c69a, 0xb2eb3875504ddb23},
  983|       |      {0xd433179d9c8cb841, 0x5fa60692a46151ec},
  984|       |      {0x849feec281d7f328, 0xdbc7c41ba6bcd334},
  985|       |      {0xa5c7ea73224deff3, 0x12b9b522906c0801},
  986|       |      {0xcf39e50feae16bef, 0xd768226b34870a01},
  987|       |      {0x81842f29f2cce375, 0xe6a1158300d46641},
  988|       |      {0xa1e53af46f801c53, 0x60495ae3c1097fd1},
  989|       |      {0xca5e89b18b602368, 0x385bb19cb14bdfc5},
  990|       |      {0xfcf62c1dee382c42, 0x46729e03dd9ed7b6},
  991|       |      {0x9e19db92b4e31ba9, 0x6c07a2c26a8346d2},
  992|       |      {0xc5a05277621be293, 0xc7098b7305241886},
  993|       |      {0xf70867153aa2db38, 0xb8cbee4fc66d1ea8},
  994|       |      {0x9a65406d44a5c903, 0x737f74f1dc043329},
  995|       |      {0xc0fe908895cf3b44, 0x505f522e53053ff3},
  996|       |      {0xf13e34aabb430a15, 0x647726b9e7c68ff0},
  997|       |      {0x96c6e0eab509e64d, 0x5eca783430dc19f6},
  998|       |      {0xbc789925624c5fe0, 0xb67d16413d132073},
  999|       |      {0xeb96bf6ebadf77d8, 0xe41c5bd18c57e890},
 1000|       |      {0x933e37a534cbaae7, 0x8e91b962f7b6f15a},
 1001|       |      {0xb80dc58e81fe95a1, 0x723627bbb5a4adb1},
 1002|       |      {0xe61136f2227e3b09, 0xcec3b1aaa30dd91d},
 1003|       |      {0x8fcac257558ee4e6, 0x213a4f0aa5e8a7b2},
 1004|       |      {0xb3bd72ed2af29e1f, 0xa988e2cd4f62d19e},
 1005|       |      {0xe0accfa875af45a7, 0x93eb1b80a33b8606},
 1006|       |      {0x8c6c01c9498d8b88, 0xbc72f130660533c4},
 1007|       |      {0xaf87023b9bf0ee6a, 0xeb8fad7c7f8680b5},
 1008|       |      {0xdb68c2ca82ed2a05, 0xa67398db9f6820e2},
 1009|       |#else
 1010|  1.85k|      {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
 1011|  1.85k|      {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
 1012|  1.85k|      {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},
 1013|  1.85k|      {0x86a8d39ef77164bc, 0xae5dff9c02033198},
 1014|  1.85k|      {0xd98ddaee19068c76, 0x3badd624dd9b0958},
 1015|  1.85k|      {0xafbd2350644eeacf, 0xe5d1929ef90898fb},
 1016|  1.85k|      {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},
 1017|  1.85k|      {0xe55990879ddcaabd, 0xcc420a6a101d0516},
 1018|  1.85k|      {0xb94470938fa89bce, 0xf808e40e8d5b3e6a},
 1019|  1.85k|      {0x95a8637627989aad, 0xdde7001379a44aa9},
 1020|  1.85k|      {0xf1c90080baf72cb1, 0x5324c68b12dd6339},
 1021|  1.85k|      {0xc350000000000000, 0x0000000000000000},
 1022|  1.85k|      {0x9dc5ada82b70b59d, 0xf020000000000000},
 1023|  1.85k|      {0xfee50b7025c36a08, 0x02f236d04753d5b5},
 1024|  1.85k|      {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87},
 1025|  1.85k|      {0xa6539930bf6bff45, 0x84db8346b786151d},
 1026|  1.85k|      {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3},
 1027|  1.85k|      {0xd910f7ff28069da4, 0x1b2ba1518094da05},
 1028|  1.85k|      {0xaf58416654a6babb, 0x387ac8d1970027b3},
 1029|  1.85k|      {0x8da471a9de737e24, 0x5ceaecfed289e5d3},
 1030|  1.85k|      {0xe4d5e82392a40515, 0x0fabaf3feaa5334b},
 1031|  1.85k|      {0xb8da1662e7b00a17, 0x3d6a751f3b936244},
 1032|  1.85k|      {0x95527a5202df0ccb, 0x0f37801e0c43ebc9},
 1033|  1.85k|      {0xf13e34aabb430a15, 0x647726b9e7c68ff0}
 1034|  1.85k|#endif
 1035|  1.85k|    };
 1036|       |
 1037|       |#if FMT_USE_FULL_CACHE_DRAGONBOX
 1038|       |    return pow10_significands[k - float_info<double>::min_k];
 1039|       |#else
 1040|  1.85k|    static constexpr const uint64_t powers_of_5_64[] = {
 1041|  1.85k|        0x0000000000000001, 0x0000000000000005, 0x0000000000000019,
 1042|  1.85k|        0x000000000000007d, 0x0000000000000271, 0x0000000000000c35,
 1043|  1.85k|        0x0000000000003d09, 0x000000000001312d, 0x000000000005f5e1,
 1044|  1.85k|        0x00000000001dcd65, 0x00000000009502f9, 0x0000000002e90edd,
 1045|  1.85k|        0x000000000e8d4a51, 0x0000000048c27395, 0x000000016bcc41e9,
 1046|  1.85k|        0x000000071afd498d, 0x0000002386f26fc1, 0x000000b1a2bc2ec5,
 1047|  1.85k|        0x000003782dace9d9, 0x00001158e460913d, 0x000056bc75e2d631,
 1048|  1.85k|        0x0001b1ae4d6e2ef5, 0x000878678326eac9, 0x002a5a058fc295ed,
 1049|  1.85k|        0x00d3c21bcecceda1, 0x0422ca8b0a00a425, 0x14adf4b7320334b9};
 1050|       |
 1051|  1.85k|    static const int compression_ratio = 27;
 1052|       |
 1053|       |    // Compute base index.
 1054|  1.85k|    int cache_index = (k - float_info<double>::min_k) / compression_ratio;
 1055|  1.85k|    int kb = cache_index * compression_ratio + float_info<double>::min_k;
 1056|  1.85k|    int offset = k - kb;
 1057|       |
 1058|       |    // Get base cache.
 1059|  1.85k|    uint128_fallback base_cache = pow10_significands[cache_index];
 1060|  1.85k|    if (offset == 0) return base_cache;
  ------------------
  |  Branch (1060:9): [True: 47, False: 1.80k]
  ------------------
 1061|       |
 1062|       |    // Compute the required amount of bit-shift.
 1063|  1.80k|    int alpha = floor_log2_pow10(kb + offset) - floor_log2_pow10(kb) - offset;
 1064|  1.80k|    FMT_ASSERT(alpha > 0 && alpha < 64, "shifting error detected");
  ------------------
  |  |  397|  3.60k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:7): [True: 1.80k, False: 0]
  |  |  |  Branch (397:7): [True: 1.80k, False: 0]
  |  |  ------------------
  |  |  398|  1.80k|         ? (void)0                                                          \
  |  |  399|  1.80k|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1065|       |
 1066|       |    // Try to recover the real cache.
 1067|  1.80k|    uint64_t pow5 = powers_of_5_64[offset];
 1068|  1.80k|    uint128_fallback recovered_cache = umul128(base_cache.high(), pow5);
 1069|  1.80k|    uint128_fallback middle_low = umul128(base_cache.low(), pow5);
 1070|       |
 1071|  1.80k|    recovered_cache += middle_low.high();
 1072|       |
 1073|  1.80k|    uint64_t high_to_middle = recovered_cache.high() << (64 - alpha);
 1074|  1.80k|    uint64_t middle_to_low = recovered_cache.low() << (64 - alpha);
 1075|       |
 1076|  1.80k|    recovered_cache =
 1077|  1.80k|        uint128_fallback{(recovered_cache.low() >> alpha) | high_to_middle,
 1078|  1.80k|                         ((middle_low.low() >> alpha) | middle_to_low)};
 1079|  1.80k|    FMT_ASSERT(recovered_cache.low() + 1 != 0, "");
  ------------------
  |  |  397|  1.80k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:6): [True: 1.80k, False: 0]
  |  |  ------------------
  |  |  398|  1.80k|         ? (void)0                                                          \
  |  |  399|  1.80k|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1080|  1.80k|    return {recovered_cache.high(), recovered_cache.low() + 1};
 1081|  1.85k|#endif
 1082|  1.85k|  }
_ZN3fmt3v116detail9dragonbox21remove_trailing_zerosERji:
 1153|    103|FMT_INLINE int remove_trailing_zeros(uint32_t& n, int s = 0) noexcept {
 1154|    103|  FMT_ASSERT(n != 0, "");
  ------------------
  |  |  397|    103|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:6): [True: 103, False: 0]
  |  |  ------------------
  |  |  398|    103|         ? (void)0                                                          \
  |  |  399|    103|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1155|       |  // Modular inverse of 5 (mod 2^32): (mod_inv_5 * 5) mod 2^32 = 1.
 1156|    103|  constexpr uint32_t mod_inv_5 = 0xcccccccd;
 1157|    103|  constexpr uint32_t mod_inv_25 = 0xc28f5c29;  // = mod_inv_5 * mod_inv_5
 1158|       |
 1159|    222|  while (true) {
  ------------------
  |  Branch (1159:10): [Folded - Ignored]
  ------------------
 1160|    222|    auto q = rotr(n * mod_inv_25, 2);
 1161|    222|    if (q > max_value<uint32_t>() / 100) break;
  ------------------
  |  Branch (1161:9): [True: 103, False: 119]
  ------------------
 1162|    119|    n = q;
 1163|    119|    s += 2;
 1164|    119|  }
 1165|    103|  auto q = rotr(n * mod_inv_5, 1);
 1166|    103|  if (q <= max_value<uint32_t>() / 10) {
  ------------------
  |  Branch (1166:7): [True: 23, False: 80]
  ------------------
 1167|     23|    n = q;
 1168|     23|    s |= 1;
 1169|     23|  }
 1170|    103|  return s;
 1171|    103|}
_ZN3fmt3v116detail4rotrEjj:
  177|    325|FMT_CONSTEXPR inline auto rotr(uint32_t n, uint32_t r) noexcept -> uint32_t {
  178|    325|  r &= 31;
  179|    325|  return (n >> r) | (n << (32 - r));
  180|    325|}
_ZN3fmt3v116detail9dragonbox14cache_accessorIdE13compute_deltaERKNS1_16uint128_fallbackEi:
 1101|    779|      -> uint32_t {
 1102|    779|    return static_cast<uint32_t>(cache.high() >> (64 - 1 - beta));
 1103|    779|  }
_ZN3fmt3v116detail9dragonbox14cache_accessorIdE11compute_mulEmRKNS1_16uint128_fallbackE:
 1095|    779|      -> compute_mul_result {
 1096|    779|    auto r = umul192_upper128(u, cache);
 1097|    779|    return {r.high(), r.low() == 0};
 1098|    779|  }
_ZN3fmt3v116detail9dragonbox28divide_by_10_to_kappa_plus_1Em:
  263|    779|inline auto divide_by_10_to_kappa_plus_1(uint64_t n) noexcept -> uint64_t {
  264|       |  // 2361183241434822607 = ceil(2^(64+7)/1000)
  265|    779|  return umul128_upper64(n, 2361183241434822607ull) >> 7;
  266|    779|}
_ZN3fmt3v116detail9dragonbox14cache_accessorIdE18compute_mul_parityEmRKNS1_16uint128_fallbackEi:
 1108|    151|      -> compute_mul_parity_result {
 1109|    151|    FMT_ASSERT(beta >= 1, "");
  ------------------
  |  |  397|    151|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:6): [True: 151, False: 0]
  |  |  ------------------
  |  |  398|    151|         ? (void)0                                                          \
  |  |  399|    151|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1110|    151|    FMT_ASSERT(beta < 64, "");
  ------------------
  |  |  397|    151|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:6): [True: 151, False: 0]
  |  |  ------------------
  |  |  398|    151|         ? (void)0                                                          \
  |  |  399|    151|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1111|       |
 1112|    151|    auto r = umul192_lower128(two_f, cache);
 1113|    151|    return {((r.high() >> (64 - beta)) & 1) != 0,
 1114|    151|            ((r.high() << beta) | (r.low() >> (64 - beta))) == 0};
 1115|    151|  }
_ZN3fmt3v116detail9dragonbox16umul192_lower128EmNS1_16uint128_fallbackE:
  197|    151|    -> uint128_fallback {
  198|    151|  uint64_t high = x * y.high();
  199|    151|  uint128_fallback high_low = umul128(x, y.low());
  200|    151|  return {high + high_low.high(), high_low.low()};
  201|    151|}
_ZN3fmt3v116detail9dragonbox21remove_trailing_zerosERm:
 1174|    500|FMT_INLINE int remove_trailing_zeros(uint64_t& n) noexcept {
 1175|    500|  FMT_ASSERT(n != 0, "");
  ------------------
  |  |  397|    500|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:6): [True: 500, False: 0]
  |  |  ------------------
  |  |  398|    500|         ? (void)0                                                          \
  |  |  399|    500|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1176|       |
 1177|       |  // This magic number is ceil(2^90 / 10^8).
 1178|    500|  constexpr uint64_t magic_number = 12379400392853802749ull;
 1179|    500|  auto nm = umul128(n, magic_number);
 1180|       |
 1181|       |  // Is n is divisible by 10^8?
 1182|    500|  if ((nm.high() & ((1ull << (90 - 64)) - 1)) == 0 && nm.low() < magic_number) {
  ------------------
  |  Branch (1182:7): [True: 128, False: 372]
  |  Branch (1182:55): [True: 103, False: 25]
  ------------------
 1183|       |    // If yes, work with the quotient...
 1184|    103|    auto n32 = static_cast<uint32_t>(nm.high() >> (90 - 64));
 1185|       |    // ... and use the 32 bit variant of the function
 1186|    103|    int s = remove_trailing_zeros(n32, 8);
 1187|    103|    n = n32;
 1188|    103|    return s;
 1189|    103|  }
 1190|       |
 1191|       |  // If n is not divisible by 10^8, work with n itself.
 1192|    397|  constexpr uint64_t mod_inv_5 = 0xcccccccccccccccd;
 1193|    397|  constexpr uint64_t mod_inv_25 = 0x8f5c28f5c28f5c29;  // mod_inv_5 * mod_inv_5
 1194|       |
 1195|    397|  int s = 0;
 1196|    470|  while (true) {
  ------------------
  |  Branch (1196:10): [Folded - Ignored]
  ------------------
 1197|    470|    auto q = rotr(n * mod_inv_25, 2);
 1198|    470|    if (q > max_value<uint64_t>() / 100) break;
  ------------------
  |  Branch (1198:9): [True: 397, False: 73]
  ------------------
 1199|     73|    n = q;
 1200|     73|    s += 2;
 1201|     73|  }
 1202|    397|  auto q = rotr(n * mod_inv_5, 1);
 1203|    397|  if (q <= max_value<uint64_t>() / 10) {
  ------------------
  |  Branch (1203:7): [True: 49, False: 348]
  ------------------
 1204|     49|    n = q;
 1205|     49|    s |= 1;
 1206|     49|  }
 1207|       |
 1208|    397|  return s;
 1209|    500|}
_ZN3fmt3v116detail4rotrEmj:
  181|    867|FMT_CONSTEXPR inline auto rotr(uint64_t n, uint32_t r) noexcept -> uint64_t {
  182|    867|  r &= 63;
  183|    867|  return (n >> r) | (n << (64 - r));
  184|    867|}
_ZN3fmt3v116detail9dragonbox37floor_log10_pow2_minus_log10_4_over_3Ei:
  210|    146|inline auto floor_log10_pow2_minus_log10_4_over_3(int e) noexcept -> int {
  211|    146|  FMT_ASSERT(e <= 2936 && e >= -2985, "too large exponent");
  ------------------
  |  |  397|    292|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:7): [True: 146, False: 0]
  |  |  |  Branch (397:7): [True: 146, False: 0]
  |  |  ------------------
  |  |  398|    146|         ? (void)0                                                          \
  |  |  399|    146|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
  212|    146|  return (e * 631305 - 261663) >> 21;
  213|    146|}
_ZN3fmt3v116detail9dragonbox21shorter_interval_caseIdEENS2_10decimal_fpIT_EEi:
 1213|    146|FMT_INLINE decimal_fp<T> shorter_interval_case(int exponent) noexcept {
 1214|    146|  decimal_fp<T> ret_value;
 1215|       |  // Compute k and beta
 1216|    146|  const int minus_k = floor_log10_pow2_minus_log10_4_over_3(exponent);
 1217|    146|  const int beta = exponent + floor_log2_pow10(-minus_k);
 1218|       |
 1219|       |  // Compute xi and zi
 1220|    146|  using cache_entry_type = typename cache_accessor<T>::cache_entry_type;
 1221|    146|  const cache_entry_type cache = cache_accessor<T>::get_cached_power(-minus_k);
 1222|       |
 1223|    146|  auto xi = cache_accessor<T>::compute_left_endpoint_for_shorter_interval_case(
 1224|    146|      cache, beta);
 1225|    146|  auto zi = cache_accessor<T>::compute_right_endpoint_for_shorter_interval_case(
 1226|    146|      cache, beta);
 1227|       |
 1228|       |  // If the left endpoint is not an integer, increase it
 1229|    146|  if (!is_left_endpoint_integer_shorter_interval<T>(exponent)) ++xi;
  ------------------
  |  Branch (1229:7): [True: 144, False: 2]
  ------------------
 1230|       |
 1231|       |  // Try bigger divisor
 1232|    146|  ret_value.significand = zi / 10;
 1233|       |
 1234|       |  // If succeed, remove trailing zeros if necessary and return
 1235|    146|  if (ret_value.significand * 10 >= xi) {
  ------------------
  |  Branch (1235:7): [True: 102, False: 44]
  ------------------
 1236|    102|    ret_value.exponent = minus_k + 1;
 1237|    102|    ret_value.exponent += remove_trailing_zeros(ret_value.significand);
 1238|    102|    return ret_value;
 1239|    102|  }
 1240|       |
 1241|       |  // Otherwise, compute the round-up of y
 1242|     44|  ret_value.significand =
 1243|     44|      cache_accessor<T>::compute_round_up_for_shorter_interval_case(cache,
 1244|     44|                                                                    beta);
 1245|     44|  ret_value.exponent = minus_k;
 1246|       |
 1247|       |  // When tie occurs, choose one of them according to the rule
 1248|     44|  if (exponent >= float_info<T>::shorter_interval_tie_lower_threshold &&
  ------------------
  |  Branch (1248:7): [True: 20, False: 24]
  ------------------
 1249|     44|      exponent <= float_info<T>::shorter_interval_tie_upper_threshold) {
  ------------------
  |  Branch (1249:7): [True: 1, False: 19]
  ------------------
 1250|      1|    ret_value.significand = ret_value.significand % 2 == 0
  ------------------
  |  Branch (1250:29): [True: 0, False: 1]
  ------------------
 1251|      1|                                ? ret_value.significand
 1252|      1|                                : ret_value.significand - 1;
 1253|     43|  } else if (ret_value.significand < xi) {
  ------------------
  |  Branch (1253:14): [True: 3, False: 40]
  ------------------
 1254|      3|    ++ret_value.significand;
 1255|      3|  }
 1256|     44|  return ret_value;
 1257|    146|}
_ZN3fmt3v116detail9dragonbox14cache_accessorIdE47compute_left_endpoint_for_shorter_interval_caseERKNS1_16uint128_fallbackEi:
 1118|    146|      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
 1119|    146|    return (cache.high() -
 1120|    146|            (cache.high() >> (num_significand_bits<double>() + 2))) >>
 1121|    146|           (64 - num_significand_bits<double>() - 1 - beta);
 1122|    146|  }
_ZN3fmt3v116detail9dragonbox14cache_accessorIdE48compute_right_endpoint_for_shorter_interval_caseERKNS1_16uint128_fallbackEi:
 1125|    146|      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
 1126|    146|    return (cache.high() +
 1127|    146|            (cache.high() >> (num_significand_bits<double>() + 1))) >>
 1128|    146|           (64 - num_significand_bits<double>() - 1 - beta);
 1129|    146|  }
_ZN3fmt3v116detail9dragonbox41is_left_endpoint_integer_shorter_intervalIdEEbi:
 1145|    146|auto is_left_endpoint_integer_shorter_interval(int exponent) noexcept -> bool {
 1146|    146|  const int case_shorter_interval_left_endpoint_lower_threshold = 2;
 1147|    146|  const int case_shorter_interval_left_endpoint_upper_threshold = 3;
 1148|    146|  return exponent >= case_shorter_interval_left_endpoint_lower_threshold &&
  ------------------
  |  Branch (1148:10): [True: 48, False: 98]
  ------------------
 1149|    146|         exponent <= case_shorter_interval_left_endpoint_upper_threshold;
  ------------------
  |  Branch (1149:10): [True: 2, False: 46]
  ------------------
 1150|    146|}
_ZN3fmt3v116detail9dragonbox14cache_accessorIdE42compute_round_up_for_shorter_interval_caseERKNS1_16uint128_fallbackEi:
 1132|     44|      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
 1133|     44|    return ((cache.high() >> (64 - num_significand_bits<double>() - 2 - beta)) +
 1134|     44|            1) /
 1135|     44|           2;
 1136|     44|  }
_ZN3fmt3v116detail9dragonbox38check_divisibility_and_divide_by_pow10ILi2EEEbRj:
  224|    381|auto check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept -> bool {
  225|       |  // The numbers below are chosen such that:
  226|       |  //   1. floor(n/d) = floor(nm / 2^k) where d=10 or d=100,
  227|       |  //   2. nm mod 2^k < m if and only if n is divisible by d,
  228|       |  // where m is magic_number, k is shift_amount
  229|       |  // and d is divisor.
  230|       |  //
  231|       |  // Item 1 is a common technique of replacing division by a constant with
  232|       |  // multiplication, see e.g. "Division by Invariant Integers Using
  233|       |  // Multiplication" by Granlund and Montgomery (1994). magic_number (m) is set
  234|       |  // to ceil(2^k/d) for large enough k.
  235|       |  // The idea for item 2 originates from Schubfach.
  236|    381|  constexpr auto info = div_small_pow10_infos[N - 1];
  237|    381|  FMT_ASSERT(n <= info.divisor * 10, "n is too large");
  ------------------
  |  |  397|    381|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:6): [True: 381, False: 0]
  |  |  ------------------
  |  |  398|    381|         ? (void)0                                                          \
  |  |  399|    381|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
  238|    381|  constexpr uint32_t magic_number =
  239|    381|      (1u << info.shift_amount) / info.divisor + 1;
  240|    381|  n *= magic_number;
  241|    381|  const uint32_t comparison_mask = (1u << info.shift_amount) - 1;
  242|    381|  bool result = (n & comparison_mask) < magic_number;
  243|    381|  n >>= info.shift_amount;
  244|    381|  return result;
  245|    381|}

_ZN3fmt3v1119basic_memory_bufferIcLm500ENS0_6detail9allocatorIcEEEC2ERKS4_:
  821|  2.96k|      : detail::buffer<T>(grow), alloc_(alloc) {
  822|  2.96k|    this->set(store_, SIZE);
  823|  2.96k|    if (detail::is_constant_evaluated()) detail::fill_n(store_, SIZE, T());
  ------------------
  |  Branch (823:9): [Folded - Ignored]
  ------------------
  824|  2.96k|  }
_ZN3fmt3v116detail16abort_fuzzing_ifEb:
  220|    343|FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) {
  221|    343|  ignore_unused(condition);
  222|    343|#ifdef FMT_FUZZ
  223|    343|  if (condition) throw std::runtime_error("fuzzing limit reached");
  ------------------
  |  Branch (223:7): [True: 0, False: 343]
  ------------------
  224|    343|#endif
  225|    343|}
_ZN3fmt3v116detail9max_valueImEET_v:
  395|    867|template <typename T> constexpr auto max_value() -> T {
  396|    867|  return (std::numeric_limits<T>::max)();
  397|    867|}
_ZN3fmt3v1119basic_memory_bufferIcLm500ENS0_6detail9allocatorIcEEED2Ev:
  825|  2.96k|  FMT_CONSTEXPR20 ~basic_memory_buffer() { deallocate(); }
_ZN3fmt3v1119basic_memory_bufferIcLm500ENS0_6detail9allocatorIcEEE10deallocateEv:
  786|  2.96k|  FMT_CONSTEXPR20 void deallocate() {
  787|  2.96k|    T* data = this->data();
  788|  2.96k|    if (data != store_) alloc_.deallocate(data, this->capacity());
  ------------------
  |  Branch (788:9): [True: 0, False: 2.96k]
  ------------------
  789|  2.96k|  }
_ZN3fmt3v116detail16uint128_fallbackC2Emm:
  278|  9.71k|  constexpr uint128_fallback(uint64_t hi, uint64_t lo) : lo_(lo), hi_(hi) {}
_ZNK3fmt3v116detail16uint128_fallback4highEv:
  281|  13.2k|  constexpr auto high() const noexcept -> uint64_t { return hi_; }
_ZNK3fmt3v116detail16uint128_fallback3lowEv:
  282|  14.8k|  constexpr auto low() const noexcept -> uint64_t { return lo_; }
_ZN3fmt3v116detail16uint128_fallbackpLEm:
  359|  3.50k|  FMT_CONSTEXPR20 auto operator+=(uint64_t n) noexcept -> uint128_fallback& {
  360|  3.50k|    if (is_constant_evaluated()) {
  ------------------
  |  Branch (360:9): [Folded - Ignored]
  ------------------
  361|      0|      lo_ += n;
  362|      0|      hi_ += (lo_ < n ? 1 : 0);
  ------------------
  |  Branch (362:15): [True: 0, False: 0]
  ------------------
  363|      0|      return *this;
  364|      0|    }
  365|  3.50k|#if FMT_HAS_BUILTIN(__builtin_addcll) && !defined(__ibmxl__)
  366|  3.50k|    unsigned long long carry;
  367|  3.50k|    lo_ = __builtin_addcll(lo_, n, 0, &carry);
  368|  3.50k|    hi_ += carry;
  369|       |#elif FMT_HAS_BUILTIN(__builtin_ia32_addcarryx_u64) && !defined(__ibmxl__)
  370|       |    unsigned long long result;
  371|       |    auto carry = __builtin_ia32_addcarryx_u64(0, lo_, n, &result);
  372|       |    lo_ = result;
  373|       |    hi_ += carry;
  374|       |#elif defined(_MSC_VER) && defined(_M_X64)
  375|       |    auto carry = _addcarry_u64(0, lo_, n, &lo_);
  376|       |    _addcarry_u64(carry, hi_, 0, &hi_);
  377|       |#else
  378|       |    lo_ += n;
  379|       |    hi_ += (lo_ < n ? 1 : 0);
  380|       |#endif
  381|  3.50k|    return *this;
  382|  3.50k|  }
_ZN3fmt3v116detail20num_significand_bitsIdEEiv:
 1470|  9.83k|template <typename Float> constexpr auto num_significand_bits() -> int {
 1471|       |  // std::numeric_limits may not support __float128.
 1472|  9.83k|  return is_float128<Float>() ? 112
  ------------------
  |  Branch (1472:10): [Folded - Ignored]
  ------------------
 1473|  9.83k|                              : (std::numeric_limits<Float>::digits -
 1474|  9.83k|                                 (has_implicit_bit<Float>() ? 1 : 0));
  ------------------
  |  Branch (1474:35): [Folded - Ignored]
  ------------------
 1475|  9.83k|}
_ZN3fmt3v116detail9max_valueIiEET_v:
  395|    667|template <typename T> constexpr auto max_value() -> T {
  396|    667|  return (std::numeric_limits<T>::max)();
  397|    667|}
_ZN3fmt3v116detail6fill_nINS0_14basic_appenderIcEEicEET_S5_T0_RKT1_:
  521|    529|    -> OutputIt {
  522|    859|  for (Size i = 0; i < count; ++i) *out++ = value;
  ------------------
  |  Branch (522:20): [True: 330, False: 529]
  ------------------
  523|    529|  return out;
  524|    529|}
_ZN3fmt3v116detail8num_bitsIjEEiv:
  398|  21.2k|template <typename T> constexpr auto num_bits() -> int {
  399|  21.2k|  return std::numeric_limits<T>::digits;
  400|  21.2k|}
_ZNK3fmt3v116detail6bigint9get_bigitEi:
 2523|  2.83k|  FMT_CONSTEXPR auto get_bigit(int i) const -> bigit {
 2524|  2.83k|    return i >= exp_ && i < num_bigits() ? bigits_[i - exp_] : 0;
  ------------------
  |  Branch (2524:12): [True: 2.79k, False: 40]
  |  Branch (2524:25): [True: 2.02k, False: 772]
  ------------------
 2525|  2.83k|  }
_ZN3fmt3v116detail6bigint15subtract_bigitsEijRj:
 2527|   801k|  FMT_CONSTEXPR void subtract_bigits(int index, bigit other, bigit& borrow) {
 2528|   801k|    auto result = double_bigit(bigits_[index]) - other - borrow;
 2529|   801k|    bigits_[index] = static_cast<bigit>(result);
 2530|   801k|    borrow = static_cast<bigit>(result >> (bigit_bits * 2 - 1));
 2531|   801k|  }
_ZN3fmt3v1119basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEE6resizeEm:
  867|   175k|  FMT_CONSTEXPR void resize(size_t count) { this->try_resize(count); }
_ZN3fmt3v116detail6bigint20remove_leading_zerosEv:
 2533|   164k|  FMT_CONSTEXPR void remove_leading_zeros() {
 2534|   164k|    int num_bigits = static_cast<int>(bigits_.size()) - 1;
 2535|   171k|    while (num_bigits > 0 && bigits_[num_bigits] == 0) --num_bigits;
  ------------------
  |  Branch (2535:12): [True: 169k, False: 2.46k]
  |  Branch (2535:30): [True: 7.10k, False: 162k]
  ------------------
 2536|   164k|    bigits_.resize(to_unsigned(num_bigits + 1));
 2537|   164k|  }
_ZN3fmt3v116detail6bigint16subtract_alignedERKS2_:
 2540|   160k|  FMT_CONSTEXPR void subtract_aligned(const bigint& other) {
 2541|   160k|    FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints");
  ------------------
  |  |  397|   160k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:6): [True: 160k, False: 0]
  |  |  ------------------
  |  |  398|   160k|         ? (void)0                                                          \
  |  |  399|   160k|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2542|   160k|    FMT_ASSERT(compare(*this, other) >= 0, "");
  ------------------
  |  |  397|   160k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:6): [True: 160k, False: 0]
  |  |  ------------------
  |  |  398|   160k|         ? (void)0                                                          \
  |  |  399|   160k|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2543|   160k|    bigit borrow = 0;
 2544|   160k|    int i = other.exp_ - exp_;
 2545|   957k|    for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j)
  ------------------
  |  Branch (2545:50): [True: 796k, False: 160k]
  ------------------
 2546|   796k|      subtract_bigits(i, other.bigits_[j], borrow);
 2547|   160k|    if (borrow != 0) subtract_bigits(i, 0, borrow);
  ------------------
  |  Branch (2547:9): [True: 4.76k, False: 155k]
  ------------------
 2548|   160k|    FMT_ASSERT(borrow == 0, "");
  ------------------
  |  |  397|   160k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:6): [True: 160k, False: 0]
  |  |  ------------------
  |  |  398|   160k|         ? (void)0                                                          \
  |  |  399|   160k|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2549|   160k|    remove_leading_zeros();
 2550|   160k|  }
_ZN3fmt3v116detail6bigint8multiplyEj:
 2552|  47.3k|  FMT_CONSTEXPR void multiply(uint32_t value) {
 2553|  47.3k|    bigit carry = 0;
 2554|  47.3k|    const double_bigit wide_value = value;
 2555|   497k|    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
  ------------------
  |  Branch (2555:44): [True: 449k, False: 47.3k]
  ------------------
 2556|   449k|      double_bigit result = bigits_[i] * wide_value + carry;
 2557|   449k|      bigits_[i] = static_cast<bigit>(result);
 2558|   449k|      carry = static_cast<bigit>(result >> bigit_bits);
 2559|   449k|    }
 2560|  47.3k|    if (carry != 0) bigits_.push_back(carry);
  ------------------
  |  Branch (2560:9): [True: 3.75k, False: 43.5k]
  ------------------
 2561|  47.3k|  }
_ZN3fmt3v116detail6bigintC2Ev:
 2597|  3.70k|  FMT_CONSTEXPR bigint() : exp_(0) {}
_ZN3fmt3v116detail6bigint6assignImTnNSt3__19enable_ifIXoosr3std7is_sameIT_mEE5valuesr3std7is_sameIS6_oEE5valueEiE4typeELi0EEEvS6_:
 2586|  1.93k|  FMT_CONSTEXPR void assign(UInt n) {
 2587|  1.93k|    size_t num_bigits = 0;
 2588|  1.93k|    do {
 2589|  1.93k|      bigits_[num_bigits++] = static_cast<bigit>(n);
 2590|  1.93k|      n >>= bigit_bits;
 2591|  1.93k|    } while (n != 0);
  ------------------
  |  Branch (2591:14): [True: 0, False: 1.93k]
  ------------------
 2592|  1.93k|    bigits_.resize(num_bigits);
 2593|  1.93k|    exp_ = 0;
 2594|  1.93k|  }
_ZN3fmt3v116detail6bigint6assignERKS2_:
 2603|    475|  FMT_CONSTEXPR void assign(const bigint& other) {
 2604|    475|    auto size = other.bigits_.size();
 2605|    475|    bigits_.resize(size);
 2606|    475|    auto data = other.bigits_.data();
 2607|    475|    copy<bigit>(data, data + size, bigits_.data());
 2608|    475|    exp_ = other.exp_;
 2609|    475|  }
_ZNK3fmt3v116detail6bigint10num_bigitsEv:
 2616|   739k|  FMT_CONSTEXPR auto num_bigits() const -> int {
 2617|   739k|    return static_cast<int>(bigits_.size()) + exp_;
 2618|   739k|  }
_ZN3fmt3v116detail6bigintlSEi:
 2620|  3.07k|  FMT_CONSTEXPR auto operator<<=(int shift) -> bigint& {
 2621|  3.07k|    FMT_ASSERT(shift >= 0, "");
  ------------------
  |  |  397|  3.07k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:6): [True: 3.07k, False: 0]
  |  |  ------------------
  |  |  398|  3.07k|         ? (void)0                                                          \
  |  |  399|  3.07k|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2622|  3.07k|    exp_ += shift / bigit_bits;
 2623|  3.07k|    shift %= bigit_bits;
 2624|  3.07k|    if (shift == 0) return *this;
  ------------------
  |  Branch (2624:9): [True: 53, False: 3.01k]
  ------------------
 2625|  3.01k|    bigit carry = 0;
 2626|  22.4k|    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
  ------------------
  |  Branch (2626:44): [True: 19.3k, False: 3.01k]
  ------------------
 2627|  19.3k|      bigit c = bigits_[i] >> (bigit_bits - shift);
 2628|  19.3k|      bigits_[i] = (bigits_[i] << shift) + carry;
 2629|  19.3k|      carry = c;
 2630|  19.3k|    }
 2631|  3.01k|    if (carry != 0) bigits_.push_back(carry);
  ------------------
  |  Branch (2631:9): [True: 498, False: 2.52k]
  ------------------
 2632|  3.01k|    return *this;
 2633|  3.07k|  }
_ZN3fmt3v116detail7compareERKNS1_6bigintES4_:
 2641|   367k|  friend FMT_CONSTEXPR auto compare(const bigint& b1, const bigint& b2) -> int {
 2642|   367k|    int num_bigits1 = b1.num_bigits(), num_bigits2 = b2.num_bigits();
 2643|   367k|    if (num_bigits1 != num_bigits2) return num_bigits1 > num_bigits2 ? 1 : -1;
  ------------------
  |  Branch (2643:9): [True: 29.0k, False: 338k]
  |  Branch (2643:44): [True: 15.1k, False: 13.8k]
  ------------------
 2644|   338k|    int i = static_cast<int>(b1.bigits_.size()) - 1;
 2645|   338k|    int j = static_cast<int>(b2.bigits_.size()) - 1;
 2646|   338k|    int end = i - j;
 2647|   338k|    if (end < 0) end = 0;
  ------------------
  |  Branch (2647:9): [True: 160, False: 337k]
  ------------------
 2648|   343k|    for (; i >= end; --i, --j) {
  ------------------
  |  Branch (2648:12): [True: 340k, False: 2.85k]
  ------------------
 2649|   340k|      bigit b1_bigit = b1.bigits_[i], b2_bigit = b2.bigits_[j];
 2650|   340k|      if (b1_bigit != b2_bigit) return b1_bigit > b2_bigit ? 1 : -1;
  ------------------
  |  Branch (2650:11): [True: 335k, False: 4.94k]
  |  Branch (2650:40): [True: 302k, False: 32.3k]
  ------------------
 2651|   340k|    }
 2652|  2.85k|    if (i != j) return i > j ? 1 : -1;
  ------------------
  |  Branch (2652:9): [True: 2.43k, False: 422]
  |  Branch (2652:24): [True: 2.43k, False: 0]
  ------------------
 2653|    422|    return 0;
 2654|  2.85k|  }
_ZN3fmt3v116detail11add_compareERKNS1_6bigintES4_S4_:
 2658|    925|                                        const bigint& rhs) -> int {
 2659|    925|    int max_lhs_bigits = max_of(lhs1.num_bigits(), lhs2.num_bigits());
 2660|    925|    int num_rhs_bigits = rhs.num_bigits();
 2661|    925|    if (max_lhs_bigits + 1 < num_rhs_bigits) return -1;
  ------------------
  |  Branch (2661:9): [True: 42, False: 883]
  ------------------
 2662|    883|    if (max_lhs_bigits > num_rhs_bigits) return 1;
  ------------------
  |  Branch (2662:9): [True: 0, False: 883]
  ------------------
 2663|    883|    double_bigit borrow = 0;
 2664|    883|    int min_exp = min_of(min_of(lhs1.exp_, lhs2.exp_), rhs.exp_);
 2665|    960|    for (int i = num_rhs_bigits - 1; i >= min_exp; --i) {
  ------------------
  |  Branch (2665:38): [True: 945, False: 15]
  ------------------
 2666|    945|      double_bigit sum = double_bigit(lhs1.get_bigit(i)) + lhs2.get_bigit(i);
 2667|    945|      bigit rhs_bigit = rhs.get_bigit(i);
 2668|    945|      if (sum > rhs_bigit + borrow) return 1;
  ------------------
  |  Branch (2668:11): [True: 266, False: 679]
  ------------------
 2669|    679|      borrow = rhs_bigit + borrow - sum;
 2670|    679|      if (borrow > 1) return -1;
  ------------------
  |  Branch (2670:11): [True: 602, False: 77]
  ------------------
 2671|     77|      borrow <<= bigit_bits;
 2672|     77|    }
 2673|     15|    return borrow != 0 ? -1 : 0;
  ------------------
  |  Branch (2673:12): [True: 0, False: 15]
  ------------------
 2674|    883|  }
_ZN3fmt3v116detail6bigintaSIiEEvT_:
 2611|  1.89k|  template <typename Int> FMT_CONSTEXPR void operator=(Int n) {
 2612|  1.89k|    FMT_ASSERT(n > 0, "");
  ------------------
  |  |  397|  1.89k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:6): [True: 1.89k, False: 0]
  |  |  ------------------
  |  |  398|  1.89k|         ? (void)0                                                          \
  |  |  399|  1.89k|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2613|  1.89k|    assign(uint64_or_128_t<Int>(n));
 2614|  1.89k|  }
_ZN3fmt3v116detail6bigintmLIiEERS2_T_:
 2635|  47.3k|  template <typename Int> FMT_CONSTEXPR auto operator*=(Int value) -> bigint& {
 2636|  47.3k|    FMT_ASSERT(value > 0, "");
  ------------------
  |  |  397|  47.3k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:6): [True: 47.3k, False: 0]
  |  |  ------------------
  |  |  398|  47.3k|         ? (void)0                                                          \
  |  |  399|  47.3k|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2637|  47.3k|    multiply(uint32_or_64_or_128_t<Int>(value));
 2638|  47.3k|    return *this;
 2639|  47.3k|  }
_ZN3fmt3v116detail6bigint12assign_pow10Ei:
 2677|    925|  FMT_CONSTEXPR20 void assign_pow10(int exp) {
 2678|    925|    FMT_ASSERT(exp >= 0, "");
  ------------------
  |  |  397|    925|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:6): [True: 925, False: 0]
  |  |  ------------------
  |  |  398|    925|         ? (void)0                                                          \
  |  |  399|    925|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2679|    925|    if (exp == 0) return *this = 1;
  ------------------
  |  Branch (2679:9): [True: 28, False: 897]
  ------------------
 2680|    897|    int bitmask = 1 << (num_bits<unsigned>() -
 2681|    897|                        countl_zero(static_cast<uint32_t>(exp)) - 1);
 2682|       |    // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by
 2683|       |    // repeated squaring and multiplication.
 2684|    897|    *this = 5;
 2685|    897|    bitmask >>= 1;
 2686|  5.00k|    while (bitmask != 0) {
  ------------------
  |  Branch (2686:12): [True: 4.10k, False: 897]
  ------------------
 2687|  4.10k|      square();
 2688|  4.10k|      if ((exp & bitmask) != 0) *this *= 5;
  ------------------
  |  Branch (2688:11): [True: 2.00k, False: 2.10k]
  ------------------
 2689|  4.10k|      bitmask >>= 1;
 2690|  4.10k|    }
 2691|    897|    *this <<= exp;  // Multiply by pow(2, exp) by shifting.
 2692|    897|  }
_ZN3fmt3v116detail6bigint6squareEv:
 2694|  4.10k|  FMT_CONSTEXPR20 void square() {
 2695|  4.10k|    int num_bigits = static_cast<int>(bigits_.size());
 2696|  4.10k|    int num_result_bigits = 2 * num_bigits;
 2697|  4.10k|    basic_memory_buffer<bigit, bigits_capacity> n(std::move(bigits_));
 2698|  4.10k|    bigits_.resize(to_unsigned(num_result_bigits));
 2699|  4.10k|    auto sum = uint128_t();
 2700|  14.2k|    for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) {
  ------------------
  |  Branch (2700:31): [True: 10.1k, False: 4.10k]
  ------------------
 2701|       |      // Compute bigit at position bigit_index of the result by adding
 2702|       |      // cross-product terms n[i] * n[j] such that i + j == bigit_index.
 2703|  44.3k|      for (int i = 0, j = bigit_index; j >= 0; ++i, --j) {
  ------------------
  |  Branch (2703:40): [True: 34.1k, False: 10.1k]
  ------------------
 2704|       |        // Most terms are multiplied twice which can be optimized in the future.
 2705|  34.1k|        sum += double_bigit(n[i]) * n[j];
 2706|  34.1k|      }
 2707|  10.1k|      bigits_[bigit_index] = static_cast<bigit>(sum);
 2708|  10.1k|      sum >>= num_bits<bigit>();  // Compute the carry.
 2709|  10.1k|    }
 2710|       |    // Do the same for the top half.
 2711|  14.2k|    for (int bigit_index = num_bigits; bigit_index < num_result_bigits;
  ------------------
  |  Branch (2711:40): [True: 10.1k, False: 4.10k]
  ------------------
 2712|  10.1k|         ++bigit_index) {
 2713|  34.1k|      for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;)
  ------------------
  |  Branch (2713:57): [True: 23.9k, False: 10.1k]
  ------------------
 2714|  23.9k|        sum += double_bigit(n[i++]) * n[j--];
 2715|  10.1k|      bigits_[bigit_index] = static_cast<bigit>(sum);
 2716|  10.1k|      sum >>= num_bits<bigit>();
 2717|  10.1k|    }
 2718|  4.10k|    remove_leading_zeros();
 2719|  4.10k|    exp_ *= 2;
 2720|  4.10k|  }
_ZN3fmt3v116detail6bigint5alignERKS2_:
 2724|  31.5k|  FMT_CONSTEXPR void align(const bigint& other) {
 2725|  31.5k|    int exp_difference = exp_ - other.exp_;
 2726|  31.5k|    if (exp_difference <= 0) return;
  ------------------
  |  Branch (2726:9): [True: 31.3k, False: 184]
  ------------------
 2727|    184|    int num_bigits = static_cast<int>(bigits_.size());
 2728|    184|    bigits_.resize(to_unsigned(num_bigits + exp_difference));
 2729|    692|    for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
  ------------------
  |  Branch (2729:58): [True: 508, False: 184]
  ------------------
 2730|    508|      bigits_[j] = bigits_[i];
 2731|    184|    memset(bigits_.data(), 0, to_unsigned(exp_difference) * sizeof(bigit));
 2732|    184|    exp_ -= exp_difference;
 2733|    184|  }
_ZN3fmt3v116detail6bigint13divmod_assignERKS2_:
 2737|  46.2k|  FMT_CONSTEXPR auto divmod_assign(const bigint& divisor) -> int {
 2738|  46.2k|    FMT_ASSERT(this != &divisor, "");
  ------------------
  |  |  397|  46.2k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:6): [True: 46.2k, False: 0]
  |  |  ------------------
  |  |  398|  46.2k|         ? (void)0                                                          \
  |  |  399|  46.2k|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2739|  46.2k|    if (compare(*this, divisor) < 0) return 0;
  ------------------
  |  Branch (2739:9): [True: 14.7k, False: 31.5k]
  ------------------
 2740|  31.5k|    FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, "");
  ------------------
  |  |  397|  31.5k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:6): [True: 31.5k, False: 0]
  |  |  ------------------
  |  |  398|  31.5k|         ? (void)0                                                          \
  |  |  399|  31.5k|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2741|  31.5k|    align(divisor);
 2742|  31.5k|    int quotient = 0;
 2743|   160k|    do {
 2744|   160k|      subtract_aligned(divisor);
 2745|   160k|      ++quotient;
 2746|   160k|    } while (compare(*this, divisor) >= 0);
  ------------------
  |  Branch (2746:14): [True: 128k, False: 31.5k]
  ------------------
 2747|  31.5k|    return quotient;
 2748|  46.2k|  }
_ZN3fmt3v116detail6bigint6assignIoTnNSt3__19enable_ifIXoosr3std7is_sameIT_mEE5valuesr3std7is_sameIS6_oEE5valueEiE4typeELi0EEEvS6_:
 2586|    514|  FMT_CONSTEXPR void assign(UInt n) {
 2587|    514|    size_t num_bigits = 0;
 2588|  1.02k|    do {
 2589|  1.02k|      bigits_[num_bigits++] = static_cast<bigit>(n);
 2590|  1.02k|      n >>= bigit_bits;
 2591|  1.02k|    } while (n != 0);
  ------------------
  |  Branch (2591:14): [True: 514, False: 514]
  ------------------
 2592|    514|    bigits_.resize(num_bigits);
 2593|    514|    exp_ = 0;
 2594|    514|  }
_ZN3fmt3v116detail6bigintaSIoEEvT_:
 2611|    514|  template <typename Int> FMT_CONSTEXPR void operator=(Int n) {
 2612|    514|    FMT_ASSERT(n > 0, "");
  ------------------
  |  |  397|    514|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:6): [True: 514, False: 0]
  |  |  ------------------
  |  |  398|    514|         ? (void)0                                                          \
  |  |  399|    514|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2613|    514|    assign(uint64_or_128_t<Int>(n));
 2614|    514|  }
_ZN3fmt3v116detail8num_bitsImEEiv:
  398|    651|template <typename T> constexpr auto num_bits() -> int {
  399|    651|  return std::numeric_limits<T>::digits;
  400|    651|}
_ZN3fmt3v116detail6bigint8multiplyIoTnNSt3__19enable_ifIXoosr3std7is_sameIT_mEE5valuesr3std7is_sameIS6_oEE5valueEiE4typeELi0EEEvS6_:
 2565|    411|  FMT_CONSTEXPR void multiply(UInt value) {
 2566|    411|    using half_uint =
 2567|    411|        conditional_t<std::is_same<UInt, uint128_t>::value, uint64_t, uint32_t>;
 2568|    411|    const int shift = num_bits<half_uint>() - bigit_bits;
 2569|    411|    const UInt lower = static_cast<half_uint>(value);
 2570|    411|    const UInt upper = value >> num_bits<half_uint>();
 2571|    411|    UInt carry = 0;
 2572|  5.54k|    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
  ------------------
  |  Branch (2572:44): [True: 5.12k, False: 411]
  ------------------
 2573|  5.12k|      UInt result = lower * bigits_[i] + static_cast<bigit>(carry);
 2574|  5.12k|      carry = (upper * bigits_[i] << shift) + (result >> bigit_bits) +
 2575|  5.12k|              (carry >> bigit_bits);
 2576|  5.12k|      bigits_[i] = static_cast<bigit>(result);
 2577|  5.12k|    }
 2578|    947|    while (carry != 0) {
  ------------------
  |  Branch (2578:12): [True: 536, False: 411]
  ------------------
 2579|    536|      bigits_.push_back(static_cast<bigit>(carry));
 2580|    536|      carry >>= bigit_bits;
 2581|    536|    }
 2582|    411|  }
_ZN3fmt3v116detail6bigintmLIoEERS2_T_:
 2635|    411|  template <typename Int> FMT_CONSTEXPR auto operator*=(Int value) -> bigint& {
 2636|    411|    FMT_ASSERT(value > 0, "");
  ------------------
  |  |  397|    411|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:6): [True: 411, False: 0]
  |  |  ------------------
  |  |  398|    411|         ? (void)0                                                          \
  |  |  399|    411|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2637|    411|    multiply(uint32_or_64_or_128_t<Int>(value));
 2638|    411|    return *this;
 2639|    411|  }
_ZN3fmt3v116detail6bigintaSIyEEvT_:
 2611|     32|  template <typename Int> FMT_CONSTEXPR void operator=(Int n) {
 2612|     32|    FMT_ASSERT(n > 0, "");
  ------------------
  |  |  397|     32|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:6): [True: 32, False: 0]
  |  |  ------------------
  |  |  398|     32|         ? (void)0                                                          \
  |  |  399|     32|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2613|     32|    assign(uint64_or_128_t<Int>(n));
 2614|     32|  }
_ZN3fmt3v116detail13copy_noinlineIcPcNS0_14basic_appenderIcEEEET1_T0_S7_S6_:
  534|    679|                                              OutputIt out) -> OutputIt {
  535|    679|  return copy<OutChar>(begin, end, out);
  536|    679|}
_ZN3fmt3v116detail13exponent_maskIdEENS1_9dragonbox10float_infoIT_vE12carrier_uintEv:
 1479|  3.79k|    typename dragonbox::float_info<Float>::carrier_uint {
 1480|  3.79k|  using float_uint = typename dragonbox::float_info<Float>::carrier_uint;
 1481|  3.79k|  return ((float_uint(1) << dragonbox::float_info<Float>::exponent_bits) - 1)
 1482|  3.79k|         << num_significand_bits<Float>();
 1483|  3.79k|}
_ZN3fmt3v116detail13exponent_biasIdEEiv:
 1484|  2.53k|template <typename Float> constexpr auto exponent_bias() -> int {
 1485|       |  // std::numeric_limits may not support __float128.
 1486|  2.53k|  return is_float128<Float>() ? 16383
  ------------------
  |  Branch (1486:10): [Folded - Ignored]
  ------------------
 1487|  2.53k|                              : std::numeric_limits<Float>::max_exponent - 1;
 1488|  2.53k|}
_ZN3fmt3v116detail7getsignIcEET_NS0_4signE:
 1008|    920|template <typename Char> constexpr auto getsign(sign s) -> Char {
 1009|    920|  return static_cast<char>(((' ' << 24) | ('+' << 16) | ('-' << 8)) >>
 1010|    920|                           (static_cast<int>(s) * 8));
 1011|    920|}
_ZN3fmt3v116detail11countl_zeroEj:
  433|    897|FMT_CONSTEXPR20 inline auto countl_zero(uint32_t n) -> int {
  434|    897|#ifdef FMT_BUILTIN_CLZ
  435|    897|  if (!is_constant_evaluated()) return FMT_BUILTIN_CLZ(n);
  ------------------
  |  |  174|    897|#    define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
  ------------------
  |  Branch (435:7): [Folded - Ignored]
  ------------------
  436|      0|#endif
  437|      0|  return countl_zero_fallback(n);
  438|    897|}
_ZN3fmt3v116detail11countl_zeroEm:
  440|    120|FMT_CONSTEXPR20 inline auto countl_zero(uint64_t n) -> int {
  441|    120|#ifdef FMT_BUILTIN_CLZLL
  442|    120|  if (!is_constant_evaluated()) return FMT_BUILTIN_CLZLL(n);
  ------------------
  |  |  177|    120|#    define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
  ------------------
  |  Branch (442:7): [Folded - Ignored]
  ------------------
  443|      0|#endif
  444|      0|  return countl_zero_fallback(n);
  445|    120|}
_ZN3fmt3v116detail7digits2Em:
  996|  7.72k|inline auto digits2(size_t value) -> const char* {
  997|       |  // Align data since unaligned access may be slower when crossing a
  998|       |  // hardware-specific boundary.
  999|  7.72k|  alignas(2) static const char data[] =
 1000|  7.72k|      "0001020304050607080910111213141516171819"
 1001|  7.72k|      "2021222324252627282930313233343536373839"
 1002|  7.72k|      "4041424344454647484950515253545556575859"
 1003|  7.72k|      "6061626364656667686970717273747576777879"
 1004|  7.72k|      "8081828384858687888990919293949596979899";
 1005|  7.72k|  return &data[value * 2];
 1006|  7.72k|}
_ZN3fmt3v116detail15do_count_digitsEm:
 1036|  1.85k|inline auto do_count_digits(uint64_t n) -> int {
 1037|       |  // This has comparable performance to the version by Kendall Willets
 1038|       |  // (https://github.com/fmtlib/format-benchmark/blob/master/digits10)
 1039|       |  // but uses smaller tables.
 1040|       |  // Maps bsr(n) to ceil(log10(pow(2, bsr(n) + 1) - 1)).
 1041|  1.85k|  static constexpr uint8_t bsr2log10[] = {
 1042|  1.85k|      1,  1,  1,  2,  2,  2,  3,  3,  3,  4,  4,  4,  4,  5,  5,  5,
 1043|  1.85k|      6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  9,  9,  9,  10, 10, 10,
 1044|  1.85k|      10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15,
 1045|  1.85k|      15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19, 20};
 1046|  1.85k|  auto t = bsr2log10[FMT_BUILTIN_CLZLL(n | 1) ^ 63];
  ------------------
  |  |  177|  1.85k|#    define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
  ------------------
 1047|  1.85k|  static constexpr const uint64_t zero_or_powers_of_10[] = {
 1048|  1.85k|      0, 0, FMT_POWERS_OF_10(1U), FMT_POWERS_OF_10(1000000000ULL),
  ------------------
  |  |  990|  1.85k|  factor * 10, (factor) * 100, (factor) * 1000, (factor) * 10000, \
  |  |  991|  1.85k|      (factor) * 100000, (factor) * 1000000, (factor) * 10000000, \
  |  |  992|  1.85k|      (factor) * 100000000, (factor) * 1000000000
  ------------------
                    0, 0, FMT_POWERS_OF_10(1U), FMT_POWERS_OF_10(1000000000ULL),
  ------------------
  |  |  990|  1.85k|  factor * 10, (factor) * 100, (factor) * 1000, (factor) * 10000, \
  |  |  991|  1.85k|      (factor) * 100000, (factor) * 1000000, (factor) * 10000000, \
  |  |  992|  1.85k|      (factor) * 100000000, (factor) * 1000000000
  ------------------
 1049|  1.85k|      10000000000000000000ULL};
 1050|  1.85k|  return t - (n < zero_or_powers_of_10[t]);
 1051|  1.85k|}
_ZN3fmt3v116detail12count_digitsEm:
 1056|  1.85k|FMT_CONSTEXPR20 inline auto count_digits(uint64_t n) -> int {
 1057|  1.85k|#ifdef FMT_BUILTIN_CLZLL
 1058|  1.85k|  if (!is_constant_evaluated() && !FMT_OPTIMIZE_SIZE) return do_count_digits(n);
  ------------------
  |  |  295|      0|#  define FMT_OPTIMIZE_SIZE 0
  ------------------
  |  Branch (1058:7): [Folded - Ignored]
  |  Branch (1058:35): [Folded - Ignored]
  ------------------
 1059|      0|#endif
 1060|      0|  return count_digits_fallback(n);
 1061|  1.85k|}
_ZN3fmt3v116detail6equal2EPKcS3_:
 1160|  1.02k|inline auto equal2(const char* lhs, const char* rhs) -> bool {
 1161|  1.02k|  return memcmp(lhs, rhs, 2) == 0;
 1162|  1.02k|}
_ZN3fmt3v116detail7umul128Emm:
 1346|  5.96k|inline auto umul128(uint64_t x, uint64_t y) noexcept -> uint128_fallback {
 1347|  5.96k|#if FMT_USE_INT128
 1348|  5.96k|  auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
 1349|  5.96k|  return {static_cast<uint64_t>(p >> 64), static_cast<uint64_t>(p)};
 1350|       |#elif defined(_MSC_VER) && defined(_M_X64)
 1351|       |  auto hi = uint64_t();
 1352|       |  auto lo = _umul128(x, y, &hi);
 1353|       |  return {hi, lo};
 1354|       |#else
 1355|       |  const uint64_t mask = static_cast<uint64_t>(max_value<uint32_t>());
 1356|       |
 1357|       |  uint64_t a = x >> 32;
 1358|       |  uint64_t b = x & mask;
 1359|       |  uint64_t c = y >> 32;
 1360|       |  uint64_t d = y & mask;
 1361|       |
 1362|       |  uint64_t ac = a * c;
 1363|       |  uint64_t bc = b * c;
 1364|       |  uint64_t ad = a * d;
 1365|       |  uint64_t bd = b * d;
 1366|       |
 1367|       |  uint64_t intermediate = (bd >> 32) + (ad & mask) + (bc & mask);
 1368|       |
 1369|       |  return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32),
 1370|       |          (intermediate << 32) + (bd & mask)};
 1371|       |#endif
 1372|  5.96k|}
_ZN3fmt3v116detail9dragonbox16floor_log10_pow2Ei:
 1377|  1.70k|inline auto floor_log10_pow2(int e) noexcept -> int {
 1378|  1.70k|  FMT_ASSERT(e <= 2620 && e >= -2620, "too large exponent");
  ------------------
  |  |  397|  3.40k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:7): [True: 1.70k, False: 0]
  |  |  |  Branch (397:7): [True: 1.70k, False: 0]
  |  |  ------------------
  |  |  398|  1.70k|         ? (void)0                                                          \
  |  |  399|  1.70k|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1379|  1.70k|  static_assert((-1 >> 1) == -1, "right shift is not arithmetic");
 1380|  1.70k|  return (e * 315653) >> 20;
 1381|  1.70k|}
_ZN3fmt3v116detail9dragonbox16floor_log2_pow10Ei:
 1383|  5.45k|inline auto floor_log2_pow10(int e) noexcept -> int {
 1384|  5.45k|  FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent");
  ------------------
  |  |  397|  10.9k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:7): [True: 5.45k, False: 0]
  |  |  |  Branch (397:7): [True: 5.45k, False: 0]
  |  |  ------------------
  |  |  398|  5.45k|         ? (void)0                                                          \
  |  |  399|  5.45k|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1385|  5.45k|  return (e * 1741647) >> 19;
 1386|  5.45k|}
_ZN3fmt3v116detail9dragonbox15umul128_upper64Emm:
 1389|  2.48k|inline auto umul128_upper64(uint64_t x, uint64_t y) noexcept -> uint64_t {
 1390|  2.48k|#if FMT_USE_INT128
 1391|  2.48k|  auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
 1392|  2.48k|  return static_cast<uint64_t>(p >> 64);
 1393|       |#elif defined(_MSC_VER) && defined(_M_X64)
 1394|       |  return __umulh(x, y);
 1395|       |#else
 1396|       |  return umul128(x, y).high();
 1397|       |#endif
 1398|  2.48k|}
_ZN3fmt3v116detail9dragonbox16umul192_upper128EmNS1_16uint128_fallbackE:
 1403|  1.70k|    -> uint128_fallback {
 1404|  1.70k|  uint128_fallback r = umul128(x, y.high());
 1405|  1.70k|  r += umul128_upper64(x, y.low());
 1406|  1.70k|  return r;
 1407|  1.70k|}
_ZN3fmt3v116detail20get_significand_sizeERKNS1_14big_decimal_fpE:
 2235|    927|constexpr auto get_significand_size(const big_decimal_fp& f) -> int {
 2236|    927|  return f.significand_size;
 2237|    927|}
_ZN3fmt3v116detail13format_dragonENS1_8basic_fpIoEEjiRNS1_6bufferIcEERi:
 2763|    925|                                          buffer<char>& buf, int& exp10) {
 2764|    925|  bigint numerator;    // 2 * R in (FPP)^2.
 2765|    925|  bigint denominator;  // 2 * S in (FPP)^2.
 2766|       |  // lower and upper are differences between value and corresponding boundaries.
 2767|    925|  bigint lower;             // (M^- in (FPP)^2).
 2768|    925|  bigint upper_store;       // upper's value if different from lower.
 2769|    925|  bigint* upper = nullptr;  // (M^+ in (FPP)^2).
 2770|       |  // Shift numerator and denominator by an extra bit or two (if lower boundary
 2771|       |  // is closer) to make lower and upper integers. This eliminates multiplication
 2772|       |  // by 2 during later computations.
 2773|    925|  bool is_predecessor_closer = (flags & dragon::predecessor_closer) != 0;
 2774|    925|  int shift = is_predecessor_closer ? 2 : 1;
  ------------------
  |  Branch (2774:15): [True: 145, False: 780]
  ------------------
 2775|    925|  if (value.e >= 0) {
  ------------------
  |  Branch (2775:7): [True: 211, False: 714]
  ------------------
 2776|    211|    numerator = value.f;
 2777|    211|    numerator <<= value.e + shift;
 2778|    211|    lower = 1;
 2779|    211|    lower <<= value.e;
 2780|    211|    if (is_predecessor_closer) {
  ------------------
  |  Branch (2780:9): [True: 49, False: 162]
  ------------------
 2781|     49|      upper_store = 1;
 2782|     49|      upper_store <<= value.e + 1;
 2783|     49|      upper = &upper_store;
 2784|     49|    }
 2785|    211|    denominator.assign_pow10(exp10);
 2786|    211|    denominator <<= shift;
 2787|    714|  } else if (exp10 < 0) {
  ------------------
  |  Branch (2787:14): [True: 411, False: 303]
  ------------------
 2788|    411|    numerator.assign_pow10(-exp10);
 2789|    411|    lower.assign(numerator);
 2790|    411|    if (is_predecessor_closer) {
  ------------------
  |  Branch (2790:9): [True: 64, False: 347]
  ------------------
 2791|     64|      upper_store.assign(numerator);
 2792|     64|      upper_store <<= 1;
 2793|     64|      upper = &upper_store;
 2794|     64|    }
 2795|    411|    numerator *= value.f;
 2796|    411|    numerator <<= shift;
 2797|    411|    denominator = 1;
 2798|    411|    denominator <<= shift - value.e;
 2799|    411|  } else {
 2800|    303|    numerator = value.f;
 2801|    303|    numerator <<= shift;
 2802|    303|    denominator.assign_pow10(exp10);
 2803|    303|    denominator <<= shift - value.e;
 2804|    303|    lower = 1;
 2805|    303|    if (is_predecessor_closer) {
  ------------------
  |  Branch (2805:9): [True: 32, False: 271]
  ------------------
 2806|     32|      upper_store = 1ULL << 1;
 2807|     32|      upper = &upper_store;
 2808|     32|    }
 2809|    303|  }
 2810|    925|  int even = static_cast<int>((value.f & 1) == 0);
 2811|    925|  if (!upper) upper = &lower;
  ------------------
  |  Branch (2811:7): [True: 780, False: 145]
  ------------------
 2812|    925|  bool shortest = num_digits < 0;
 2813|    925|  if ((flags & dragon::fixup) != 0) {
  ------------------
  |  Branch (2813:7): [True: 0, False: 925]
  ------------------
 2814|      0|    if (add_compare(numerator, *upper, denominator) + even <= 0) {
  ------------------
  |  Branch (2814:9): [True: 0, False: 0]
  ------------------
 2815|      0|      --exp10;
 2816|      0|      numerator *= 10;
 2817|      0|      if (num_digits < 0) {
  ------------------
  |  Branch (2817:11): [True: 0, False: 0]
  ------------------
 2818|      0|        lower *= 10;
 2819|      0|        if (upper != &lower) *upper *= 10;
  ------------------
  |  Branch (2819:13): [True: 0, False: 0]
  ------------------
 2820|      0|      }
 2821|      0|    }
 2822|      0|    if ((flags & dragon::fixed) != 0) adjust_precision(num_digits, exp10 + 1);
  ------------------
  |  Branch (2822:9): [True: 0, False: 0]
  ------------------
 2823|      0|  }
 2824|       |  // Invariant: value == (numerator / denominator) * pow(10, exp10).
 2825|    925|  if (shortest) {
  ------------------
  |  Branch (2825:7): [True: 0, False: 925]
  ------------------
 2826|       |    // Generate the shortest representation.
 2827|      0|    num_digits = 0;
 2828|      0|    char* data = buf.data();
 2829|      0|    for (;;) {
 2830|      0|      int digit = numerator.divmod_assign(denominator);
 2831|      0|      bool low = compare(numerator, lower) - even < 0;  // numerator <[=] lower.
 2832|       |      // numerator + upper >[=] pow10:
 2833|      0|      bool high = add_compare(numerator, *upper, denominator) + even > 0;
 2834|      0|      data[num_digits++] = static_cast<char>('0' + digit);
 2835|      0|      if (low || high) {
  ------------------
  |  Branch (2835:11): [True: 0, False: 0]
  |  Branch (2835:18): [True: 0, False: 0]
  ------------------
 2836|      0|        if (!low) {
  ------------------
  |  Branch (2836:13): [True: 0, False: 0]
  ------------------
 2837|      0|          ++data[num_digits - 1];
 2838|      0|        } else if (high) {
  ------------------
  |  Branch (2838:20): [True: 0, False: 0]
  ------------------
 2839|      0|          int result = add_compare(numerator, numerator, denominator);
 2840|       |          // Round half to even.
 2841|      0|          if (result > 0 || (result == 0 && (digit % 2) != 0))
  ------------------
  |  Branch (2841:15): [True: 0, False: 0]
  |  Branch (2841:30): [True: 0, False: 0]
  |  Branch (2841:45): [True: 0, False: 0]
  ------------------
 2842|      0|            ++data[num_digits - 1];
 2843|      0|        }
 2844|      0|        buf.try_resize(to_unsigned(num_digits));
 2845|      0|        exp10 -= num_digits - 1;
 2846|      0|        return;
 2847|      0|      }
 2848|      0|      numerator *= 10;
 2849|      0|      lower *= 10;
 2850|      0|      if (upper != &lower) *upper *= 10;
  ------------------
  |  Branch (2850:11): [True: 0, False: 0]
  ------------------
 2851|      0|    }
 2852|      0|  }
 2853|       |  // Generate the given number of digits.
 2854|    925|  exp10 -= num_digits - 1;
 2855|    925|  if (num_digits <= 0) {
  ------------------
  |  Branch (2855:7): [True: 0, False: 925]
  ------------------
 2856|      0|    auto digit = '0';
 2857|      0|    if (num_digits == 0) {
  ------------------
  |  Branch (2857:9): [True: 0, False: 0]
  ------------------
 2858|      0|      denominator *= 10;
 2859|      0|      digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0';
  ------------------
  |  Branch (2859:15): [True: 0, False: 0]
  ------------------
 2860|      0|    }
 2861|      0|    buf.push_back(digit);
 2862|      0|    return;
 2863|      0|  }
 2864|    925|  buf.try_resize(to_unsigned(num_digits));
 2865|  46.2k|  for (int i = 0; i < num_digits - 1; ++i) {
  ------------------
  |  Branch (2865:19): [True: 45.3k, False: 925]
  ------------------
 2866|  45.3k|    int digit = numerator.divmod_assign(denominator);
 2867|  45.3k|    buf[i] = static_cast<char>('0' + digit);
 2868|  45.3k|    numerator *= 10;
 2869|  45.3k|  }
 2870|    925|  int digit = numerator.divmod_assign(denominator);
 2871|    925|  auto result = add_compare(numerator, numerator, denominator);
 2872|    925|  if (result > 0 || (result == 0 && (digit % 2) != 0)) {
  ------------------
  |  Branch (2872:7): [True: 266, False: 659]
  |  Branch (2872:22): [True: 15, False: 644]
  |  Branch (2872:37): [True: 7, False: 8]
  ------------------
 2873|    273|    if (digit == 9) {
  ------------------
  |  Branch (2873:9): [True: 37, False: 236]
  ------------------
 2874|     37|      const auto overflow = '0' + 10;
 2875|     37|      buf[num_digits - 1] = overflow;
 2876|       |      // Propagate the carry.
 2877|    100|      for (int i = num_digits - 1; i > 0 && buf[i] == overflow; --i) {
  ------------------
  |  Branch (2877:36): [True: 100, False: 0]
  |  Branch (2877:45): [True: 63, False: 37]
  ------------------
 2878|     63|        buf[i] = '0';
 2879|     63|        ++buf[i - 1];
 2880|     63|      }
 2881|     37|      if (buf[0] == overflow) {
  ------------------
  |  Branch (2881:11): [True: 0, False: 37]
  ------------------
 2882|      0|        buf[0] = '1';
 2883|      0|        if ((flags & dragon::fixed) != 0)
  ------------------
  |  Branch (2883:13): [True: 0, False: 0]
  ------------------
 2884|      0|          buf.push_back('0');
 2885|      0|        else
 2886|      0|          ++exp10;
 2887|      0|      }
 2888|     37|      return;
 2889|     37|    }
 2890|    236|    ++digit;
 2891|    236|  }
 2892|    888|  buf[num_digits - 1] = static_cast<char>('0' + digit);
 2893|    888|}
_ZN3fmt3v1119basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEE10deallocateEv:
  786|  7.80k|  FMT_CONSTEXPR20 void deallocate() {
  787|  7.80k|    T* data = this->data();
  788|  7.80k|    if (data != store_) alloc_.deallocate(data, this->capacity());
  ------------------
  |  Branch (788:9): [True: 0, False: 7.80k]
  ------------------
  789|  7.80k|  }
_ZN3fmt3v1119basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEE4moveERS5_:
  829|  4.10k|  FMT_CONSTEXPR20 void move(basic_memory_buffer& other) {
  830|  4.10k|    alloc_ = std::move(other.alloc_);
  831|  4.10k|    T* data = other.data();
  832|  4.10k|    size_t size = other.size(), capacity = other.capacity();
  833|  4.10k|    if (data == other.store_) {
  ------------------
  |  Branch (833:9): [True: 4.10k, False: 0]
  ------------------
  834|  4.10k|      this->set(store_, capacity);
  835|  4.10k|      detail::copy<T>(other.store_, other.store_ + size, store_);
  836|  4.10k|    } else {
  837|      0|      this->set(data, capacity);
  838|       |      // Set pointer to the inline array so that delete is not called
  839|       |      // when deallocating.
  840|      0|      other.set(other.store_, 0);
  841|      0|      other.clear();
  842|      0|    }
  843|  4.10k|    this->resize(size);
  844|  4.10k|  }
_ZN3fmt3v116detail10to_pointerIcEEPT_NS0_14basic_appenderIS3_EEm:
  494|    248|FMT_CONSTEXPR20 auto to_pointer(basic_appender<T> it, size_t n) -> T* {
  495|    248|  buffer<T>& buf = get_container(it);
  496|    248|  buf.try_reserve(buf.size() + n);
  497|    248|  auto size = buf.size();
  498|    248|  if (buf.capacity() < size + n) return nullptr;
  ------------------
  |  Branch (498:7): [True: 0, False: 248]
  ------------------
  499|    248|  buf.try_resize(size + n);
  500|    248|  return buf.data() + size;
  501|    248|}
_ZN3fmt3v116detail12write2digitsIcEEvPT_m:
 1166|  5.98k|FMT_CONSTEXPR20 FMT_INLINE void write2digits(Char* out, size_t value) {
 1167|  5.98k|  if (!is_constant_evaluated() && std::is_same<Char, char>::value &&
  ------------------
  |  Branch (1167:7): [Folded - Ignored]
  |  Branch (1167:35): [Folded - Ignored]
  ------------------
 1168|  5.98k|      !FMT_OPTIMIZE_SIZE) {
  ------------------
  |  |  295|      0|#  define FMT_OPTIMIZE_SIZE 0
  ------------------
  |  Branch (1168:7): [Folded - Ignored]
  ------------------
 1169|  5.98k|    memcpy(out, digits2(value), 2);
 1170|  5.98k|    return;
 1171|  5.98k|  }
 1172|      0|  *out++ = static_cast<Char>('0' + value / 10);
 1173|      0|  *out = static_cast<Char>('0' + value % 10);
 1174|      0|}
_ZN3fmt3v116detail17do_format_decimalIcmEEPT_S4_T0_i:
 1180|    927|    -> Char* {
 1181|    927|  FMT_ASSERT(size >= count_digits(value), "invalid digit count");
  ------------------
  |  |  397|    927|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:6): [True: 927, False: 0]
  |  |  ------------------
  |  |  398|    927|         ? (void)0                                                          \
  |  |  399|    927|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1182|    927|  unsigned n = to_unsigned(size);
 1183|  2.64k|  while (value >= 100) {
  ------------------
  |  Branch (1183:10): [True: 1.71k, False: 927]
  ------------------
 1184|       |    // Integer division is slow so do it for a group of two digits instead
 1185|       |    // of for every digit. The idea comes from the talk by Alexandrescu
 1186|       |    // "Three Optimization Tips for C++". See speed-test for a comparison.
 1187|  1.71k|    n -= 2;
 1188|  1.71k|    write2digits(out + n, static_cast<unsigned>(value % 100));
 1189|  1.71k|    value /= 100;
 1190|  1.71k|  }
 1191|    927|  if (value >= 10) {
  ------------------
  |  Branch (1191:7): [True: 251, False: 676]
  ------------------
 1192|    251|    n -= 2;
 1193|    251|    write2digits(out + n, static_cast<unsigned>(value));
 1194|    676|  } else {
 1195|    676|    out[--n] = static_cast<Char>('0' + value);
 1196|    676|  }
 1197|    927|  return out + n;
 1198|    927|}
_ZN3fmt3v116detail14format_decimalIcmEEPT_S4_T0_i:
 1202|    679|                                             int num_digits) -> Char* {
 1203|    679|  do_format_decimal(out, value, num_digits);
 1204|    679|  return out + num_digits;
 1205|    679|}
_ZN3fmt3v116detail14format_decimalIcmNS0_14basic_appenderIcEETnNSt3__19enable_ifIXntsr3std10is_pointerINS5_9remove_cvINS5_16remove_referenceIT1_E4typeEE4typeEEE5valueEiE4typeELi0EEES9_S9_T0_i:
 1210|    248|    -> OutputIt {
 1211|    248|  if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
  ------------------
  |  Branch (1211:12): [True: 248, False: 0]
  ------------------
 1212|    248|    do_format_decimal(ptr, value, num_digits);
 1213|    248|    return out;
 1214|    248|  }
 1215|       |  // Buffer is large enough to hold all digits (digits10 + 1).
 1216|      0|  char buffer[digits10<UInt>() + 1];
 1217|      0|  if (is_constant_evaluated()) fill_n(buffer, sizeof(buffer), '\0');
  ------------------
  |  Branch (1217:7): [Folded - Ignored]
  ------------------
 1218|      0|  do_format_decimal(buffer, value, num_digits);
 1219|      0|  return copy_noinline<Char>(buffer, buffer + num_digits, out);
 1220|    248|}
_ZN3fmt3v116detail7reserveIcEENS0_14basic_appenderIT_EES5_m:
  474|  2.04k|    -> basic_appender<T> {
  475|  2.04k|  buffer<T>& buf = get_container(it);
  476|  2.04k|  buf.try_reserve(buf.size() + n);
  477|  2.04k|  return it;
  478|  2.04k|}
_ZN3fmt3v116detail13base_iteratorINS0_14basic_appenderIcEEEET_S5_S5_:
  513|  2.04k|constexpr auto base_iterator(Iterator, Iterator it) -> Iterator {
  514|  2.04k|  return it;
  515|  2.04k|}
_ZN3fmt3v116detail15write_nonfiniteIcNS0_14basic_appenderIcEEEET0_S5_bNS0_12format_specsENS0_4signE:
 2211|    188|                                     format_specs specs, sign s) -> OutputIt {
 2212|    188|  auto str =
 2213|    188|      isnan ? (specs.upper() ? "NAN" : "nan") : (specs.upper() ? "INF" : "inf");
  ------------------
  |  Branch (2213:7): [True: 184, False: 4]
  |  Branch (2213:16): [True: 0, False: 184]
  |  Branch (2213:50): [True: 0, False: 4]
  ------------------
 2214|    188|  constexpr size_t str_size = 3;
 2215|    188|  auto size = str_size + (s != sign::none ? 1 : 0);
  ------------------
  |  Branch (2215:27): [True: 180, False: 8]
  ------------------
 2216|       |  // Replace '0'-padding with space for non-finite values.
 2217|    188|  const bool is_zero_fill =
 2218|    188|      specs.fill_size() == 1 && specs.fill_unit<Char>() == '0';
  ------------------
  |  Branch (2218:7): [True: 188, False: 0]
  |  Branch (2218:33): [True: 0, False: 188]
  ------------------
 2219|    188|  if (is_zero_fill) specs.set_fill(' ');
  ------------------
  |  Branch (2219:7): [True: 0, False: 188]
  ------------------
 2220|    188|  return write_padded<Char>(out, specs, size,
 2221|    188|                            [=](reserve_iterator<OutputIt> it) {
 2222|    188|                              if (s != sign::none)
 2223|    188|                                *it++ = detail::getsign<Char>(s);
 2224|    188|                              return copy<Char>(str, str + str_size, it);
 2225|    188|                            });
 2226|    188|}
_ZN3fmt3v116detail12write_paddedIcLNS0_5alignE1ENS0_14basic_appenderIcEEZNS1_15write_nonfiniteIcS5_EET0_S7_bNS0_12format_specsENS0_4signEEUlS5_E_EET1_SB_RKS8_mOT2_:
 1653|    188|                            size_t size, F&& f) -> OutputIt {
 1654|    188|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1655|    188|}
_ZN3fmt3v116detail12write_paddedIcLNS0_5alignE1ENS0_14basic_appenderIcEERZNS1_15write_nonfiniteIcS5_EET0_S7_bNS0_12format_specsENS0_4signEEUlS5_E_EET1_SC_RKS8_mmOT2_:
 1632|    188|                                size_t size, size_t width, F&& f) -> OutputIt {
 1633|    188|  static_assert(default_align == align::left || default_align == align::right,
 1634|    188|                "");
 1635|    188|  unsigned spec_width = to_unsigned(specs.width);
 1636|    188|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1636:20): [True: 0, False: 188]
  ------------------
 1637|       |  // Shifts are encoded as string literals because static constexpr is not
 1638|       |  // supported in constexpr functions.
 1639|    188|  auto* shifts =
 1640|    188|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1640:7): [Folded - Ignored]
  ------------------
 1641|    188|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1642|    188|  size_t right_padding = padding - left_padding;
 1643|    188|  auto it = reserve(out, size + padding * specs.fill_size());
 1644|    188|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1644:7): [True: 0, False: 188]
  ------------------
 1645|    188|  it = f(it);
 1646|    188|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1646:7): [True: 0, False: 188]
  ------------------
 1647|    188|  return base_iterator(out, it);
 1648|    188|}
_ZZN3fmt3v116detail15write_nonfiniteIcNS0_14basic_appenderIcEEEET0_S5_bNS0_12format_specsENS0_4signEENKUlS4_E_clES4_:
 2221|    188|                            [=](reserve_iterator<OutputIt> it) {
 2222|    188|                              if (s != sign::none)
  ------------------
  |  Branch (2222:35): [True: 180, False: 8]
  ------------------
 2223|    180|                                *it++ = detail::getsign<Char>(s);
 2224|    188|                              return copy<Char>(str, str + str_size, it);
 2225|    188|                            });
_ZN3fmt3v116detail14write_exponentIcNS0_14basic_appenderIcEEEET0_iS5_:
 1492|  1.00k|FMT_CONSTEXPR auto write_exponent(int exp, OutputIt out) -> OutputIt {
 1493|  1.00k|  FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range");
  ------------------
  |  |  397|  2.00k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:7): [True: 1.00k, False: 0]
  |  |  |  Branch (397:7): [True: 1.00k, False: 0]
  |  |  ------------------
  |  |  398|  1.00k|         ? (void)0                                                          \
  |  |  399|  1.00k|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1494|  1.00k|  if (exp < 0) {
  ------------------
  |  Branch (1494:7): [True: 636, False: 365]
  ------------------
 1495|    636|    *out++ = static_cast<Char>('-');
 1496|    636|    exp = -exp;
 1497|    636|  } else {
 1498|    365|    *out++ = static_cast<Char>('+');
 1499|    365|  }
 1500|  1.00k|  auto uexp = static_cast<uint32_t>(exp);
 1501|  1.00k|  if (is_constant_evaluated()) {
  ------------------
  |  Branch (1501:7): [Folded - Ignored]
  ------------------
 1502|      0|    if (uexp < 10) *out++ = '0';
  ------------------
  |  Branch (1502:9): [True: 0, False: 0]
  ------------------
 1503|      0|    return format_decimal<Char>(out, uexp, count_digits(uexp));
 1504|      0|  }
 1505|  1.00k|  if (uexp >= 100u) {
  ------------------
  |  Branch (1505:7): [True: 744, False: 257]
  ------------------
 1506|    744|    const char* top = digits2(uexp / 100);
 1507|    744|    if (uexp >= 1000u) *out++ = static_cast<Char>(top[0]);
  ------------------
  |  Branch (1507:9): [True: 0, False: 744]
  ------------------
 1508|    744|    *out++ = static_cast<Char>(top[1]);
 1509|    744|    uexp %= 100;
 1510|    744|  }
 1511|  1.00k|  const char* d = digits2(uexp);
 1512|  1.00k|  *out++ = static_cast<Char>(d[0]);
 1513|  1.00k|  *out++ = static_cast<Char>(d[1]);
 1514|  1.00k|  return out;
 1515|  1.00k|}
_ZN3fmt3v116detail14digit_groupingIcEC2INS1_10locale_refETnNSt3__19enable_ifIXsr3std7is_sameIT_S5_EE5valueEiE4typeELi0EEES8_b:
 1846|    667|  explicit digit_grouping(Locale loc, bool localized = true) {
 1847|    667|    if (!localized) return;
  ------------------
  |  Branch (1847:9): [True: 667, False: 0]
  ------------------
 1848|      0|    auto sep = thousands_sep<Char>(loc);
 1849|      0|    grouping_ = sep.grouping;
 1850|      0|    if (sep.thousands_sep) thousands_sep_.assign(1, sep.thousands_sep);
  ------------------
  |  Branch (1850:9): [True: 0, False: 0]
  ------------------
 1851|      0|  }
_ZNK3fmt3v116detail14digit_groupingIcE16count_separatorsEi:
 1857|    667|  auto count_separators(int num_digits) const -> int {
 1858|    667|    int count = 0;
 1859|    667|    auto state = initial_state();
 1860|    667|    while (num_digits > next(state)) ++count;
  ------------------
  |  Branch (1860:12): [True: 0, False: 667]
  ------------------
 1861|    667|    return count;
 1862|    667|  }
_ZNK3fmt3v116detail14digit_groupingIcE13initial_stateEv:
 1831|    667|  auto initial_state() const -> next_state { return {grouping_.begin(), 0}; }
_ZNK3fmt3v116detail14digit_groupingIcE4nextERNS3_10next_stateE:
 1834|    667|  auto next(next_state& state) const -> int {
 1835|    667|    if (thousands_sep_.empty()) return max_value<int>();
  ------------------
  |  Branch (1835:9): [True: 667, False: 0]
  ------------------
 1836|      0|    if (state.group == grouping_.end()) return state.pos += grouping_.back();
  ------------------
  |  Branch (1836:9): [True: 0, False: 0]
  ------------------
 1837|      0|    if (*state.group <= 0 || *state.group == max_value<char>())
  ------------------
  |  Branch (1837:9): [True: 0, False: 0]
  |  Branch (1837:30): [True: 0, False: 0]
  ------------------
 1838|      0|      return max_value<int>();
 1839|      0|    state.pos += *state.group++;
 1840|      0|    return state.pos;
 1841|      0|  }
_ZNK3fmt3v116detail14digit_groupingIcE13has_separatorEv:
 1855|    667|  auto has_separator() const -> bool { return !thousands_sep_.empty(); }
_ZN3fmt3v116detail21default_arg_formatterIcEclIdTnNSt3__19enable_ifIXsr10is_builtinIT_EE5valueEiE4typeELi0EEEvS7_:
 3475|  1.02k|  void operator()(T value) {
 3476|  1.02k|    write<Char>(out, value);
 3477|  1.02k|  }
_ZN3fmt3v116detail5writeIcNS0_14basic_appenderIcEEdTnNSt3__19enable_ifIXsr13is_fast_floatIT1_EE5valueEiE4typeELi0EEET0_SA_S7_:
 3366|  1.02k|FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt {
 3367|  1.02k|  if (is_constant_evaluated()) return write<Char>(out, value, format_specs());
  ------------------
  |  Branch (3367:7): [Folded - Ignored]
  ------------------
 3368|       |
 3369|  1.02k|  auto s = detail::signbit(value) ? sign::minus : sign::none;
  ------------------
  |  Branch (3369:12): [True: 460, False: 561]
  ------------------
 3370|       |
 3371|  1.02k|  constexpr auto specs = format_specs();
 3372|  1.02k|  using floaty = conditional_t<sizeof(T) >= sizeof(double), double, float>;
 3373|  1.02k|  using floaty_uint = typename dragonbox::float_info<floaty>::carrier_uint;
 3374|  1.02k|  floaty_uint mask = exponent_mask<floaty>();
 3375|  1.02k|  if ((bit_cast<floaty_uint>(value) & mask) == mask)
  ------------------
  |  Branch (3375:7): [True: 94, False: 927]
  ------------------
 3376|     94|    return write_nonfinite<Char>(out, std::isnan(value), specs, s);
 3377|       |
 3378|    927|  auto dec = dragonbox::to_decimal(static_cast<floaty>(value));
 3379|    927|  return write_float<Char>(out, dec, specs, s, exp_upper<T>(), {});
 3380|  1.02k|}
_ZN3fmt3v116detail7signbitIdTnNSt3__19enable_ifIXsr17is_floating_pointIT_EE5valueEiE4typeELi0EEEbS5_:
 2491|  2.04k|FMT_INLINE FMT_CONSTEXPR bool signbit(T value) {
 2492|  2.04k|  if (is_constant_evaluated()) {
  ------------------
  |  Branch (2492:7): [Folded - Ignored]
  ------------------
 2493|       |#ifdef __cpp_if_constexpr
 2494|       |    if constexpr (std::numeric_limits<double>::is_iec559) {
 2495|       |      auto bits = detail::bit_cast<uint64_t>(static_cast<double>(value));
 2496|       |      return (bits >> (num_bits<uint64_t>() - 1)) != 0;
 2497|       |    }
 2498|       |#endif
 2499|      0|  }
 2500|  2.04k|  return std::signbit(static_cast<double>(value));
 2501|  2.04k|}
_ZN3fmt3v116detail11write_floatIcNS0_14basic_appenderIcEENS1_9dragonbox10decimal_fpIdEEEET0_S8_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refE:
 2454|    927|                                 int exp_upper, locale_ref loc) -> OutputIt {
 2455|    927|  if (is_constant_evaluated()) {
  ------------------
  |  Branch (2455:7): [Folded - Ignored]
  ------------------
 2456|      0|    return do_write_float<Char, OutputIt, DecimalFP,
 2457|      0|                          fallback_digit_grouping<Char>>(out, f, specs, s,
 2458|      0|                                                         exp_upper, loc);
 2459|    927|  } else {
 2460|    927|    return do_write_float<Char>(out, f, specs, s, exp_upper, loc);
 2461|    927|  }
 2462|    927|}
_ZN3fmt3v116detail14do_write_floatIcNS0_14basic_appenderIcEENS1_9dragonbox10decimal_fpIdEENS1_14digit_groupingIcEEEET0_SA_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refE:
 2335|    927|                                    int exp_upper, locale_ref loc) -> OutputIt {
 2336|    927|  auto significand = f.significand;
 2337|    927|  int significand_size = get_significand_size(f);
 2338|    927|  const Char zero = static_cast<Char>('0');
 2339|    927|  size_t size = to_unsigned(significand_size) + (s != sign::none ? 1 : 0);
  ------------------
  |  Branch (2339:50): [True: 370, False: 557]
  ------------------
 2340|    927|  using iterator = reserve_iterator<OutputIt>;
 2341|       |
 2342|    927|  Char decimal_point = specs.localized() ? detail::decimal_point<Char>(loc)
  ------------------
  |  Branch (2342:24): [True: 0, False: 927]
  ------------------
 2343|    927|                                         : static_cast<Char>('.');
 2344|       |
 2345|    927|  int output_exp = f.exponent + significand_size - 1;
 2346|    927|  auto use_exp_format = [=]() {
 2347|    927|    if (specs.type() == presentation_type::exp) return true;
 2348|    927|    if (specs.type() == presentation_type::fixed) return false;
 2349|       |    // Use the fixed notation if the exponent is in [exp_lower, exp_upper),
 2350|       |    // e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation.
 2351|    927|    const int exp_lower = -4;
 2352|    927|    return output_exp < exp_lower ||
 2353|    927|           output_exp >= (specs.precision > 0 ? specs.precision : exp_upper);
 2354|    927|  };
 2355|    927|  if (use_exp_format()) {
  ------------------
  |  Branch (2355:7): [True: 517, False: 410]
  ------------------
 2356|    517|    int num_zeros = 0;
 2357|    517|    if (specs.alt()) {
  ------------------
  |  Branch (2357:9): [True: 0, False: 517]
  ------------------
 2358|      0|      num_zeros = specs.precision - significand_size;
 2359|      0|      if (num_zeros < 0) num_zeros = 0;
  ------------------
  |  Branch (2359:11): [True: 0, False: 0]
  ------------------
 2360|      0|      size += to_unsigned(num_zeros);
 2361|    517|    } else if (significand_size == 1) {
  ------------------
  |  Branch (2361:16): [True: 7, False: 510]
  ------------------
 2362|      7|      decimal_point = Char();
 2363|      7|    }
 2364|    517|    auto abs_output_exp = output_exp >= 0 ? output_exp : -output_exp;
  ------------------
  |  Branch (2364:27): [True: 199, False: 318]
  ------------------
 2365|    517|    int exp_digits = 2;
 2366|    517|    if (abs_output_exp >= 100) exp_digits = abs_output_exp >= 1000 ? 4 : 3;
  ------------------
  |  Branch (2366:9): [True: 372, False: 145]
  |  Branch (2366:45): [True: 0, False: 372]
  ------------------
 2367|       |
 2368|    517|    size += to_unsigned((decimal_point ? 1 : 0) + 2 + exp_digits);
  ------------------
  |  Branch (2368:26): [True: 510, False: 7]
  ------------------
 2369|    517|    char exp_char = specs.upper() ? 'E' : 'e';
  ------------------
  |  Branch (2369:21): [True: 0, False: 517]
  ------------------
 2370|    517|    auto write = [=](iterator it) {
 2371|    517|      if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2372|       |      // Insert a decimal point after the first digit and add an exponent.
 2373|    517|      it = write_significand(it, significand, significand_size, 1,
 2374|    517|                             decimal_point);
 2375|    517|      if (num_zeros > 0) it = detail::fill_n(it, num_zeros, zero);
 2376|    517|      *it++ = static_cast<Char>(exp_char);
 2377|    517|      return write_exponent<Char>(output_exp, it);
 2378|    517|    };
 2379|    517|    return specs.width > 0
  ------------------
  |  Branch (2379:12): [True: 0, False: 517]
  ------------------
 2380|    517|               ? write_padded<Char, align::right>(out, specs, size, write)
 2381|    517|               : base_iterator(out, write(reserve(out, size)));
 2382|    517|  }
 2383|       |
 2384|    410|  int exp = f.exponent + significand_size;
 2385|    410|  if (f.exponent >= 0) {
  ------------------
  |  Branch (2385:7): [True: 155, False: 255]
  ------------------
 2386|       |    // 1234e5 -> 123400000[.0+]
 2387|    155|    size += to_unsigned(f.exponent);
 2388|    155|    int num_zeros = specs.precision - exp;
 2389|    155|    abort_fuzzing_if(num_zeros > 5000);
 2390|    155|    if (specs.alt()) {
  ------------------
  |  Branch (2390:9): [True: 0, False: 155]
  ------------------
 2391|      0|      ++size;
 2392|      0|      if (num_zeros <= 0 && specs.type() != presentation_type::fixed)
  ------------------
  |  Branch (2392:11): [True: 0, False: 0]
  |  Branch (2392:29): [True: 0, False: 0]
  ------------------
 2393|      0|        num_zeros = 0;
 2394|      0|      if (num_zeros > 0) size += to_unsigned(num_zeros);
  ------------------
  |  Branch (2394:11): [True: 0, False: 0]
  ------------------
 2395|      0|    }
 2396|    155|    auto grouping = Grouping(loc, specs.localized());
 2397|    155|    size += to_unsigned(grouping.count_separators(exp));
 2398|    155|    return write_padded<Char, align::right>(out, specs, size, [&](iterator it) {
 2399|    155|      if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2400|    155|      it = write_significand<Char>(it, significand, significand_size,
 2401|    155|                                   f.exponent, grouping);
 2402|    155|      if (!specs.alt()) return it;
 2403|    155|      *it++ = decimal_point;
 2404|    155|      return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
 2405|    155|    });
 2406|    255|  } else if (exp > 0) {
  ------------------
  |  Branch (2406:14): [True: 162, False: 93]
  ------------------
 2407|       |    // 1234e-2 -> 12.34[0+]
 2408|    162|    int num_zeros = specs.alt() ? specs.precision - significand_size : 0;
  ------------------
  |  Branch (2408:21): [True: 0, False: 162]
  ------------------
 2409|    162|    size += 1 + static_cast<unsigned>(max_of(num_zeros, 0));
 2410|    162|    auto grouping = Grouping(loc, specs.localized());
 2411|    162|    size += to_unsigned(grouping.count_separators(exp));
 2412|    162|    return write_padded<Char, align::right>(out, specs, size, [&](iterator it) {
 2413|    162|      if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2414|    162|      it = write_significand(it, significand, significand_size, exp,
 2415|    162|                             decimal_point, grouping);
 2416|    162|      return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
 2417|    162|    });
 2418|    162|  }
 2419|       |  // 1234e-6 -> 0.001234
 2420|     93|  int num_zeros = -exp;
 2421|     93|  if (significand_size == 0 && specs.precision >= 0 &&
  ------------------
  |  Branch (2421:7): [True: 0, False: 93]
  |  Branch (2421:32): [True: 0, False: 0]
  ------------------
 2422|     93|      specs.precision < num_zeros) {
  ------------------
  |  Branch (2422:7): [True: 0, False: 0]
  ------------------
 2423|      0|    num_zeros = specs.precision;
 2424|      0|  }
 2425|     93|  bool pointy = num_zeros != 0 || significand_size != 0 || specs.alt();
  ------------------
  |  Branch (2425:17): [True: 34, False: 59]
  |  Branch (2425:35): [True: 59, False: 0]
  |  Branch (2425:60): [True: 0, False: 0]
  ------------------
 2426|     93|  size += 1 + (pointy ? 1 : 0) + to_unsigned(num_zeros);
  ------------------
  |  Branch (2426:16): [True: 93, False: 0]
  ------------------
 2427|     93|  return write_padded<Char, align::right>(out, specs, size, [&](iterator it) {
 2428|     93|    if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2429|     93|    *it++ = zero;
 2430|     93|    if (!pointy) return it;
 2431|     93|    *it++ = decimal_point;
 2432|     93|    it = detail::fill_n(it, num_zeros, zero);
 2433|     93|    return write_significand<Char>(it, significand, significand_size);
 2434|     93|  });
 2435|    410|}
_ZN3fmt3v116detail20get_significand_sizeIdEEiRKNS1_9dragonbox10decimal_fpIT_EE:
 2239|    927|inline auto get_significand_size(const dragonbox::decimal_fp<T>& f) -> int {
 2240|    927|  return count_digits(f.significand);
 2241|    927|}
_ZZN3fmt3v116detail14do_write_floatIcNS0_14basic_appenderIcEENS1_9dragonbox10decimal_fpIdEENS1_14digit_groupingIcEEEET0_SA_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refEENKUlvE_clEv:
 2346|    927|  auto use_exp_format = [=]() {
 2347|    927|    if (specs.type() == presentation_type::exp) return true;
  ------------------
  |  Branch (2347:9): [True: 0, False: 927]
  ------------------
 2348|    927|    if (specs.type() == presentation_type::fixed) return false;
  ------------------
  |  Branch (2348:9): [True: 0, False: 927]
  ------------------
 2349|       |    // Use the fixed notation if the exponent is in [exp_lower, exp_upper),
 2350|       |    // e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation.
 2351|    927|    const int exp_lower = -4;
 2352|    927|    return output_exp < exp_lower ||
  ------------------
  |  Branch (2352:12): [True: 318, False: 609]
  ------------------
 2353|    927|           output_exp >= (specs.precision > 0 ? specs.precision : exp_upper);
  ------------------
  |  Branch (2353:12): [True: 199, False: 410]
  |  Branch (2353:27): [True: 0, False: 609]
  ------------------
 2354|    927|  };
_ZZN3fmt3v116detail14do_write_floatIcNS0_14basic_appenderIcEENS1_9dragonbox10decimal_fpIdEENS1_14digit_groupingIcEEEET0_SA_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refEENKUlS4_E_clES4_:
 2370|    517|    auto write = [=](iterator it) {
 2371|    517|      if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2371:11): [True: 196, False: 321]
  ------------------
 2372|       |      // Insert a decimal point after the first digit and add an exponent.
 2373|    517|      it = write_significand(it, significand, significand_size, 1,
 2374|    517|                             decimal_point);
 2375|    517|      if (num_zeros > 0) it = detail::fill_n(it, num_zeros, zero);
  ------------------
  |  Branch (2375:11): [True: 0, False: 517]
  ------------------
 2376|    517|      *it++ = static_cast<Char>(exp_char);
 2377|    517|      return write_exponent<Char>(output_exp, it);
 2378|    517|    };
_ZN3fmt3v116detail17write_significandINS0_14basic_appenderIcEEmcTnNSt3__19enable_ifIXntsr3std10is_pointerINS5_9remove_cvINS5_16remove_referenceIT_E4typeEE4typeEEE5valueEiE4typeELi0EEES9_S9_T0_iiT1_:
 2293|    679|                              Char decimal_point) -> OutputIt {
 2294|       |  // Buffer is large enough to hold digits (digits10 + 1) and a decimal point.
 2295|    679|  Char buffer[digits10<UInt>() + 2];
 2296|    679|  auto end = write_significand(buffer, significand, significand_size,
 2297|    679|                               integral_size, decimal_point);
 2298|    679|  return detail::copy_noinline<Char>(buffer, end, out);
 2299|    679|}
_ZN3fmt3v116detail17write_significandIcmTnNSt3__19enable_ifIXsr3std11is_integralIT0_EE5valueEiE4typeELi0EEEPT_S9_S5_iiS8_:
 2270|    679|                              int integral_size, Char decimal_point) -> Char* {
 2271|    679|  if (!decimal_point) return format_decimal(out, significand, significand_size);
  ------------------
  |  Branch (2271:7): [True: 7, False: 672]
  ------------------
 2272|    672|  out += significand_size + 1;
 2273|    672|  Char* end = out;
 2274|    672|  int floating_size = significand_size - integral_size;
 2275|  4.68k|  for (int i = floating_size / 2; i > 0; --i) {
  ------------------
  |  Branch (2275:35): [True: 4.01k, False: 672]
  ------------------
 2276|  4.01k|    out -= 2;
 2277|  4.01k|    write2digits(out, static_cast<std::size_t>(significand % 100));
 2278|  4.01k|    significand /= 100;
 2279|  4.01k|  }
 2280|    672|  if (floating_size % 2 != 0) {
  ------------------
  |  Branch (2280:7): [True: 349, False: 323]
  ------------------
 2281|    349|    *--out = static_cast<Char>('0' + significand % 10);
 2282|    349|    significand /= 10;
 2283|    349|  }
 2284|    672|  *--out = decimal_point;
 2285|    672|  format_decimal(out - integral_size, significand, integral_size);
 2286|    672|  return end;
 2287|    679|}
_ZN3fmt3v116detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEEZNS1_14do_write_floatIcS5_NS1_9dragonbox10decimal_fpIdEENS1_14digit_groupingIcEEEET0_SC_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refEEUlS5_E0_EESD_SD_SI_mOT2_:
 1653|    155|                            size_t size, F&& f) -> OutputIt {
 1654|    155|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1655|    155|}
_ZN3fmt3v116detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEERZNS1_14do_write_floatIcS5_NS1_9dragonbox10decimal_fpIdEENS1_14digit_groupingIcEEEET0_SC_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refEEUlS5_E0_EESD_SD_SI_mmOT2_:
 1632|    155|                                size_t size, size_t width, F&& f) -> OutputIt {
 1633|    155|  static_assert(default_align == align::left || default_align == align::right,
 1634|    155|                "");
 1635|    155|  unsigned spec_width = to_unsigned(specs.width);
 1636|    155|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1636:20): [True: 0, False: 155]
  ------------------
 1637|       |  // Shifts are encoded as string literals because static constexpr is not
 1638|       |  // supported in constexpr functions.
 1639|    155|  auto* shifts =
 1640|    155|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1640:7): [Folded - Ignored]
  ------------------
 1641|    155|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1642|    155|  size_t right_padding = padding - left_padding;
 1643|    155|  auto it = reserve(out, size + padding * specs.fill_size());
 1644|    155|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1644:7): [True: 0, False: 155]
  ------------------
 1645|    155|  it = f(it);
 1646|    155|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1646:7): [True: 0, False: 155]
  ------------------
 1647|    155|  return base_iterator(out, it);
 1648|    155|}
_ZZN3fmt3v116detail14do_write_floatIcNS0_14basic_appenderIcEENS1_9dragonbox10decimal_fpIdEENS1_14digit_groupingIcEEEET0_SA_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refEENKUlS4_E0_clES4_:
 2398|    155|    return write_padded<Char, align::right>(out, specs, size, [&](iterator it) {
 2399|    155|      if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2399:11): [True: 75, False: 80]
  ------------------
 2400|    155|      it = write_significand<Char>(it, significand, significand_size,
 2401|    155|                                   f.exponent, grouping);
 2402|    155|      if (!specs.alt()) return it;
  ------------------
  |  Branch (2402:11): [True: 155, False: 0]
  ------------------
 2403|      0|      *it++ = decimal_point;
 2404|      0|      return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
  ------------------
  |  Branch (2404:14): [True: 0, False: 0]
  ------------------
 2405|    155|    });
_ZN3fmt3v116detail17write_significandIcNS0_14basic_appenderIcEEmNS1_14digit_groupingIcEEEET0_S7_T1_iiRKT2_:
 2256|    155|                                       const Grouping& grouping) -> OutputIt {
 2257|    155|  if (!grouping.has_separator()) {
  ------------------
  |  Branch (2257:7): [True: 155, False: 0]
  ------------------
 2258|    155|    out = write_significand<Char>(out, significand, significand_size);
 2259|    155|    return detail::fill_n(out, exponent, static_cast<Char>('0'));
 2260|    155|  }
 2261|      0|  auto buffer = memory_buffer();
 2262|      0|  write_significand<char>(appender(buffer), significand, significand_size);
 2263|      0|  detail::fill_n(appender(buffer), exponent, '0');
 2264|      0|  return grouping.apply(out, string_view(buffer.data(), buffer.size()));
 2265|    155|}
_ZN3fmt3v116detail17write_significandIcNS0_14basic_appenderIcEEmEET0_S5_T1_i:
 2250|    248|                              int significand_size) -> OutputIt {
 2251|    248|  return format_decimal<Char>(out, significand, significand_size);
 2252|    248|}
_ZN3fmt3v116detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEEZNS1_14do_write_floatIcS5_NS1_9dragonbox10decimal_fpIdEENS1_14digit_groupingIcEEEET0_SC_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refEEUlS5_E1_EESD_SD_SI_mOT2_:
 1653|    162|                            size_t size, F&& f) -> OutputIt {
 1654|    162|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1655|    162|}
_ZN3fmt3v116detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEERZNS1_14do_write_floatIcS5_NS1_9dragonbox10decimal_fpIdEENS1_14digit_groupingIcEEEET0_SC_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refEEUlS5_E1_EESD_SD_SI_mmOT2_:
 1632|    162|                                size_t size, size_t width, F&& f) -> OutputIt {
 1633|    162|  static_assert(default_align == align::left || default_align == align::right,
 1634|    162|                "");
 1635|    162|  unsigned spec_width = to_unsigned(specs.width);
 1636|    162|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1636:20): [True: 0, False: 162]
  ------------------
 1637|       |  // Shifts are encoded as string literals because static constexpr is not
 1638|       |  // supported in constexpr functions.
 1639|    162|  auto* shifts =
 1640|    162|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1640:7): [Folded - Ignored]
  ------------------
 1641|    162|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1642|    162|  size_t right_padding = padding - left_padding;
 1643|    162|  auto it = reserve(out, size + padding * specs.fill_size());
 1644|    162|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1644:7): [True: 0, False: 162]
  ------------------
 1645|    162|  it = f(it);
 1646|    162|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1646:7): [True: 0, False: 162]
  ------------------
 1647|    162|  return base_iterator(out, it);
 1648|    162|}
_ZZN3fmt3v116detail14do_write_floatIcNS0_14basic_appenderIcEENS1_9dragonbox10decimal_fpIdEENS1_14digit_groupingIcEEEET0_SA_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refEENKUlS4_E1_clES4_:
 2412|    162|    return write_padded<Char, align::right>(out, specs, size, [&](iterator it) {
 2413|    162|      if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2413:11): [True: 55, False: 107]
  ------------------
 2414|    162|      it = write_significand(it, significand, significand_size, exp,
 2415|    162|                             decimal_point, grouping);
 2416|    162|      return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
  ------------------
  |  Branch (2416:14): [True: 0, False: 162]
  ------------------
 2417|    162|    });
_ZN3fmt3v116detail17write_significandINS0_14basic_appenderIcEEcmNS1_14digit_groupingIcEEEET_S7_T1_iiT0_RKT2_:
 2317|    162|                                       const Grouping& grouping) -> OutputIt {
 2318|    162|  if (!grouping.has_separator()) {
  ------------------
  |  Branch (2318:7): [True: 162, False: 0]
  ------------------
 2319|    162|    return write_significand(out, significand, significand_size, integral_size,
 2320|    162|                             decimal_point);
 2321|    162|  }
 2322|      0|  auto buffer = basic_memory_buffer<Char>();
 2323|      0|  write_significand(basic_appender<Char>(buffer), significand, significand_size,
 2324|      0|                    integral_size, decimal_point);
 2325|      0|  grouping.apply(
 2326|      0|      out, basic_string_view<Char>(buffer.data(), to_unsigned(integral_size)));
 2327|      0|  return detail::copy_noinline<Char>(buffer.data() + integral_size,
 2328|      0|                                     buffer.end(), out);
 2329|    162|}
_ZN3fmt3v116detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEEZNS1_14do_write_floatIcS5_NS1_9dragonbox10decimal_fpIdEENS1_14digit_groupingIcEEEET0_SC_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refEEUlS5_E2_EESD_SD_SI_mOT2_:
 1653|     93|                            size_t size, F&& f) -> OutputIt {
 1654|     93|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1655|     93|}
_ZN3fmt3v116detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEERZNS1_14do_write_floatIcS5_NS1_9dragonbox10decimal_fpIdEENS1_14digit_groupingIcEEEET0_SC_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refEEUlS5_E2_EESD_SD_SI_mmOT2_:
 1632|     93|                                size_t size, size_t width, F&& f) -> OutputIt {
 1633|     93|  static_assert(default_align == align::left || default_align == align::right,
 1634|     93|                "");
 1635|     93|  unsigned spec_width = to_unsigned(specs.width);
 1636|     93|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1636:20): [True: 0, False: 93]
  ------------------
 1637|       |  // Shifts are encoded as string literals because static constexpr is not
 1638|       |  // supported in constexpr functions.
 1639|     93|  auto* shifts =
 1640|     93|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1640:7): [Folded - Ignored]
  ------------------
 1641|     93|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1642|     93|  size_t right_padding = padding - left_padding;
 1643|     93|  auto it = reserve(out, size + padding * specs.fill_size());
 1644|     93|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1644:7): [True: 0, False: 93]
  ------------------
 1645|     93|  it = f(it);
 1646|     93|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1646:7): [True: 0, False: 93]
  ------------------
 1647|     93|  return base_iterator(out, it);
 1648|     93|}
_ZZN3fmt3v116detail14do_write_floatIcNS0_14basic_appenderIcEENS1_9dragonbox10decimal_fpIdEENS1_14digit_groupingIcEEEET0_SA_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refEENKUlS4_E2_clES4_:
 2427|     93|  return write_padded<Char, align::right>(out, specs, size, [&](iterator it) {
 2428|     93|    if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2428:9): [True: 44, False: 49]
  ------------------
 2429|     93|    *it++ = zero;
 2430|     93|    if (!pointy) return it;
  ------------------
  |  Branch (2430:9): [True: 0, False: 93]
  ------------------
 2431|     93|    *it++ = decimal_point;
 2432|     93|    it = detail::fill_n(it, num_zeros, zero);
 2433|     93|    return write_significand<Char>(it, significand, significand_size);
 2434|     93|  });
_ZN3fmt3v116detail9exp_upperIdEEiv:
 3294|    927|template <typename T> constexpr auto exp_upper() -> int {
 3295|    927|  return std::numeric_limits<T>::digits10 != 0
  ------------------
  |  Branch (3295:10): [Folded - Ignored]
  ------------------
 3296|    927|             ? min_of(16, std::numeric_limits<T>::digits10 + 1)
 3297|    927|             : 16;
 3298|    927|}
_ZN3fmt3v116detail8basic_fpIoEC2Ev:
 1525|    925|  constexpr basic_fp() : f(0), e(0) {}
_ZN3fmt3v1119basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEEC2ERKS4_:
  821|  3.70k|      : detail::buffer<T>(grow), alloc_(alloc) {
  822|  3.70k|    this->set(store_, SIZE);
  823|  3.70k|    if (detail::is_constant_evaluated()) detail::fill_n(store_, SIZE, T());
  ------------------
  |  Branch (823:9): [Folded - Ignored]
  ------------------
  824|  3.70k|  }
_ZN3fmt3v1119basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEEC2EOS5_:
  850|  4.10k|      : detail::buffer<T>(grow) {
  851|  4.10k|    move(other);
  852|  4.10k|  }
_ZN3fmt3v1119basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEED2Ev:
  825|  7.80k|  FMT_CONSTEXPR20 ~basic_memory_buffer() { deallocate(); }
_ZN3fmt3v116detail11write_floatIcNS0_14basic_appenderIcEENS1_14big_decimal_fpEEET0_S6_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refE:
 2454|    927|                                 int exp_upper, locale_ref loc) -> OutputIt {
 2455|    927|  if (is_constant_evaluated()) {
  ------------------
  |  Branch (2455:7): [Folded - Ignored]
  ------------------
 2456|      0|    return do_write_float<Char, OutputIt, DecimalFP,
 2457|      0|                          fallback_digit_grouping<Char>>(out, f, specs, s,
 2458|      0|                                                         exp_upper, loc);
 2459|    927|  } else {
 2460|    927|    return do_write_float<Char>(out, f, specs, s, exp_upper, loc);
 2461|    927|  }
 2462|    927|}
_ZN3fmt3v116detail14do_write_floatIcNS0_14basic_appenderIcEENS1_14big_decimal_fpENS1_14digit_groupingIcEEEET0_S8_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refE:
 2335|    927|                                    int exp_upper, locale_ref loc) -> OutputIt {
 2336|    927|  auto significand = f.significand;
 2337|    927|  int significand_size = get_significand_size(f);
 2338|    927|  const Char zero = static_cast<Char>('0');
 2339|    927|  size_t size = to_unsigned(significand_size) + (s != sign::none ? 1 : 0);
  ------------------
  |  Branch (2339:50): [True: 370, False: 557]
  ------------------
 2340|    927|  using iterator = reserve_iterator<OutputIt>;
 2341|       |
 2342|    927|  Char decimal_point = specs.localized() ? detail::decimal_point<Char>(loc)
  ------------------
  |  Branch (2342:24): [True: 0, False: 927]
  ------------------
 2343|    927|                                         : static_cast<Char>('.');
 2344|       |
 2345|    927|  int output_exp = f.exponent + significand_size - 1;
 2346|    927|  auto use_exp_format = [=]() {
 2347|    927|    if (specs.type() == presentation_type::exp) return true;
 2348|    927|    if (specs.type() == presentation_type::fixed) return false;
 2349|       |    // Use the fixed notation if the exponent is in [exp_lower, exp_upper),
 2350|       |    // e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation.
 2351|    927|    const int exp_lower = -4;
 2352|    927|    return output_exp < exp_lower ||
 2353|    927|           output_exp >= (specs.precision > 0 ? specs.precision : exp_upper);
 2354|    927|  };
 2355|    927|  if (use_exp_format()) {
  ------------------
  |  Branch (2355:7): [True: 484, False: 443]
  ------------------
 2356|    484|    int num_zeros = 0;
 2357|    484|    if (specs.alt()) {
  ------------------
  |  Branch (2357:9): [True: 0, False: 484]
  ------------------
 2358|      0|      num_zeros = specs.precision - significand_size;
 2359|      0|      if (num_zeros < 0) num_zeros = 0;
  ------------------
  |  Branch (2359:11): [True: 0, False: 0]
  ------------------
 2360|      0|      size += to_unsigned(num_zeros);
 2361|    484|    } else if (significand_size == 1) {
  ------------------
  |  Branch (2361:16): [True: 0, False: 484]
  ------------------
 2362|      0|      decimal_point = Char();
 2363|      0|    }
 2364|    484|    auto abs_output_exp = output_exp >= 0 ? output_exp : -output_exp;
  ------------------
  |  Branch (2364:27): [True: 166, False: 318]
  ------------------
 2365|    484|    int exp_digits = 2;
 2366|    484|    if (abs_output_exp >= 100) exp_digits = abs_output_exp >= 1000 ? 4 : 3;
  ------------------
  |  Branch (2366:9): [True: 372, False: 112]
  |  Branch (2366:45): [True: 0, False: 372]
  ------------------
 2367|       |
 2368|    484|    size += to_unsigned((decimal_point ? 1 : 0) + 2 + exp_digits);
  ------------------
  |  Branch (2368:26): [True: 484, False: 0]
  ------------------
 2369|    484|    char exp_char = specs.upper() ? 'E' : 'e';
  ------------------
  |  Branch (2369:21): [True: 0, False: 484]
  ------------------
 2370|    484|    auto write = [=](iterator it) {
 2371|    484|      if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2372|       |      // Insert a decimal point after the first digit and add an exponent.
 2373|    484|      it = write_significand(it, significand, significand_size, 1,
 2374|    484|                             decimal_point);
 2375|    484|      if (num_zeros > 0) it = detail::fill_n(it, num_zeros, zero);
 2376|    484|      *it++ = static_cast<Char>(exp_char);
 2377|    484|      return write_exponent<Char>(output_exp, it);
 2378|    484|    };
 2379|    484|    return specs.width > 0
  ------------------
  |  Branch (2379:12): [True: 0, False: 484]
  ------------------
 2380|    484|               ? write_padded<Char, align::right>(out, specs, size, write)
 2381|    484|               : base_iterator(out, write(reserve(out, size)));
 2382|    484|  }
 2383|       |
 2384|    443|  int exp = f.exponent + significand_size;
 2385|    443|  if (f.exponent >= 0) {
  ------------------
  |  Branch (2385:7): [True: 188, False: 255]
  ------------------
 2386|       |    // 1234e5 -> 123400000[.0+]
 2387|    188|    size += to_unsigned(f.exponent);
 2388|    188|    int num_zeros = specs.precision - exp;
 2389|    188|    abort_fuzzing_if(num_zeros > 5000);
 2390|    188|    if (specs.alt()) {
  ------------------
  |  Branch (2390:9): [True: 0, False: 188]
  ------------------
 2391|      0|      ++size;
 2392|      0|      if (num_zeros <= 0 && specs.type() != presentation_type::fixed)
  ------------------
  |  Branch (2392:11): [True: 0, False: 0]
  |  Branch (2392:29): [True: 0, False: 0]
  ------------------
 2393|      0|        num_zeros = 0;
 2394|      0|      if (num_zeros > 0) size += to_unsigned(num_zeros);
  ------------------
  |  Branch (2394:11): [True: 0, False: 0]
  ------------------
 2395|      0|    }
 2396|    188|    auto grouping = Grouping(loc, specs.localized());
 2397|    188|    size += to_unsigned(grouping.count_separators(exp));
 2398|    188|    return write_padded<Char, align::right>(out, specs, size, [&](iterator it) {
 2399|    188|      if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2400|    188|      it = write_significand<Char>(it, significand, significand_size,
 2401|    188|                                   f.exponent, grouping);
 2402|    188|      if (!specs.alt()) return it;
 2403|    188|      *it++ = decimal_point;
 2404|    188|      return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
 2405|    188|    });
 2406|    255|  } else if (exp > 0) {
  ------------------
  |  Branch (2406:14): [True: 162, False: 93]
  ------------------
 2407|       |    // 1234e-2 -> 12.34[0+]
 2408|    162|    int num_zeros = specs.alt() ? specs.precision - significand_size : 0;
  ------------------
  |  Branch (2408:21): [True: 0, False: 162]
  ------------------
 2409|    162|    size += 1 + static_cast<unsigned>(max_of(num_zeros, 0));
 2410|    162|    auto grouping = Grouping(loc, specs.localized());
 2411|    162|    size += to_unsigned(grouping.count_separators(exp));
 2412|    162|    return write_padded<Char, align::right>(out, specs, size, [&](iterator it) {
 2413|    162|      if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2414|    162|      it = write_significand(it, significand, significand_size, exp,
 2415|    162|                             decimal_point, grouping);
 2416|    162|      return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
 2417|    162|    });
 2418|    162|  }
 2419|       |  // 1234e-6 -> 0.001234
 2420|     93|  int num_zeros = -exp;
 2421|     93|  if (significand_size == 0 && specs.precision >= 0 &&
  ------------------
  |  Branch (2421:7): [True: 0, False: 93]
  |  Branch (2421:32): [True: 0, False: 0]
  ------------------
 2422|     93|      specs.precision < num_zeros) {
  ------------------
  |  Branch (2422:7): [True: 0, False: 0]
  ------------------
 2423|      0|    num_zeros = specs.precision;
 2424|      0|  }
 2425|     93|  bool pointy = num_zeros != 0 || significand_size != 0 || specs.alt();
  ------------------
  |  Branch (2425:17): [True: 34, False: 59]
  |  Branch (2425:35): [True: 59, False: 0]
  |  Branch (2425:60): [True: 0, False: 0]
  ------------------
 2426|     93|  size += 1 + (pointy ? 1 : 0) + to_unsigned(num_zeros);
  ------------------
  |  Branch (2426:16): [True: 93, False: 0]
  ------------------
 2427|     93|  return write_padded<Char, align::right>(out, specs, size, [&](iterator it) {
 2428|     93|    if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2429|     93|    *it++ = zero;
 2430|     93|    if (!pointy) return it;
 2431|     93|    *it++ = decimal_point;
 2432|     93|    it = detail::fill_n(it, num_zeros, zero);
 2433|     93|    return write_significand<Char>(it, significand, significand_size);
 2434|     93|  });
 2435|    443|}
_ZZN3fmt3v116detail14do_write_floatIcNS0_14basic_appenderIcEENS1_14big_decimal_fpENS1_14digit_groupingIcEEEET0_S8_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refEENKUlvE_clEv:
 2346|    927|  auto use_exp_format = [=]() {
 2347|    927|    if (specs.type() == presentation_type::exp) return true;
  ------------------
  |  Branch (2347:9): [True: 0, False: 927]
  ------------------
 2348|    927|    if (specs.type() == presentation_type::fixed) return false;
  ------------------
  |  Branch (2348:9): [True: 0, False: 927]
  ------------------
 2349|       |    // Use the fixed notation if the exponent is in [exp_lower, exp_upper),
 2350|       |    // e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation.
 2351|    927|    const int exp_lower = -4;
 2352|    927|    return output_exp < exp_lower ||
  ------------------
  |  Branch (2352:12): [True: 318, False: 609]
  ------------------
 2353|    927|           output_exp >= (specs.precision > 0 ? specs.precision : exp_upper);
  ------------------
  |  Branch (2353:12): [True: 166, False: 443]
  |  Branch (2353:27): [True: 609, False: 0]
  ------------------
 2354|    927|  };
_ZZN3fmt3v116detail14do_write_floatIcNS0_14basic_appenderIcEENS1_14big_decimal_fpENS1_14digit_groupingIcEEEET0_S8_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refEENKUlS4_E_clES4_:
 2370|    484|    auto write = [=](iterator it) {
 2371|    484|      if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2371:11): [True: 181, False: 303]
  ------------------
 2372|       |      // Insert a decimal point after the first digit and add an exponent.
 2373|    484|      it = write_significand(it, significand, significand_size, 1,
 2374|    484|                             decimal_point);
 2375|    484|      if (num_zeros > 0) it = detail::fill_n(it, num_zeros, zero);
  ------------------
  |  Branch (2375:11): [True: 0, False: 484]
  ------------------
 2376|    484|      *it++ = static_cast<Char>(exp_char);
 2377|    484|      return write_exponent<Char>(output_exp, it);
 2378|    484|    };
_ZN3fmt3v116detail17write_significandINS0_14basic_appenderIcEEcEET_S5_PKciiT0_:
 2304|    646|                                     Char decimal_point) -> OutputIt {
 2305|    646|  out = detail::copy_noinline<Char>(significand, significand + integral_size,
 2306|    646|                                    out);
 2307|    646|  if (!decimal_point) return out;
  ------------------
  |  Branch (2307:7): [True: 0, False: 646]
  ------------------
 2308|    646|  *out++ = decimal_point;
 2309|    646|  return detail::copy_noinline<Char>(significand + integral_size,
 2310|    646|                                     significand + significand_size, out);
 2311|    646|}
_ZN3fmt3v116detail13copy_noinlineIcPKcNS0_14basic_appenderIcEEEET1_T0_S8_S7_:
  534|  3.33k|                                              OutputIt out) -> OutputIt {
  535|  3.33k|  return copy<OutChar>(begin, end, out);
  536|  3.33k|}
_ZN3fmt3v116detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEEZNS1_14do_write_floatIcS5_NS1_14big_decimal_fpENS1_14digit_groupingIcEEEET0_SA_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refEEUlS5_E0_EESB_SB_SG_mOT2_:
 1653|    188|                            size_t size, F&& f) -> OutputIt {
 1654|    188|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1655|    188|}
_ZN3fmt3v116detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEERZNS1_14do_write_floatIcS5_NS1_14big_decimal_fpENS1_14digit_groupingIcEEEET0_SA_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refEEUlS5_E0_EESB_SB_SG_mmOT2_:
 1632|    188|                                size_t size, size_t width, F&& f) -> OutputIt {
 1633|    188|  static_assert(default_align == align::left || default_align == align::right,
 1634|    188|                "");
 1635|    188|  unsigned spec_width = to_unsigned(specs.width);
 1636|    188|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1636:20): [True: 0, False: 188]
  ------------------
 1637|       |  // Shifts are encoded as string literals because static constexpr is not
 1638|       |  // supported in constexpr functions.
 1639|    188|  auto* shifts =
 1640|    188|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1640:7): [Folded - Ignored]
  ------------------
 1641|    188|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1642|    188|  size_t right_padding = padding - left_padding;
 1643|    188|  auto it = reserve(out, size + padding * specs.fill_size());
 1644|    188|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1644:7): [True: 0, False: 188]
  ------------------
 1645|    188|  it = f(it);
 1646|    188|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1646:7): [True: 0, False: 188]
  ------------------
 1647|    188|  return base_iterator(out, it);
 1648|    188|}
_ZZN3fmt3v116detail14do_write_floatIcNS0_14basic_appenderIcEENS1_14big_decimal_fpENS1_14digit_groupingIcEEEET0_S8_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refEENKUlS4_E0_clES4_:
 2398|    188|    return write_padded<Char, align::right>(out, specs, size, [&](iterator it) {
 2399|    188|      if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2399:11): [True: 90, False: 98]
  ------------------
 2400|    188|      it = write_significand<Char>(it, significand, significand_size,
 2401|    188|                                   f.exponent, grouping);
 2402|    188|      if (!specs.alt()) return it;
  ------------------
  |  Branch (2402:11): [True: 188, False: 0]
  ------------------
 2403|      0|      *it++ = decimal_point;
 2404|      0|      return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
  ------------------
  |  Branch (2404:14): [True: 0, False: 0]
  ------------------
 2405|    188|    });
_ZN3fmt3v116detail17write_significandIcNS0_14basic_appenderIcEEPKcNS1_14digit_groupingIcEEEET0_S9_T1_iiRKT2_:
 2256|    188|                                       const Grouping& grouping) -> OutputIt {
 2257|    188|  if (!grouping.has_separator()) {
  ------------------
  |  Branch (2257:7): [True: 188, False: 0]
  ------------------
 2258|    188|    out = write_significand<Char>(out, significand, significand_size);
 2259|    188|    return detail::fill_n(out, exponent, static_cast<Char>('0'));
 2260|    188|  }
 2261|      0|  auto buffer = memory_buffer();
 2262|      0|  write_significand<char>(appender(buffer), significand, significand_size);
 2263|      0|  detail::fill_n(appender(buffer), exponent, '0');
 2264|      0|  return grouping.apply(out, string_view(buffer.data(), buffer.size()));
 2265|    188|}
_ZN3fmt3v116detail17write_significandIcNS0_14basic_appenderIcEEEET0_S5_PKci:
 2245|    281|                                 int significand_size) -> OutputIt {
 2246|    281|  return copy<Char>(significand, significand + significand_size, out);
 2247|    281|}
_ZN3fmt3v116detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEEZNS1_14do_write_floatIcS5_NS1_14big_decimal_fpENS1_14digit_groupingIcEEEET0_SA_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refEEUlS5_E1_EESB_SB_SG_mOT2_:
 1653|    162|                            size_t size, F&& f) -> OutputIt {
 1654|    162|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1655|    162|}
_ZN3fmt3v116detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEERZNS1_14do_write_floatIcS5_NS1_14big_decimal_fpENS1_14digit_groupingIcEEEET0_SA_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refEEUlS5_E1_EESB_SB_SG_mmOT2_:
 1632|    162|                                size_t size, size_t width, F&& f) -> OutputIt {
 1633|    162|  static_assert(default_align == align::left || default_align == align::right,
 1634|    162|                "");
 1635|    162|  unsigned spec_width = to_unsigned(specs.width);
 1636|    162|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1636:20): [True: 0, False: 162]
  ------------------
 1637|       |  // Shifts are encoded as string literals because static constexpr is not
 1638|       |  // supported in constexpr functions.
 1639|    162|  auto* shifts =
 1640|    162|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1640:7): [Folded - Ignored]
  ------------------
 1641|    162|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1642|    162|  size_t right_padding = padding - left_padding;
 1643|    162|  auto it = reserve(out, size + padding * specs.fill_size());
 1644|    162|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1644:7): [True: 0, False: 162]
  ------------------
 1645|    162|  it = f(it);
 1646|    162|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1646:7): [True: 0, False: 162]
  ------------------
 1647|    162|  return base_iterator(out, it);
 1648|    162|}
_ZZN3fmt3v116detail14do_write_floatIcNS0_14basic_appenderIcEENS1_14big_decimal_fpENS1_14digit_groupingIcEEEET0_S8_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refEENKUlS4_E1_clES4_:
 2412|    162|    return write_padded<Char, align::right>(out, specs, size, [&](iterator it) {
 2413|    162|      if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2413:11): [True: 55, False: 107]
  ------------------
 2414|    162|      it = write_significand(it, significand, significand_size, exp,
 2415|    162|                             decimal_point, grouping);
 2416|    162|      return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
  ------------------
  |  Branch (2416:14): [True: 0, False: 162]
  ------------------
 2417|    162|    });
_ZN3fmt3v116detail17write_significandINS0_14basic_appenderIcEEcPKcNS1_14digit_groupingIcEEEET_S9_T1_iiT0_RKT2_:
 2317|    162|                                       const Grouping& grouping) -> OutputIt {
 2318|    162|  if (!grouping.has_separator()) {
  ------------------
  |  Branch (2318:7): [True: 162, False: 0]
  ------------------
 2319|    162|    return write_significand(out, significand, significand_size, integral_size,
 2320|    162|                             decimal_point);
 2321|    162|  }
 2322|      0|  auto buffer = basic_memory_buffer<Char>();
 2323|      0|  write_significand(basic_appender<Char>(buffer), significand, significand_size,
 2324|      0|                    integral_size, decimal_point);
 2325|      0|  grouping.apply(
 2326|      0|      out, basic_string_view<Char>(buffer.data(), to_unsigned(integral_size)));
 2327|      0|  return detail::copy_noinline<Char>(buffer.data() + integral_size,
 2328|      0|                                     buffer.end(), out);
 2329|    162|}
_ZN3fmt3v116detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEEZNS1_14do_write_floatIcS5_NS1_14big_decimal_fpENS1_14digit_groupingIcEEEET0_SA_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refEEUlS5_E2_EESB_SB_SG_mOT2_:
 1653|     93|                            size_t size, F&& f) -> OutputIt {
 1654|     93|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1655|     93|}
_ZN3fmt3v116detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEERZNS1_14do_write_floatIcS5_NS1_14big_decimal_fpENS1_14digit_groupingIcEEEET0_SA_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refEEUlS5_E2_EESB_SB_SG_mmOT2_:
 1632|     93|                                size_t size, size_t width, F&& f) -> OutputIt {
 1633|     93|  static_assert(default_align == align::left || default_align == align::right,
 1634|     93|                "");
 1635|     93|  unsigned spec_width = to_unsigned(specs.width);
 1636|     93|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1636:20): [True: 0, False: 93]
  ------------------
 1637|       |  // Shifts are encoded as string literals because static constexpr is not
 1638|       |  // supported in constexpr functions.
 1639|     93|  auto* shifts =
 1640|     93|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1640:7): [Folded - Ignored]
  ------------------
 1641|     93|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1642|     93|  size_t right_padding = padding - left_padding;
 1643|     93|  auto it = reserve(out, size + padding * specs.fill_size());
 1644|     93|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1644:7): [True: 0, False: 93]
  ------------------
 1645|     93|  it = f(it);
 1646|     93|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1646:7): [True: 0, False: 93]
  ------------------
 1647|     93|  return base_iterator(out, it);
 1648|     93|}
_ZZN3fmt3v116detail14do_write_floatIcNS0_14basic_appenderIcEENS1_14big_decimal_fpENS1_14digit_groupingIcEEEET0_S8_RKT1_RKNS0_12format_specsENS0_4signEiNS1_10locale_refEENKUlS4_E2_clES4_:
 2427|     93|  return write_padded<Char, align::right>(out, specs, size, [&](iterator it) {
 2428|     93|    if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2428:9): [True: 44, False: 49]
  ------------------
 2429|     93|    *it++ = zero;
 2430|     93|    if (!pointy) return it;
  ------------------
  |  Branch (2430:9): [True: 0, False: 93]
  ------------------
 2431|     93|    *it++ = decimal_point;
 2432|     93|    it = detail::fill_n(it, num_zeros, zero);
 2433|     93|    return write_significand<Char>(it, significand, significand_size);
 2434|     93|  });
_ZN3fmt3v116detail14format_handlerIcE7on_textEPKcS5_:
 3593|  2.04k|  void on_text(const Char* begin, const Char* end) {
 3594|  2.04k|    copy_noinline<Char>(begin, end, ctx.out());
 3595|  2.04k|  }
_ZN3fmt3v116detail14format_handlerIcE9on_arg_idEv:
 3597|  1.02k|  FMT_CONSTEXPR auto on_arg_id() -> int { return parse_ctx.next_arg_id(); }
_ZN3fmt3v116detail14format_handlerIcE15on_format_specsEiPKcS5_:
 3614|  1.02k|      -> const Char* {
 3615|  1.02k|    auto arg = get_arg(ctx, id);
 3616|       |    // Not using a visitor for custom types gives better codegen.
 3617|  1.02k|    if (arg.format_custom(begin, parse_ctx, ctx)) return parse_ctx.begin();
  ------------------
  |  Branch (3617:9): [True: 0, False: 1.02k]
  ------------------
 3618|       |
 3619|  1.02k|    auto specs = dynamic_format_specs<Char>();
 3620|  1.02k|    begin = parse_format_specs(begin, end, specs, parse_ctx, arg.type());
 3621|  1.02k|    if (specs.dynamic()) {
  ------------------
  |  Branch (3621:9): [True: 0, False: 1.02k]
  ------------------
 3622|      0|      handle_dynamic_spec(specs.dynamic_width(), specs.width, specs.width_ref,
 3623|      0|                          ctx);
 3624|      0|      handle_dynamic_spec(specs.dynamic_precision(), specs.precision,
 3625|      0|                          specs.precision_ref, ctx);
 3626|      0|    }
 3627|       |
 3628|  1.02k|    arg.visit(arg_formatter<Char>{ctx.out(), specs, ctx.locale()});
 3629|  1.02k|    return begin;
 3630|  1.02k|  }
_ZN3fmt3v116detail7get_argINS0_7contextEiEENS0_16basic_format_argIT_EERS5_T0_:
 3527|  1.02k|FMT_CONSTEXPR auto get_arg(Context& ctx, ID id) -> basic_format_arg<Context> {
 3528|  1.02k|  auto arg = ctx.arg(id);
 3529|  1.02k|  if (!arg) report_error("argument not found");
  ------------------
  |  Branch (3529:7): [True: 0, False: 1.02k]
  ------------------
 3530|  1.02k|  return arg;
 3531|  1.02k|}
_ZN3fmt3v116detail12format_floatIdEEiT_iRKNS0_12format_specsEbRNS1_6bufferIcEE:
 2996|    927|                                  buffer<char>& buf) -> int {
 2997|       |  // float is passed as double to reduce the number of instantiations.
 2998|    927|  static_assert(!std::is_same<Float, float>::value, "");
 2999|    927|  auto converted_value = convert_float(value);
 3000|       |
 3001|    927|  const bool fixed = specs.type() == presentation_type::fixed;
 3002|    927|  if (value == 0) {
  ------------------
  |  Branch (3002:7): [True: 2, False: 925]
  ------------------
 3003|      2|    if (precision <= 0 || !fixed) {
  ------------------
  |  Branch (3003:9): [True: 0, False: 2]
  |  Branch (3003:27): [True: 2, False: 0]
  ------------------
 3004|      2|      buf.push_back('0');
 3005|      2|      return 0;
 3006|      2|    }
 3007|      0|    buf.try_resize(to_unsigned(precision));
 3008|      0|    fill_n(buf.data(), precision, '0');
 3009|      0|    return -precision;
 3010|      2|  }
 3011|       |
 3012|    925|  int exp = 0;
 3013|    925|  bool use_dragon = true;
 3014|    925|  unsigned dragon_flags = 0;
 3015|    925|  if (!is_fast_float<Float>() || is_constant_evaluated()) {
  ------------------
  |  Branch (3015:7): [Folded - Ignored]
  |  Branch (3015:7): [Folded - Ignored]
  |  Branch (3015:34): [Folded - Ignored]
  ------------------
 3016|      0|    const auto inv_log2_10 = 0.3010299956639812;  // 1 / log2(10)
 3017|      0|    using info = dragonbox::float_info<decltype(converted_value)>;
 3018|      0|    const auto f = basic_fp<typename info::carrier_uint>(converted_value);
 3019|       |    // Compute exp, an approximate power of 10, such that
 3020|       |    //   10^(exp - 1) <= value < 10^exp or 10^exp <= value < 10^(exp + 1).
 3021|       |    // This is based on log10(value) == log2(value) / log2(10) and approximation
 3022|       |    // of log2(value) by e + num_fraction_bits idea from double-conversion.
 3023|      0|    auto e = (f.e + count_digits<1>(f.f) - 1) * inv_log2_10 - 1e-10;
 3024|      0|    exp = static_cast<int>(e);
 3025|      0|    if (e > exp) ++exp;  // Compute ceil.
  ------------------
  |  Branch (3025:9): [True: 0, False: 0]
  ------------------
 3026|      0|    dragon_flags = dragon::fixup;
 3027|    925|  } else {
 3028|       |    // Extract significand bits and exponent bits.
 3029|    925|    using info = dragonbox::float_info<double>;
 3030|    925|    auto br = bit_cast<uint64_t>(static_cast<double>(value));
 3031|       |
 3032|    925|    const uint64_t significand_mask =
 3033|    925|        (static_cast<uint64_t>(1) << num_significand_bits<double>()) - 1;
 3034|    925|    uint64_t significand = (br & significand_mask);
 3035|    925|    int exponent = static_cast<int>((br & exponent_mask<double>()) >>
 3036|    925|                                    num_significand_bits<double>());
 3037|       |
 3038|    925|    if (exponent != 0) {  // Check if normal.
  ------------------
  |  Branch (3038:9): [True: 805, False: 120]
  ------------------
 3039|    805|      exponent -= exponent_bias<double>() + num_significand_bits<double>();
 3040|    805|      significand |=
 3041|    805|          (static_cast<uint64_t>(1) << num_significand_bits<double>());
 3042|    805|      significand <<= 1;
 3043|    805|    } else {
 3044|       |      // Normalize subnormal inputs.
 3045|    120|      FMT_ASSERT(significand != 0, "zeros should not appear here");
  ------------------
  |  |  397|    120|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:6): [True: 120, False: 0]
  |  |  ------------------
  |  |  398|    120|         ? (void)0                                                          \
  |  |  399|    120|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 3046|    120|      int shift = countl_zero(significand);
 3047|    120|      FMT_ASSERT(shift >= num_bits<uint64_t>() - num_significand_bits<double>(),
  ------------------
  |  |  397|    120|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (397:6): [True: 120, False: 0]
  |  |  ------------------
  |  |  398|    120|         ? (void)0                                                          \
  |  |  399|    120|         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 3048|    120|                 "");
 3049|    120|      shift -= (num_bits<uint64_t>() - num_significand_bits<double>() - 2);
 3050|    120|      exponent = (std::numeric_limits<double>::min_exponent -
 3051|    120|                  num_significand_bits<double>()) -
 3052|    120|                 shift;
 3053|    120|      significand <<= shift;
 3054|    120|    }
 3055|       |
 3056|       |    // Compute the first several nonzero decimal significand digits.
 3057|       |    // We call the number we get the first segment.
 3058|    925|    const int k = info::kappa - dragonbox::floor_log10_pow2(exponent);
 3059|    925|    exp = -k;
 3060|    925|    const int beta = exponent + dragonbox::floor_log2_pow10(k);
 3061|    925|    uint64_t first_segment;
 3062|    925|    bool has_more_segments;
 3063|    925|    int digits_in_the_first_segment;
 3064|    925|    {
 3065|    925|      const auto r = dragonbox::umul192_upper128(
 3066|    925|          significand << beta, dragonbox::get_cached_power(k));
 3067|    925|      first_segment = r.high();
 3068|    925|      has_more_segments = r.low() != 0;
 3069|       |
 3070|       |      // The first segment can have 18 ~ 19 digits.
 3071|    925|      if (first_segment >= 1000000000000000000ULL) {
  ------------------
  |  Branch (3071:11): [True: 630, False: 295]
  ------------------
 3072|    630|        digits_in_the_first_segment = 19;
 3073|    630|      } else {
 3074|       |        // When it is of 18-digits, we align it to 19-digits by adding a bogus
 3075|       |        // zero at the end.
 3076|    295|        digits_in_the_first_segment = 18;
 3077|    295|        first_segment *= 10;
 3078|    295|      }
 3079|    925|    }
 3080|       |
 3081|       |    // Compute the actual number of decimal digits to print.
 3082|    925|    if (fixed) adjust_precision(precision, exp + digits_in_the_first_segment);
  ------------------
  |  Branch (3082:9): [True: 0, False: 925]
  ------------------
 3083|       |
 3084|       |    // Use Dragon4 only when there might be not enough digits in the first
 3085|       |    // segment.
 3086|    925|    if (digits_in_the_first_segment > precision) {
  ------------------
  |  Branch (3086:9): [True: 0, False: 925]
  ------------------
 3087|      0|      use_dragon = false;
 3088|       |
 3089|      0|      if (precision <= 0) {
  ------------------
  |  Branch (3089:11): [True: 0, False: 0]
  ------------------
 3090|      0|        exp += digits_in_the_first_segment;
 3091|       |
 3092|      0|        if (precision < 0) {
  ------------------
  |  Branch (3092:13): [True: 0, False: 0]
  ------------------
 3093|       |          // Nothing to do, since all we have are just leading zeros.
 3094|      0|          buf.try_resize(0);
 3095|      0|        } else {
 3096|       |          // We may need to round-up.
 3097|      0|          buf.try_resize(1);
 3098|      0|          if ((first_segment | static_cast<uint64_t>(has_more_segments)) >
  ------------------
  |  Branch (3098:15): [True: 0, False: 0]
  ------------------
 3099|      0|              5000000000000000000ULL) {
 3100|      0|            buf[0] = '1';
 3101|      0|          } else {
 3102|      0|            buf[0] = '0';
 3103|      0|          }
 3104|      0|        }
 3105|      0|      }  // precision <= 0
 3106|      0|      else {
 3107|      0|        exp += digits_in_the_first_segment - precision;
 3108|       |
 3109|       |        // When precision > 0, we divide the first segment into three
 3110|       |        // subsegments, each with 9, 9, and 0 ~ 1 digits so that each fits
 3111|       |        // in 32-bits which usually allows faster calculation than in
 3112|       |        // 64-bits. Since some compiler (e.g. MSVC) doesn't know how to optimize
 3113|       |        // division-by-constant for large 64-bit divisors, we do it here
 3114|       |        // manually. The magic number 7922816251426433760 below is equal to
 3115|       |        // ceil(2^(64+32) / 10^10).
 3116|      0|        const uint32_t first_subsegment = static_cast<uint32_t>(
 3117|      0|            dragonbox::umul128_upper64(first_segment, 7922816251426433760ULL) >>
 3118|      0|            32);
 3119|      0|        const uint64_t second_third_subsegments =
 3120|      0|            first_segment - first_subsegment * 10000000000ULL;
 3121|       |
 3122|      0|        uint64_t prod;
 3123|      0|        uint32_t digits;
 3124|      0|        bool should_round_up;
 3125|      0|        int number_of_digits_to_print = min_of(precision, 9);
 3126|       |
 3127|       |        // Print a 9-digits subsegment, either the first or the second.
 3128|      0|        auto print_subsegment = [&](uint32_t subsegment, char* buffer) {
 3129|      0|          int number_of_digits_printed = 0;
 3130|       |
 3131|       |          // If we want to print an odd number of digits from the subsegment,
 3132|      0|          if ((number_of_digits_to_print & 1) != 0) {
 3133|       |            // Convert to 64-bit fixed-point fractional form with 1-digit
 3134|       |            // integer part. The magic number 720575941 is a good enough
 3135|       |            // approximation of 2^(32 + 24) / 10^8; see
 3136|       |            // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case
 3137|       |            // for details.
 3138|      0|            prod = ((subsegment * static_cast<uint64_t>(720575941)) >> 24) + 1;
 3139|      0|            digits = static_cast<uint32_t>(prod >> 32);
 3140|      0|            *buffer = static_cast<char>('0' + digits);
 3141|      0|            number_of_digits_printed++;
 3142|      0|          }
 3143|       |          // If we want to print an even number of digits from the
 3144|       |          // first_subsegment,
 3145|      0|          else {
 3146|       |            // Convert to 64-bit fixed-point fractional form with 2-digits
 3147|       |            // integer part. The magic number 450359963 is a good enough
 3148|       |            // approximation of 2^(32 + 20) / 10^7; see
 3149|       |            // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case
 3150|       |            // for details.
 3151|      0|            prod = ((subsegment * static_cast<uint64_t>(450359963)) >> 20) + 1;
 3152|      0|            digits = static_cast<uint32_t>(prod >> 32);
 3153|      0|            write2digits(buffer, digits);
 3154|      0|            number_of_digits_printed += 2;
 3155|      0|          }
 3156|       |
 3157|       |          // Print all digit pairs.
 3158|      0|          while (number_of_digits_printed < number_of_digits_to_print) {
 3159|      0|            prod = static_cast<uint32_t>(prod) * static_cast<uint64_t>(100);
 3160|      0|            digits = static_cast<uint32_t>(prod >> 32);
 3161|      0|            write2digits(buffer + number_of_digits_printed, digits);
 3162|      0|            number_of_digits_printed += 2;
 3163|      0|          }
 3164|      0|        };
 3165|       |
 3166|       |        // Print first subsegment.
 3167|      0|        print_subsegment(first_subsegment, buf.data());
 3168|       |
 3169|       |        // Perform rounding if the first subsegment is the last subsegment to
 3170|       |        // print.
 3171|      0|        if (precision <= 9) {
  ------------------
  |  Branch (3171:13): [True: 0, False: 0]
  ------------------
 3172|       |          // Rounding inside the subsegment.
 3173|       |          // We round-up if:
 3174|       |          //  - either the fractional part is strictly larger than 1/2, or
 3175|       |          //  - the fractional part is exactly 1/2 and the last digit is odd.
 3176|       |          // We rely on the following observations:
 3177|       |          //  - If fractional_part >= threshold, then the fractional part is
 3178|       |          //    strictly larger than 1/2.
 3179|       |          //  - If the MSB of fractional_part is set, then the fractional part
 3180|       |          //    must be at least 1/2.
 3181|       |          //  - When the MSB of fractional_part is set, either
 3182|       |          //    second_third_subsegments being nonzero or has_more_segments
 3183|       |          //    being true means there are further digits not printed, so the
 3184|       |          //    fractional part is strictly larger than 1/2.
 3185|      0|          if (precision < 9) {
  ------------------
  |  Branch (3185:15): [True: 0, False: 0]
  ------------------
 3186|      0|            uint32_t fractional_part = static_cast<uint32_t>(prod);
 3187|      0|            should_round_up =
 3188|      0|                fractional_part >= fractional_part_rounding_thresholds(
  ------------------
  |  Branch (3188:17): [True: 0, False: 0]
  ------------------
 3189|      0|                                       8 - number_of_digits_to_print) ||
 3190|      0|                ((fractional_part >> 31) &
  ------------------
  |  Branch (3190:17): [True: 0, False: 0]
  ------------------
 3191|      0|                 ((digits & 1) | (second_third_subsegments != 0) |
 3192|      0|                  has_more_segments)) != 0;
 3193|      0|          }
 3194|       |          // Rounding at the subsegment boundary.
 3195|       |          // In this case, the fractional part is at least 1/2 if and only if
 3196|       |          // second_third_subsegments >= 5000000000ULL, and is strictly larger
 3197|       |          // than 1/2 if we further have either second_third_subsegments >
 3198|       |          // 5000000000ULL or has_more_segments == true.
 3199|      0|          else {
 3200|      0|            should_round_up = second_third_subsegments > 5000000000ULL ||
  ------------------
  |  Branch (3200:31): [True: 0, False: 0]
  ------------------
 3201|      0|                              (second_third_subsegments == 5000000000ULL &&
  ------------------
  |  Branch (3201:32): [True: 0, False: 0]
  ------------------
 3202|      0|                               ((digits & 1) != 0 || has_more_segments));
  ------------------
  |  Branch (3202:33): [True: 0, False: 0]
  |  Branch (3202:54): [True: 0, False: 0]
  ------------------
 3203|      0|          }
 3204|      0|        }
 3205|       |        // Otherwise, print the second subsegment.
 3206|      0|        else {
 3207|       |          // Compilers are not aware of how to leverage the maximum value of
 3208|       |          // second_third_subsegments to find out a better magic number which
 3209|       |          // allows us to eliminate an additional shift. 1844674407370955162 =
 3210|       |          // ceil(2^64/10) < ceil(2^64*(10^9/(10^10 - 1))).
 3211|      0|          const uint32_t second_subsegment =
 3212|      0|              static_cast<uint32_t>(dragonbox::umul128_upper64(
 3213|      0|                  second_third_subsegments, 1844674407370955162ULL));
 3214|      0|          const uint32_t third_subsegment =
 3215|      0|              static_cast<uint32_t>(second_third_subsegments) -
 3216|      0|              second_subsegment * 10;
 3217|       |
 3218|      0|          number_of_digits_to_print = precision - 9;
 3219|      0|          print_subsegment(second_subsegment, buf.data() + 9);
 3220|       |
 3221|       |          // Rounding inside the subsegment.
 3222|      0|          if (precision < 18) {
  ------------------
  |  Branch (3222:15): [True: 0, False: 0]
  ------------------
 3223|       |            // The condition third_subsegment != 0 implies that the segment was
 3224|       |            // of 19 digits, so in this case the third segment should be
 3225|       |            // consisting of a genuine digit from the input.
 3226|      0|            uint32_t fractional_part = static_cast<uint32_t>(prod);
 3227|      0|            should_round_up =
 3228|      0|                fractional_part >= fractional_part_rounding_thresholds(
  ------------------
  |  Branch (3228:17): [True: 0, False: 0]
  ------------------
 3229|      0|                                       8 - number_of_digits_to_print) ||
 3230|      0|                ((fractional_part >> 31) &
  ------------------
  |  Branch (3230:17): [True: 0, False: 0]
  ------------------
 3231|      0|                 ((digits & 1) | (third_subsegment != 0) |
 3232|      0|                  has_more_segments)) != 0;
 3233|      0|          }
 3234|       |          // Rounding at the subsegment boundary.
 3235|      0|          else {
 3236|       |            // In this case, the segment must be of 19 digits, thus
 3237|       |            // the third subsegment should be consisting of a genuine digit from
 3238|       |            // the input.
 3239|      0|            should_round_up = third_subsegment > 5 ||
  ------------------
  |  Branch (3239:31): [True: 0, False: 0]
  ------------------
 3240|      0|                              (third_subsegment == 5 &&
  ------------------
  |  Branch (3240:32): [True: 0, False: 0]
  ------------------
 3241|      0|                               ((digits & 1) != 0 || has_more_segments));
  ------------------
  |  Branch (3241:33): [True: 0, False: 0]
  |  Branch (3241:54): [True: 0, False: 0]
  ------------------
 3242|      0|          }
 3243|      0|        }
 3244|       |
 3245|       |        // Round-up if necessary.
 3246|      0|        if (should_round_up) {
  ------------------
  |  Branch (3246:13): [True: 0, False: 0]
  ------------------
 3247|      0|          ++buf[precision - 1];
 3248|      0|          for (int i = precision - 1; i > 0 && buf[i] > '9'; --i) {
  ------------------
  |  Branch (3248:39): [True: 0, False: 0]
  |  Branch (3248:48): [True: 0, False: 0]
  ------------------
 3249|      0|            buf[i] = '0';
 3250|      0|            ++buf[i - 1];
 3251|      0|          }
 3252|      0|          if (buf[0] > '9') {
  ------------------
  |  Branch (3252:15): [True: 0, False: 0]
  ------------------
 3253|      0|            buf[0] = '1';
 3254|      0|            if (fixed)
  ------------------
  |  Branch (3254:17): [True: 0, False: 0]
  ------------------
 3255|      0|              buf[precision++] = '0';
 3256|      0|            else
 3257|      0|              ++exp;
 3258|      0|          }
 3259|      0|        }
 3260|      0|        buf.try_resize(to_unsigned(precision));
 3261|      0|      }
 3262|      0|    }  // if (digits_in_the_first_segment > precision)
 3263|    925|    else {
 3264|       |      // Adjust the exponent for its use in Dragon4.
 3265|    925|      exp += digits_in_the_first_segment - 1;
 3266|    925|    }
 3267|    925|  }
 3268|    925|  if (use_dragon) {
  ------------------
  |  Branch (3268:7): [True: 925, False: 0]
  ------------------
 3269|    925|    auto f = basic_fp<uint128_t>();
 3270|    925|    bool is_predecessor_closer = binary32 ? f.assign(static_cast<float>(value))
  ------------------
  |  Branch (3270:34): [True: 0, False: 925]
  ------------------
 3271|    925|                                          : f.assign(converted_value);
 3272|    925|    if (is_predecessor_closer) dragon_flags |= dragon::predecessor_closer;
  ------------------
  |  Branch (3272:9): [True: 145, False: 780]
  ------------------
 3273|    925|    if (fixed) dragon_flags |= dragon::fixed;
  ------------------
  |  Branch (3273:9): [True: 0, False: 925]
  ------------------
 3274|       |    // Limit precision to the maximum possible number of significant digits in
 3275|       |    // an IEEE754 double because we don't need to generate zeros.
 3276|    925|    const int max_double_digits = 767;
 3277|    925|    if (precision > max_double_digits) precision = max_double_digits;
  ------------------
  |  Branch (3277:9): [True: 0, False: 925]
  ------------------
 3278|    925|    format_dragon(f, dragon_flags, precision, buf, exp);
 3279|    925|  }
 3280|    925|  if (!fixed && !specs.alt()) {
  ------------------
  |  Branch (3280:7): [True: 925, False: 0]
  |  Branch (3280:17): [True: 925, False: 0]
  ------------------
 3281|       |    // Remove trailing zeros.
 3282|    925|    auto num_digits = buf.size();
 3283|  12.1k|    while (num_digits > 0 && buf[num_digits - 1] == '0') {
  ------------------
  |  Branch (3283:12): [True: 12.1k, False: 0]
  |  Branch (3283:30): [True: 11.2k, False: 925]
  ------------------
 3284|  11.2k|      --num_digits;
 3285|  11.2k|      ++exp;
 3286|  11.2k|    }
 3287|    925|    buf.try_resize(num_digits);
 3288|    925|  }
 3289|    925|  return exp;
 3290|    927|}
_ZN3fmt3v116detail13convert_floatIdEENSt3__111conditionalIXoosr3std7is_sameIT_fEE5valueeqcl8num_bitsIS5_EEclL_ZNS1_8num_bitsIdEEivEEEdS5_E4typeES5_:
 1611|  1.85k|constexpr auto convert_float(T value) -> convert_float_result<T> {
 1612|  1.85k|  return static_cast<convert_float_result<T>>(value);
 1613|  1.85k|}
_ZN3fmt3v116detail8basic_fpIoE6assignIdTnNSt3__19enable_ifIXntsr16is_double_doubleIT_EE5valueEiE4typeELi0EEEbS7_:
 1533|    925|  FMT_CONSTEXPR auto assign(Float n) -> bool {
 1534|    925|    static_assert(std::numeric_limits<Float>::digits <= 113, "unsupported FP");
 1535|       |    // Assume Float is in the format [sign][exponent][significand].
 1536|    925|    using carrier_uint = typename dragonbox::float_info<Float>::carrier_uint;
 1537|    925|    const auto num_float_significand_bits =
 1538|    925|        detail::num_significand_bits<Float>();
 1539|    925|    const auto implicit_bit = carrier_uint(1) << num_float_significand_bits;
 1540|    925|    const auto significand_mask = implicit_bit - 1;
 1541|    925|    auto u = bit_cast<carrier_uint>(n);
 1542|    925|    f = static_cast<F>(u & significand_mask);
 1543|    925|    auto biased_e = static_cast<int>((u & exponent_mask<Float>()) >>
 1544|    925|                                     num_float_significand_bits);
 1545|       |    // The predecessor is closer if n is a normalized power of 2 (f == 0)
 1546|       |    // other than the smallest normalized number (biased_e > 1).
 1547|    925|    auto is_predecessor_closer = f == 0 && biased_e > 1;
  ------------------
  |  Branch (1547:34): [True: 146, False: 779]
  |  Branch (1547:44): [True: 145, False: 1]
  ------------------
 1548|    925|    if (biased_e == 0)
  ------------------
  |  Branch (1548:9): [True: 120, False: 805]
  ------------------
 1549|    120|      biased_e = 1;  // Subnormals use biased exponent 1 (min exponent).
 1550|    805|    else if (has_implicit_bit<Float>())
  ------------------
  |  Branch (1550:14): [Folded - Ignored]
  ------------------
 1551|    805|      f += static_cast<F>(implicit_bit);
 1552|    925|    e = biased_e - exponent_bias<Float>() - num_float_significand_bits;
 1553|    925|    if (!has_implicit_bit<Float>()) ++e;
  ------------------
  |  Branch (1553:9): [Folded - Ignored]
  ------------------
 1554|    925|    return is_predecessor_closer;
 1555|    925|  }
_ZN3fmt3v116detail13arg_formatterIcEclIdTnNSt3__19enable_ifIXsr10is_builtinIT_EE5valueEiE4typeELi0EEEvS7_:
 3498|  1.02k|  FMT_CONSTEXPR FMT_INLINE void operator()(T value) {
 3499|  1.02k|    detail::write<Char>(out, value, specs, locale);
 3500|  1.02k|  }
_ZN3fmt3v116detail5writeIcNS0_14basic_appenderIcEEdTnNSt3__19enable_ifIXsr17is_floating_pointIT1_EE5valueEiE4typeELi0EEET0_SA_S7_NS0_12format_specsENS1_10locale_refE:
 3358|  1.02k|                           locale_ref loc = {}) -> OutputIt {
 3359|  1.02k|  return specs.localized() && write_loc(out, value, specs, loc)
  ------------------
  |  Branch (3359:10): [True: 0, False: 1.02k]
  |  Branch (3359:31): [True: 0, False: 0]
  ------------------
 3360|  1.02k|             ? out
 3361|  1.02k|             : write_float<Char>(out, value, specs, loc);
 3362|  1.02k|}
_ZN3fmt3v116detail11write_floatIcNS0_14basic_appenderIcEEdEET0_S5_T1_NS0_12format_specsENS1_10locale_refE:
 3302|  1.02k|                                 locale_ref loc) -> OutputIt {
 3303|       |  // Use signbit because value < 0 is false for NaN.
 3304|  1.02k|  sign s = detail::signbit(value) ? sign::minus : specs.sign();
  ------------------
  |  Branch (3304:12): [True: 460, False: 561]
  ------------------
 3305|       |
 3306|  1.02k|  if (!detail::isfinite(value))
  ------------------
  |  Branch (3306:7): [True: 94, False: 927]
  ------------------
 3307|     94|    return write_nonfinite<Char>(out, detail::isnan(value), specs, s);
 3308|       |
 3309|    927|  if (specs.align() == align::numeric && s != sign::none) {
  ------------------
  |  Branch (3309:7): [True: 0, False: 927]
  |  Branch (3309:42): [True: 0, False: 0]
  ------------------
 3310|      0|    *out++ = detail::getsign<Char>(s);
 3311|      0|    s = sign::none;
 3312|      0|    if (specs.width != 0) --specs.width;
  ------------------
  |  Branch (3312:9): [True: 0, False: 0]
  ------------------
 3313|      0|  }
 3314|       |
 3315|    927|  constexpr int exp_upper = detail::exp_upper<T>();
 3316|    927|  int precision = specs.precision;
 3317|    927|  if (precision < 0) {
  ------------------
  |  Branch (3317:7): [True: 0, False: 927]
  ------------------
 3318|      0|    if (specs.type() != presentation_type::none) {
  ------------------
  |  Branch (3318:9): [True: 0, False: 0]
  ------------------
 3319|      0|      precision = 6;
 3320|      0|    } else if (is_fast_float<T>::value && !is_constant_evaluated()) {
  ------------------
  |  Branch (3320:16): [Folded - Ignored]
  |  Branch (3320:43): [Folded - Ignored]
  ------------------
 3321|       |      // Use Dragonbox for the shortest format.
 3322|      0|      using floaty = conditional_t<sizeof(T) >= sizeof(double), double, float>;
 3323|      0|      auto dec = dragonbox::to_decimal(static_cast<floaty>(value));
 3324|      0|      return write_float<Char>(out, dec, specs, s, exp_upper, loc);
 3325|      0|    }
 3326|      0|  }
 3327|       |
 3328|    927|  memory_buffer buffer;
 3329|    927|  if (specs.type() == presentation_type::hexfloat) {
  ------------------
  |  Branch (3329:7): [True: 0, False: 927]
  ------------------
 3330|      0|    if (s != sign::none) buffer.push_back(detail::getsign<char>(s));
  ------------------
  |  Branch (3330:9): [True: 0, False: 0]
  ------------------
 3331|      0|    format_hexfloat(convert_float(value), specs, buffer);
 3332|      0|    return write_bytes<Char, align::right>(out, {buffer.data(), buffer.size()},
 3333|      0|                                           specs);
 3334|      0|  }
 3335|       |
 3336|    927|  if (specs.type() == presentation_type::exp) {
  ------------------
  |  Branch (3336:7): [True: 0, False: 927]
  ------------------
 3337|      0|    if (precision == max_value<int>())
  ------------------
  |  Branch (3337:9): [True: 0, False: 0]
  ------------------
 3338|      0|      report_error("number is too big");
 3339|      0|    else
 3340|      0|      ++precision;
 3341|      0|    if (specs.precision != 0) specs.set_alt();
  ------------------
  |  Branch (3341:9): [True: 0, False: 0]
  ------------------
 3342|    927|  } else if (specs.type() == presentation_type::fixed) {
  ------------------
  |  Branch (3342:14): [True: 0, False: 927]
  ------------------
 3343|      0|    if (specs.precision != 0) specs.set_alt();
  ------------------
  |  Branch (3343:9): [True: 0, False: 0]
  ------------------
 3344|    927|  } else if (precision == 0) {
  ------------------
  |  Branch (3344:14): [True: 0, False: 927]
  ------------------
 3345|      0|    precision = 1;
 3346|      0|  }
 3347|    927|  int exp = format_float(convert_float(value), precision, specs,
 3348|    927|                         std::is_same<T, float>(), buffer);
 3349|       |
 3350|    927|  specs.precision = precision;
 3351|    927|  auto f = big_decimal_fp{buffer.data(), static_cast<int>(buffer.size()), exp};
 3352|    927|  return write_float<Char>(out, f, specs, s, exp_upper, loc);
 3353|    927|}
_ZN3fmt3v116detail8isfiniteIdTnNSt3__19enable_ifIXaasr3std17is_floating_pointIT_EE5valuesr12has_isfiniteIS5_EE5valueEiE4typeELi0EEEbS5_:
 2477|  1.02k|FMT_CONSTEXPR20 auto isfinite(T value) -> bool {
 2478|  1.02k|  constexpr T inf = T(std::numeric_limits<double>::infinity());
 2479|  1.02k|  if (is_constant_evaluated())
  ------------------
  |  Branch (2479:7): [Folded - Ignored]
  ------------------
 2480|      0|    return !detail::isnan(value) && value < inf && value > -inf;
  ------------------
  |  Branch (2480:12): [True: 0, False: 0]
  |  Branch (2480:37): [True: 0, False: 0]
  |  Branch (2480:52): [True: 0, False: 0]
  ------------------
 2481|  1.02k|  return std::isfinite(value);
 2482|  1.02k|}
_ZN3fmt3v116detail5isnanIdEEbT_:
 2464|     94|template <typename T> constexpr auto isnan(T value) -> bool {
 2465|     94|  return value != value;  // std::isnan doesn't support __float128.
 2466|     94|}
_ZN3fmt3v116detail9max_valueIjEET_v:
  395|    325|template <typename T> constexpr auto max_value() -> T {
  396|    325|  return (std::numeric_limits<T>::max)();
  397|    325|}
_ZN3fmt3v116detail8bit_castImdTnNSt3__19enable_ifIXeqstT_stT0_EiE4typeELi0EEES5_RKS6_:
  248|  3.79k|FMT_CONSTEXPR20 auto bit_cast(const From& from) -> To {
  249|       |#ifdef __cpp_lib_bit_cast
  250|       |  if (is_constant_evaluated()) return std::bit_cast<To>(from);
  251|       |#endif
  252|  3.79k|  auto to = To();
  253|       |  // The cast suppresses a bogus -Wclass-memaccess on GCC.
  254|  3.79k|  std::memcpy(static_cast<void*>(&to), &from, sizeof(to));
  255|  3.79k|  return to;
  256|  3.79k|}

_Z16check_round_tripN3fmt3v1117basic_string_viewIcEEd:
   13|  2.04k|void check_round_trip(fmt::string_view format_str, double value) {
   14|  2.04k|  auto buffer = fmt::memory_buffer();
   15|  2.04k|  fmt::format_to(std::back_inserter(buffer), format_str, value);
   16|       |
   17|  2.04k|  if (std::isnan(value)) {
  ------------------
  |  Branch (17:7): [True: 184, False: 1.85k]
  ------------------
   18|    184|    auto nan = std::signbit(value) ? "-nan" : "nan";
  ------------------
  |  Branch (18:16): [True: 178, False: 6]
  ------------------
   19|    184|    if (fmt::string_view(buffer.data(), buffer.size()) != nan)
  ------------------
  |  Branch (19:9): [True: 0, False: 184]
  ------------------
   20|      0|      throw std::runtime_error("round trip failure");
   21|    184|    return;
   22|    184|  }
   23|       |
   24|  1.85k|  buffer.push_back('\0');
   25|  1.85k|  char* ptr = nullptr;
   26|  1.85k|  if (std::strtod(buffer.data(), &ptr) != value)
  ------------------
  |  Branch (26:7): [True: 0, False: 1.85k]
  ------------------
   27|      0|    throw std::runtime_error("round trip failure");
   28|  1.85k|  if (ptr + 1 != buffer.end()) throw std::runtime_error("unparsed output");
  ------------------
  |  Branch (28:7): [True: 0, False: 1.85k]
  ------------------
   29|  1.85k|}
LLVMFuzzerTestOneInput:
   31|  1.02k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   32|  1.02k|  if (size <= sizeof(double) || !std::numeric_limits<double>::is_iec559)
  ------------------
  |  Branch (32:7): [True: 5, False: 1.02k]
  |  Branch (32:33): [Folded - Ignored]
  ------------------
   33|      5|    return 0;
   34|  1.02k|  check_round_trip("{}", assign_from_buf<double>(data));
   35|       |  // A larger than necessary precision is used to trigger the fallback
   36|       |  // formatter.
   37|  1.02k|  check_round_trip("{:.50g}", assign_from_buf<double>(data));
   38|  1.02k|  return 0;
   39|  1.02k|}

_Z15assign_from_bufIdET_PKh:
   42|  2.04k|template <class Item> inline Item assign_from_buf(const std::uint8_t* data) {
   43|  2.04k|  auto item = Item();
   44|  2.04k|  std::memcpy(&item, data, sizeof(Item));
   45|  2.04k|  return item;
   46|  2.04k|}