_ZN3fmt3v126detail13ignore_unusedIJbEEEvDpRKT_:
  376|    362|template <typename... T> FMT_CONSTEXPR void ignore_unused(const T&...) {}
_ZNK3fmt3v126detail6bufferIcE8capacityEv:
 1801|    783|  constexpr auto capacity() const noexcept -> size_t { return capacity_; }
_ZN3fmt3v126detail6bufferIcEC2EPFvRS3_mEPcmm:
 1773|  3.04k|      : ptr_(p), size_(sz), capacity_(cap), grow_(grow) {}
_ZN3fmt3v126detail6bufferIcE3setEPcm:
 1779|  3.04k|  FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept {
 1780|  3.04k|    ptr_ = buf_data;
 1781|  3.04k|    capacity_ = buf_capacity;
 1782|  3.04k|  }
_ZN3fmt3v126detail6bufferIcE4dataEv:
 1804|  6.88k|  FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; }
_ZNK3fmt3v126detail6bufferIcE4sizeEv:
 1798|  5.19k|  constexpr auto size() const noexcept -> size_t { return size_; }
_ZN3fmt3v1217basic_string_viewIcEC2EPKcm:
  532|    174|      : data_(s), size_(count) {}
_ZN3fmt3v1217basic_string_viewIcEC2EPKc:
  537|  2.26k|  FMT_CONSTEXPR basic_string_view(const Char* s) : data_(s) {
  538|  2.26k|#if FMT_HAS_BUILTIN(__builtin_strlen) || FMT_GCC_VERSION || FMT_CLANG_VERSION
  539|  2.26k|    if (std::is_same<Char, char>::value && !detail::is_constant_evaluated()) {
  ------------------
  |  Branch (539:9): [True: 0, Folded]
  |  Branch (539:44): [True: 0, Folded]
  ------------------
  540|  2.26k|      size_ = __builtin_strlen(detail::narrow(s));  // strlen is not constexpr.
  541|  2.26k|      return;
  542|  2.26k|    }
  543|      0|#endif
  544|      0|    size_t len = 0;
  545|      0|    while (*s++) ++len;
  ------------------
  |  Branch (545:12): [True: 0, False: 0]
  ------------------
  546|      0|    size_ = len;
  547|      0|  }
_ZN3fmt3v126detail6narrowEPKc:
  459|  2.26k|constexpr FMT_ALWAYS_INLINE auto narrow(const char* s) -> const char* {
  460|  2.26k|  return s;
  461|  2.26k|}
_ZN3fmt3v126detail6bufferIcE9push_backERKc:
 1825|  6.34k|  FMT_CONSTEXPR void push_back(const T& value) {
 1826|  6.34k|    try_reserve(size_ + 1);
 1827|  6.34k|    ptr_[size_++] = value;
 1828|  6.34k|  }
_ZN3fmt3v126detail6bufferIcE11try_reserveEm:
 1821|  11.3k|  FMT_CONSTEXPR void try_reserve(size_t new_capacity) {
 1822|  11.3k|    if (new_capacity > capacity_) grow_(*this, new_capacity);
  ------------------
  |  Branch (1822:9): [True: 0, False: 11.3k]
  ------------------
 1823|  11.3k|  }
_ZN3fmt3v129format_toINSt3__120back_insert_iteratorINS0_19basic_memory_bufferIcLm500ENS0_6detail9allocatorIcEEEEEEJRdETnNS2_9enable_ifIXsr6detail18is_output_iteratorINS2_9remove_cvINS2_16remove_referenceIT_E4typeEE4typeEcEE5valueEiE4typeELi0EEESI_OSE_NS0_7fstringIJDpT0_EE1tEDpOSN_:
 2825|  2.09k|    -> remove_cvref_t<OutputIt> {
 2826|  2.09k|  return vformat_to(out, fmt.str, vargs<T...>{{args...}});
 2827|  2.09k|}
_ZN3fmt3v1210vformat_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:
 2805|  2.09k|    -> remove_cvref_t<OutputIt> {
 2806|  2.09k|  auto&& buf = detail::get_buffer<char>(out);
 2807|  2.09k|  detail::vformat_to(buf, fmt, args, {});
 2808|  2.09k|  return detail::get_iterator(buf, out);
 2809|  2.09k|}
_ZN3fmt3v126detail10get_bufferIcNSt3__120back_insert_iteratorINS0_19basic_memory_bufferIcLm500ENS1_9allocatorIcEEEEEETnNS3_9enable_ifIXsr18is_buffer_appenderIT0_EE5valueEiE4typeELi0EEERNS1_6bufferIT_EESB_:
 2102|  2.09k|auto get_buffer(OutputIt out) -> buffer<T>& {
 2103|  2.09k|  return get_container(out);
 2104|  2.09k|}
_ZN3fmt3v126detail13get_containerINSt3__120back_insert_iteratorINS0_19basic_memory_bufferIcLm500ENS1_9allocatorIcEEEEEEEERNT_14container_typeESA_:
  493|  2.09k|    typename OutputIt::container_type& {
  494|  2.09k|  struct accessor : OutputIt {
  495|  2.09k|    constexpr accessor(OutputIt base) : OutputIt(base) {}
  496|  2.09k|    using OutputIt::container;
  497|  2.09k|  };
  498|  2.09k|  return *accessor(it).container;
  499|  2.09k|}
_ZZN3fmt3v126detail13get_containerINSt3__120back_insert_iteratorINS0_19basic_memory_bufferIcLm500ENS1_9allocatorIcEEEEEEEERNT_14container_typeESA_EN8accessorC2ES9_:
  495|  2.09k|    constexpr accessor(OutputIt base) : OutputIt(base) {}
_ZN3fmt3v1210locale_refC2Ev:
  910|  2.50k|  constexpr locale_ref() : locale_(nullptr) {}
_ZN3fmt3v126detail12get_iteratorIcNSt3__120back_insert_iteratorINS0_19basic_memory_bufferIcLm500ENS1_9allocatorIcEEEEEEEET0_RNS1_6bufferIT_EESA_:
 2111|  2.09k|auto get_iterator(buffer<T>&, OutputIt out) -> OutputIt {
 2112|  2.09k|  return out;
 2113|  2.09k|}
_ZN3fmt3v126detail5valueINS0_7contextEEC2Ed:
 2191|  2.09k|  constexpr FMT_INLINE value(double x FMT_BUILTIN) : double_value(x) {}
_ZN3fmt3v1217basic_format_argsINS0_7contextEEC2ILi1ELi0ELy10ETnNSt3__19enable_ifIXleT_LNS0_6detail3$_0E15EEiE4typeELi0EEERKNS7_16format_arg_storeIS2_XT_EXT0_EXT1_EEE:
 2585|  2.09k|      : desc_(DESC | (NUM_NAMED_ARGS != 0 ? +detail::has_named_args_bit : 0)),
  ------------------
  |  Branch (2585:23): [Folded, False: 2.09k]
  ------------------
 2586|  2.09k|        values_(s.args) {}
_ZN3fmt3v127fstringIJRdEEC2INS0_17basic_string_viewIcEETnNSt3__19enable_ifIXsr3std14is_convertibleIRKT_S6_EE5valueEiE4typeELi0EEESB_:
 2721|  2.09k|  FMT_CONSTEVAL FMT_ALWAYS_INLINE fstring(const S& s) : str(s) {
 2722|  2.09k|    if (FMT_USE_CONSTEVAL)
  ------------------
  |  |  120|  2.09k|#  define FMT_USE_CONSTEVAL 0
  |  |  ------------------
  |  |  |  Branch (120:29): [Folded, False: 2.09k]
  |  |  ------------------
  ------------------
 2723|      0|      detail::parse_format_string<char>(str, checker(str, arg_pack()));
 2724|  2.09k|    constexpr bool unused = detail::enforce_compile_checks<sizeof(s) != 0>();
 2725|  2.09k|    (void)unused;
 2726|  2.09k|  }
_ZN3fmt3v12neENS0_17basic_string_viewIcEES2_:
  591|    174|  friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool {
  592|    174|    return lhs.compare(rhs) != 0;
  593|    174|  }
_ZNK3fmt3v1217basic_string_viewIcE7compareES2_:
  581|    174|  FMT_CONSTEXPR auto compare(basic_string_view other) const -> int {
  582|    174|    int cmp = detail::compare(data_, other.data_, min_of(size_, other.size_));
  583|    174|    if (cmp != 0) return cmp;
  ------------------
  |  Branch (583:9): [True: 0, False: 174]
  ------------------
  584|    174|    return size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
  ------------------
  |  Branch (584:12): [True: 174, False: 0]
  |  Branch (584:40): [True: 0, False: 0]
  ------------------
  585|    174|  }
_ZN3fmt3v126detail7compareIcEEiPKT_S5_m:
  464|    174|FMT_CONSTEXPR auto compare(const Char* s1, const Char* s2, size_t n) -> int {
  465|    174|  if (!is_constant_evaluated() && sizeof(Char) == 1) return memcmp(s1, s2, n);
  ------------------
  |  Branch (465:7): [True: 0, Folded]
  |  Branch (465:35): [True: 0, Folded]
  ------------------
  466|      0|  for (; n != 0; ++s1, ++s2, --n) {
  ------------------
  |  Branch (466:10): [True: 0, False: 0]
  ------------------
  467|      0|    if (*s1 < *s2) return -1;
  ------------------
  |  Branch (467:9): [True: 0, False: 0]
  ------------------
  468|      0|    if (*s1 > *s2) return 1;
  ------------------
  |  Branch (468:9): [True: 0, False: 0]
  ------------------
  469|      0|  }
  470|      0|  return 0;
  471|      0|}
_ZN3fmt3v126min_ofImEET_S2_S2_:
  362|   180k|template <typename T> constexpr auto min_of(T a, T b) -> T {
  363|   180k|  return a < b ? a : b;
  ------------------
  |  Branch (363:10): [True: 180k, False: 174]
  ------------------
  364|   180k|}
_ZN3fmt3v126detail6bufferIcE3endEv:
 1792|  1.91k|  auto end() noexcept -> T* { return ptr_ + size_; }
_ZN3fmt3v129monostateC2Ev:
  350|  2.09k|  constexpr monostate() {}
_ZNK3fmt3v1211basic_specs4typeEv:
  732|  5.74k|  constexpr auto type() const -> presentation_type {
  733|  5.74k|    return static_cast<presentation_type>(data_ & type_mask);
  734|  5.74k|  }
_ZN3fmt3v1211basic_specs8set_typeENS0_17presentation_typeE:
  735|  1.04k|  FMT_CONSTEXPR void set_type(presentation_type t) {
  736|  1.04k|    data_ = (data_ & ~type_mask) | unsigned(t);
  737|  1.04k|  }
_ZNK3fmt3v1211basic_specs5alignEv:
  739|  1.99k|  constexpr auto align() const -> align {
  740|  1.99k|    return static_cast<fmt::align>((data_ & align_mask) >> align_shift);
  741|  1.99k|  }
_ZN3fmt3v1211basic_specs21set_dynamic_precisionENS0_11arg_id_kindE:
  757|  1.04k|  FMT_CONSTEXPR void set_dynamic_precision(arg_id_kind p) {
  758|  1.04k|    data_ = (data_ & ~precision_mask) | (unsigned(p) << precision_shift);
  759|  1.04k|  }
_ZNK3fmt3v1211basic_specs7dynamicEv:
  761|  1.04k|  constexpr auto dynamic() const -> bool {
  762|  1.04k|    return (data_ & (width_mask | precision_mask)) != 0;
  763|  1.04k|  }
_ZNK3fmt3v1211basic_specs4signEv:
  765|    605|  constexpr auto sign() const -> sign {
  766|    605|    return static_cast<fmt::sign>((data_ & sign_mask) >> sign_shift);
  767|    605|  }
_ZNK3fmt3v1211basic_specs5upperEv:
  772|    684|  constexpr auto upper() const -> bool { return (data_ & uppercase_mask) != 0; }
_ZNK3fmt3v1211basic_specs3altEv:
  775|  2.53k|  constexpr auto alt() const -> bool { return (data_ & alternate_mask) != 0; }
_ZNK3fmt3v1211basic_specs9localizedEv:
  779|  2.71k|  constexpr auto localized() const -> bool {
  780|  2.71k|    return (data_ & localized_mask) != 0;
  781|  2.71k|  }
_ZNK3fmt3v1211basic_specs9fill_sizeEv:
  784|  1.21k|  constexpr auto fill_size() const -> size_t {
  785|  1.21k|    return (data_ & fill_size_mask) >> fill_size_shift;
  786|  1.21k|  }
_ZN3fmt3v1212format_specsC2Ev:
  835|  1.54k|  constexpr format_specs() : width(0), precision(-1) {}
_ZN3fmt3v126detail11to_unsignedIiEENSt3__113make_unsignedIT_E4typeES5_:
  429|   174k|FMT_CONSTEXPR auto to_unsigned(Int value) -> make_unsigned_t<Int> {
  430|   174k|  FMT_ASSERT(std::is_unsigned<Int>::value || value >= 0, "negative value");
  ------------------
  |  |  402|   348k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:7): [Folded, False: 174k]
  |  |  |  Branch (402:7): [True: 174k, False: 0]
  |  |  ------------------
  |  |  403|   174k|         ? (void)0                                                          \
  |  |  404|   174k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
  431|   174k|  return static_cast<make_unsigned_t<Int>>(value);
  432|   174k|}
_ZN3fmt3v127contextC2ENS0_14basic_appenderIcEENS0_17basic_format_argsIS1_EENS0_10locale_refE:
 2653|  1.04k|      : out_(out), args_(args), loc_(loc) {}
_ZNK3fmt3v1217basic_format_argsINS0_7contextEE9is_packedEv:
 2558|  2.09k|  constexpr auto is_packed() const -> bool {
 2559|  2.09k|    return (desc_ & detail::is_unpacked_bit) == 0;
 2560|  2.09k|  }
_ZNK3fmt3v1217basic_format_argsINS0_7contextEE4typeEi:
 2565|  2.09k|  FMT_CONSTEXPR auto type(int index) const -> detail::type {
 2566|  2.09k|    int shift = index * detail::packed_arg_bits;
 2567|  2.09k|    unsigned mask = (1 << detail::packed_arg_bits) - 1;
 2568|  2.09k|    return static_cast<detail::type>((desc_ >> shift) & mask);
 2569|  2.09k|  }
_ZNK3fmt3v1217basic_format_argsINS0_7contextEE3getEi:
 2602|  2.09k|  FMT_CONSTEXPR auto get(int id) const -> format_arg {
 2603|  2.09k|    auto arg = format_arg();
 2604|  2.09k|    if (!is_packed()) {
  ------------------
  |  Branch (2604:9): [True: 0, False: 2.09k]
  ------------------
 2605|      0|      if (unsigned(id) < unsigned(max_size())) arg = args_[id];
  ------------------
  |  Branch (2605:11): [True: 0, False: 0]
  ------------------
 2606|      0|      return arg;
 2607|      0|    }
 2608|  2.09k|    if (unsigned(id) >= detail::max_packed_args) return arg;
  ------------------
  |  Branch (2608:9): [True: 0, False: 2.09k]
  ------------------
 2609|  2.09k|    arg.type_ = type(id);
 2610|  2.09k|    if (arg.type_ != detail::type::none_type) arg.value_ = values_[id];
  ------------------
  |  Branch (2610:9): [True: 2.09k, False: 0]
  ------------------
 2611|  2.09k|    return arg;
 2612|  2.09k|  }
_ZNK3fmt3v127context3argEi:
 2658|  1.04k|  FMT_CONSTEXPR auto arg(int id) const -> format_arg { return args_.get(id); }
_ZNK3fmt3v127context3outEv:
 2668|  3.13k|  constexpr auto out() const -> iterator { return out_; }
_ZNK3fmt3v127context6localeEv:
 2673|  1.04k|  constexpr auto locale() const -> locale_ref { return loc_; }
_ZN3fmt3v126detail2inENS1_4typeEi:
 1028|  2.09k|constexpr auto in(type t, int set) -> bool {
 1029|  2.09k|  return ((set >> int(t)) & 1) != 0;
 1030|  2.09k|}
_ZN3fmt3v126detail11parse_alignEc:
 1326|  1.04k|FMT_CONSTEXPR inline auto parse_align(char c) -> align {
 1327|  1.04k|  switch (c) {
  ------------------
  |  Branch (1327:11): [True: 0, False: 1.04k]
  ------------------
 1328|      0|  case '<': return align::left;
  ------------------
  |  Branch (1328:3): [True: 0, False: 1.04k]
  ------------------
 1329|      0|  case '>': return align::right;
  ------------------
  |  Branch (1329:3): [True: 0, False: 1.04k]
  ------------------
 1330|      0|  case '^': return align::center;
  ------------------
  |  Branch (1330:3): [True: 0, False: 1.04k]
  ------------------
 1331|  1.04k|  }
 1332|  1.04k|  return align::none;
 1333|  1.04k|}
_ZN3fmt3v126detail11to_unsignedIlEENSt3__113make_unsignedIT_E4typeES5_:
  429|  1.98k|FMT_CONSTEXPR auto to_unsigned(Int value) -> make_unsigned_t<Int> {
  430|  1.98k|  FMT_ASSERT(std::is_unsigned<Int>::value || value >= 0, "negative value");
  ------------------
  |  |  402|  3.97k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:7): [Folded, False: 1.98k]
  |  |  |  Branch (402:7): [True: 1.98k, False: 0]
  |  |  ------------------
  |  |  403|  1.98k|         ? (void)0                                                          \
  |  |  404|  1.98k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
  431|  1.98k|  return static_cast<make_unsigned_t<Int>>(value);
  432|  1.98k|}
_ZNK3fmt3v1217basic_string_viewIcE4dataEv:
  556|  2.09k|  constexpr auto data() const noexcept -> const Char* { return data_; }
_ZNK3fmt3v1217basic_string_viewIcE4sizeEv:
  557|  3.13k|  constexpr auto size() const noexcept -> size_t { return size_; }
_ZN3fmt3v1214basic_appenderIcEppEi:
 2455|  4.42k|  FMT_CONSTEXPR auto operator++(int) -> basic_appender { return *this; }
_ZN3fmt3v1214basic_appenderIcEdeEv:
 2453|  4.42k|  FMT_CONSTEXPR auto operator*() -> basic_appender& { return *this; }
_ZN3fmt3v1214basic_appenderIcEaSEc:
 2449|  4.42k|  FMT_CONSTEXPR auto operator=(T c) -> basic_appender& {
 2450|  4.42k|    container->push_back(c);
 2451|  4.42k|    return *this;
 2452|  4.42k|  }
_ZN3fmt3v126max_ofIiEET_S2_S2_:
  365|  1.30k|template <typename T> constexpr auto max_of(T a, T b) -> T {
  366|  1.30k|  return a > b ? a : b;
  ------------------
  |  Branch (366:10): [True: 0, False: 1.30k]
  ------------------
  367|  1.30k|}
_ZNK3fmt3v126detail6bufferIjEixIiEERKjT_:
 1856|   691k|  constexpr auto operator[](Idx index) const -> const T& {
 1857|   691k|    return ptr_[index];
 1858|   691k|  }
_ZN3fmt3v126detail6bufferIjEixIiEERjT_:
 1852|  1.76M|  template <typename Idx> FMT_CONSTEXPR auto operator[](Idx index) -> T& {
 1853|  1.76M|    return ptr_[index];
 1854|  1.76M|  }
_ZNK3fmt3v126detail6bufferIjE4sizeEv:
 1798|  1.85M|  constexpr auto size() const noexcept -> size_t { return size_; }
_ZN3fmt3v126detail6bufferIjE11try_reserveEm:
 1821|   183k|  FMT_CONSTEXPR void try_reserve(size_t new_capacity) {
 1822|   183k|    if (new_capacity > capacity_) grow_(*this, new_capacity);
  ------------------
  |  Branch (1822:9): [True: 0, False: 183k]
  ------------------
 1823|   183k|  }
_ZN3fmt3v126detail6bufferIjE10try_resizeEm:
 1812|   177k|  FMT_CONSTEXPR void try_resize(size_t count) {
 1813|   177k|    try_reserve(count);
 1814|   177k|    size_ = min_of(count, capacity_);
 1815|   177k|  }
_ZNK3fmt3v126detail6bufferIjEixImEERKjT_:
 1856|   760k|  constexpr auto operator[](Idx index) const -> const T& {
 1857|   760k|    return ptr_[index];
 1858|   760k|  }
_ZN3fmt3v126detail6bufferIjEixImEERjT_:
 1852|   961k|  template <typename Idx> FMT_CONSTEXPR auto operator[](Idx index) -> T& {
 1853|   961k|    return ptr_[index];
 1854|   961k|  }
_ZN3fmt3v126detail6bufferIjE9push_backERKj:
 1825|  5.40k|  FMT_CONSTEXPR void push_back(const T& value) {
 1826|  5.40k|    try_reserve(size_ + 1);
 1827|  5.40k|    ptr_[size_++] = value;
 1828|  5.40k|  }
_ZN3fmt3v126detail6bufferIjE3setEPjm:
 1779|  8.05k|  FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept {
 1780|  8.05k|    ptr_ = buf_data;
 1781|  8.05k|    capacity_ = buf_capacity;
 1782|  8.05k|  }
_ZNK3fmt3v126detail6bufferIjE4dataEv:
 1805|    495|  FMT_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; }
_ZN3fmt3v126detail6bufferIjE4dataEv:
 1804|  17.1k|  FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; }
_ZN3fmt3v126detail4copyIjPKjPjTnNSt3__19enable_ifIXoontcvNS1_23is_back_insert_iteratorIT1_NS6_17integral_constantIbLb1EEEEE_EntoocvNS1_10has_appendIS9_T0_vEE_EcvNS1_10has_insertIS9_SE_vEE_EEiE4typeELi0EEES9_SE_SE_S9_:
 1925|    495|FMT_CONSTEXPR auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt {
 1926|  6.46k|  while (begin != end) *out++ = static_cast<T>(*begin++);
  ------------------
  |  Branch (1926:10): [True: 5.97k, False: 495]
  ------------------
 1927|    495|  return out;
 1928|    495|}
_ZN3fmt3v126min_ofIiEET_S2_S2_:
  362|  3.73k|template <typename T> constexpr auto min_of(T a, T b) -> T {
  363|  3.73k|  return a < b ? a : b;
  ------------------
  |  Branch (363:10): [True: 537, False: 3.19k]
  ------------------
  364|  3.73k|}
_ZN3fmt3v126detail6bufferIcE10try_resizeEm:
 1812|  2.69k|  FMT_CONSTEXPR void try_resize(size_t count) {
 1813|  2.69k|    try_reserve(count);
 1814|  2.69k|    size_ = min_of(count, capacity_);
 1815|  2.69k|  }
_ZN3fmt3v126detail6bufferIcEixIiEERcT_:
 1852|  48.0k|  template <typename Idx> FMT_CONSTEXPR auto operator[](Idx index) -> T& {
 1853|  48.0k|    return ptr_[index];
 1854|  48.0k|  }
_ZN3fmt3v126detail13get_containerINS0_14basic_appenderIcEEEERNT_14container_typeES5_:
  493|  6.40k|    typename OutputIt::container_type& {
  494|  6.40k|  struct accessor : OutputIt {
  495|  6.40k|    constexpr accessor(OutputIt base) : OutputIt(base) {}
  496|  6.40k|    using OutputIt::container;
  497|  6.40k|  };
  498|  6.40k|  return *accessor(it).container;
  499|  6.40k|}
_ZN3fmt3v126detail4copyIcPcNS0_14basic_appenderIcEETnNSt3__19enable_ifIXaacvNS1_23is_back_insert_iteratorIT1_NS6_17integral_constantIbLb1EEEEE_EcvNS1_10has_appendIS9_T0_vEE_EEiE4typeELi0EEES9_SE_SE_S9_:
 1906|    174|FMT_CONSTEXPR auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt {
 1907|    174|  get_container(out).append(begin, end);
 1908|    174|  return out;
 1909|    174|}
_ZN3fmt3v126detail6bufferIcEixImEERcT_:
 1852|  13.3k|  template <typename Idx> FMT_CONSTEXPR auto operator[](Idx index) -> T& {
 1853|  13.3k|    return ptr_[index];
 1854|  13.3k|  }
_ZN3fmt3v126detail8to_asciiIcTnNSt3__19enable_ifIXsr3std11is_integralIT_EE5valueEiE4typeELi0EEEcS5_:
 1289|  3.13k|constexpr auto to_ascii(Char c) -> char {
 1290|  3.13k|  return c <= 0xff ? char(c) : '\0';
  ------------------
  |  Branch (1290:10): [True: 3.13k, False: 0]
  ------------------
 1291|  3.13k|}
_ZZN3fmt3v126detail18parse_format_specsIcEEPKT_S5_S5_RNS1_20dynamic_format_specsIS3_EERNS0_13parse_contextIS3_EENS1_4typeEENUt_clENS1_5stateEb:
 1468|  1.04k|    FMT_CONSTEXPR void operator()(state s, bool valid = true) {
 1469|  1.04k|      if (current_state >= s || !valid)
  ------------------
  |  Branch (1469:11): [True: 0, False: 1.04k]
  |  Branch (1469:33): [True: 0, False: 1.04k]
  ------------------
 1470|      0|        report_error("invalid format specifier");
 1471|  1.04k|      current_state = s;
 1472|  1.04k|    }
_ZZN3fmt3v126detail18parse_format_specsIcEEPKT_S5_S5_RNS1_20dynamic_format_specsIS3_EERNS0_13parse_contextIS3_EENS1_4typeEENUt0_clENS0_17presentation_typeEi:
 1482|  1.04k|    FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* {
 1483|  1.04k|      if (!in(arg_type, set)) report_error("invalid format specifier");
  ------------------
  |  Branch (1483:11): [True: 0, False: 1.04k]
  ------------------
 1484|  1.04k|      specs.set_type(pres_type);
 1485|  1.04k|      return begin + 1;
 1486|  1.04k|    }
_ZN3fmt3v126detail21parse_nonnegative_intIcEEiRPKT_S5_i:
 1305|  1.04k|                                         int error_value) noexcept -> int {
 1306|  1.04k|  FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
  ------------------
  |  |  402|  4.18k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:7): [True: 1.04k, False: 0]
  |  |  |  Branch (402:7): [True: 1.04k, False: 0]
  |  |  |  Branch (402:7): [True: 1.04k, False: 0]
  |  |  ------------------
  |  |  403|  1.04k|         ? (void)0                                                          \
  |  |  404|  1.04k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1307|  1.04k|  unsigned value = 0, prev = 0;
 1308|  1.04k|  auto p = begin;
 1309|  2.09k|  do {
 1310|  2.09k|    prev = value;
 1311|  2.09k|    value = value * 10 + unsigned(*p - '0');
 1312|  2.09k|    ++p;
 1313|  2.09k|  } while (p != end && '0' <= *p && *p <= '9');
  ------------------
  |  Branch (1313:12): [True: 2.09k, False: 0]
  |  Branch (1313:24): [True: 2.09k, False: 0]
  |  Branch (1313:37): [True: 1.04k, False: 1.04k]
  ------------------
 1314|  1.04k|  auto num_digits = p - begin;
 1315|  1.04k|  begin = p;
 1316|  1.04k|  int digits10 = int(sizeof(int) * CHAR_BIT * 3 / 10);
 1317|  1.04k|  if (num_digits <= digits10) return int(value);
  ------------------
  |  Branch (1317:7): [True: 1.04k, False: 0]
  ------------------
 1318|       |  // Check for overflow.
 1319|      0|  unsigned max = INT_MAX;
 1320|      0|  return num_digits == digits10 + 1 &&
  ------------------
  |  Branch (1320:10): [True: 0, False: 0]
  ------------------
 1321|      0|                 prev * 10ull + unsigned(p[-1] - '0') <= max
  ------------------
  |  Branch (1321:18): [True: 0, False: 0]
  ------------------
 1322|      0|             ? int(value)
 1323|      0|             : error_value;
 1324|  1.04k|}
_ZN3fmt3v1213parse_contextIcE15do_check_arg_idEi:
 2420|  1.04k|FMT_CONSTEXPR void parse_context<Char>::do_check_arg_id(int arg_id) {
 2421|       |  // Argument id is only checked at compile time during parsing because
 2422|       |  // formatting has its own validation.
 2423|  1.04k|  if (detail::is_constant_evaluated() && use_constexpr_cast) {
  ------------------
  |  Branch (2423:7): [Folded, False: 1.04k]
  |  Branch (2423:42): [True: 0, Folded]
  ------------------
 2424|      0|    auto ctx = static_cast<detail::compile_parse_context<Char>*>(this);
 2425|      0|    if (arg_id >= ctx->num_args()) report_error("argument not found");
  ------------------
  |  Branch (2425:9): [True: 0, False: 0]
  ------------------
 2426|      0|  }
 2427|  1.04k|}
_ZN3fmt3v1213parse_contextIcE11next_arg_idEv:
  873|  1.04k|  FMT_CONSTEXPR auto next_arg_id() -> int {
  874|  1.04k|    if (next_arg_id_ < 0) {
  ------------------
  |  Branch (874:9): [True: 0, False: 1.04k]
  ------------------
  875|      0|      report_error("cannot switch from manual to automatic argument indexing");
  876|      0|      return 0;
  877|      0|    }
  878|  1.04k|    int id = next_arg_id_++;
  879|  1.04k|    do_check_arg_id(id);
  880|  1.04k|    return id;
  881|  1.04k|  }
_ZN3fmt3v126detail18parse_dynamic_specIcEENS1_25parse_dynamic_spec_resultIT_EEPKS4_S7_RiRNS1_7arg_refIS4_EERNS0_13parse_contextIS4_EE:
 1395|  1.04k|    -> parse_dynamic_spec_result<Char> {
 1396|  1.04k|  FMT_ASSERT(begin != end, "");
  ------------------
  |  |  402|  1.04k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 1.04k, False: 0]
  |  |  ------------------
  |  |  403|  1.04k|         ? (void)0                                                          \
  |  |  404|  1.04k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1397|  1.04k|  auto kind = arg_id_kind::none;
 1398|  1.04k|  if ('0' <= *begin && *begin <= '9') {
  ------------------
  |  Branch (1398:7): [True: 1.04k, False: 0]
  |  Branch (1398:24): [True: 1.04k, False: 0]
  ------------------
 1399|  1.04k|    int val = parse_nonnegative_int(begin, end, -1);
 1400|  1.04k|    if (val == -1) report_error("number is too big");
  ------------------
  |  Branch (1400:9): [True: 0, False: 1.04k]
  ------------------
 1401|  1.04k|    value = val;
 1402|  1.04k|  } else {
 1403|      0|    if (*begin == '{') {
  ------------------
  |  Branch (1403:9): [True: 0, False: 0]
  ------------------
 1404|      0|      ++begin;
 1405|      0|      if (begin != end) {
  ------------------
  |  Branch (1405:11): [True: 0, False: 0]
  ------------------
 1406|      0|        Char c = *begin;
 1407|      0|        if (c == '}' || c == ':') {
  ------------------
  |  Branch (1407:13): [True: 0, False: 0]
  |  Branch (1407:25): [True: 0, False: 0]
  ------------------
 1408|      0|          int id = ctx.next_arg_id();
 1409|      0|          ref = id;
 1410|      0|          kind = arg_id_kind::index;
 1411|      0|          ctx.check_dynamic_spec(id);
 1412|      0|        } else {
 1413|      0|          begin = parse_arg_id(begin, end,
 1414|      0|                               dynamic_spec_handler<Char>{ctx, ref, kind});
 1415|      0|        }
 1416|      0|      }
 1417|      0|      if (begin != end && *begin == '}') return {++begin, kind};
  ------------------
  |  Branch (1417:11): [True: 0, False: 0]
  |  Branch (1417:27): [True: 0, False: 0]
  ------------------
 1418|      0|    }
 1419|      0|    report_error("invalid format string");
 1420|      0|  }
 1421|  1.04k|  return {begin, kind};
 1422|  1.04k|}
_ZN3fmt3v126detail15parse_precisionIcEEPKT_S5_S5_RNS0_12format_specsERNS1_7arg_refIS3_EERNS0_13parse_contextIS3_EE:
 1437|  1.04k|                                   parse_context<Char>& ctx) -> const Char* {
 1438|  1.04k|  ++begin;
 1439|  1.04k|  if (begin == end) {
  ------------------
  |  Branch (1439:7): [True: 0, False: 1.04k]
  ------------------
 1440|      0|    report_error("invalid precision");
 1441|      0|    return begin;
 1442|      0|  }
 1443|  1.04k|  auto result =
 1444|  1.04k|      parse_dynamic_spec(begin, end, specs.precision, precision_ref, ctx);
 1445|  1.04k|  specs.set_dynamic_precision(result.kind);
 1446|  1.04k|  return result.end;
 1447|  1.04k|}
_ZN3fmt3v126detail18parse_format_specsIcEEPKT_S5_S5_RNS1_20dynamic_format_specsIS3_EERNS0_13parse_contextIS3_EENS1_4typeE:
 1456|  1.04k|    -> const Char* {
 1457|  1.04k|  auto c = '\0';
 1458|  1.04k|  if (end - begin > 1) {
  ------------------
  |  Branch (1458:7): [True: 1.04k, False: 0]
  ------------------
 1459|  1.04k|    auto next = to_ascii(begin[1]);
 1460|  1.04k|    c = parse_align(next) == align::none ? to_ascii(*begin) : '\0';
  ------------------
  |  Branch (1460:9): [True: 1.04k, False: 0]
  ------------------
 1461|  1.04k|  } else {
 1462|      0|    if (begin == end) return begin;
  ------------------
  |  Branch (1462:9): [True: 0, False: 0]
  ------------------
 1463|      0|    c = to_ascii(*begin);
 1464|      0|  }
 1465|       |
 1466|  1.04k|  struct {
 1467|  1.04k|    state current_state = state::start;
 1468|  1.04k|    FMT_CONSTEXPR void operator()(state s, bool valid = true) {
 1469|  1.04k|      if (current_state >= s || !valid)
 1470|  1.04k|        report_error("invalid format specifier");
 1471|  1.04k|      current_state = s;
 1472|  1.04k|    }
 1473|  1.04k|  } enter_state;
 1474|       |
 1475|  1.04k|  using pres = presentation_type;
 1476|  1.04k|  constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
 1477|  1.04k|  struct {
 1478|  1.04k|    const Char*& begin;
 1479|  1.04k|    format_specs& specs;
 1480|  1.04k|    type arg_type;
 1481|       |
 1482|  1.04k|    FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* {
 1483|  1.04k|      if (!in(arg_type, set)) report_error("invalid format specifier");
 1484|  1.04k|      specs.set_type(pres_type);
 1485|  1.04k|      return begin + 1;
 1486|  1.04k|    }
 1487|  1.04k|  } parse_presentation_type{begin, specs, arg_type};
 1488|       |
 1489|  2.09k|  for (;;) {
 1490|  2.09k|    switch (c) {
 1491|      0|    case '<':
  ------------------
  |  Branch (1491:5): [True: 0, False: 2.09k]
  ------------------
 1492|      0|    case '>':
  ------------------
  |  Branch (1492:5): [True: 0, False: 2.09k]
  ------------------
 1493|      0|    case '^':
  ------------------
  |  Branch (1493:5): [True: 0, False: 2.09k]
  ------------------
 1494|      0|      enter_state(state::align);
 1495|      0|      specs.set_align(parse_align(c));
 1496|      0|      ++begin;
 1497|      0|      break;
 1498|      0|    case '+':
  ------------------
  |  Branch (1498:5): [True: 0, False: 2.09k]
  ------------------
 1499|      0|    case ' ':
  ------------------
  |  Branch (1499:5): [True: 0, False: 2.09k]
  ------------------
 1500|      0|      specs.set_sign(c == ' ' ? sign::space : sign::plus);
  ------------------
  |  Branch (1500:22): [True: 0, False: 0]
  ------------------
 1501|      0|      FMT_FALLTHROUGH;
  ------------------
  |  |  183|      0|#  define FMT_FALLTHROUGH [[clang::fallthrough]]
  ------------------
 1502|      0|    case '-':
  ------------------
  |  Branch (1502:5): [True: 0, False: 2.09k]
  ------------------
 1503|      0|      enter_state(state::sign, in(arg_type, sint_set | float_set));
 1504|      0|      ++begin;
 1505|      0|      break;
 1506|      0|    case '#':
  ------------------
  |  Branch (1506:5): [True: 0, False: 2.09k]
  ------------------
 1507|      0|      enter_state(state::hash, is_arithmetic_type(arg_type));
 1508|      0|      specs.set_alt();
 1509|      0|      ++begin;
 1510|      0|      break;
 1511|      0|    case '0':
  ------------------
  |  Branch (1511:5): [True: 0, False: 2.09k]
  ------------------
 1512|      0|      enter_state(state::zero);
 1513|      0|      if (!is_arithmetic_type(arg_type))
  ------------------
  |  Branch (1513:11): [True: 0, False: 0]
  ------------------
 1514|      0|        report_error("format specifier requires numeric argument");
 1515|      0|      if (specs.align() == align::none) {
  ------------------
  |  Branch (1515:11): [True: 0, False: 0]
  ------------------
 1516|       |        // Ignore 0 if align is specified for compatibility with std::format.
 1517|      0|        specs.set_align(align::numeric);
 1518|      0|        specs.set_fill('0');
 1519|      0|      }
 1520|      0|      ++begin;
 1521|      0|      break;
 1522|       |      // clang-format off
 1523|      0|    case '1': case '2': case '3': case '4': case '5':
  ------------------
  |  Branch (1523:5): [True: 0, False: 2.09k]
  |  Branch (1523:15): [True: 0, False: 2.09k]
  |  Branch (1523:25): [True: 0, False: 2.09k]
  |  Branch (1523:35): [True: 0, False: 2.09k]
  |  Branch (1523:45): [True: 0, False: 2.09k]
  ------------------
 1524|      0|    case '6': case '7': case '8': case '9': case '{':
  ------------------
  |  Branch (1524:5): [True: 0, False: 2.09k]
  |  Branch (1524:15): [True: 0, False: 2.09k]
  |  Branch (1524:25): [True: 0, False: 2.09k]
  |  Branch (1524:35): [True: 0, False: 2.09k]
  |  Branch (1524:45): [True: 0, False: 2.09k]
  ------------------
 1525|       |      // clang-format on
 1526|      0|      enter_state(state::width);
 1527|      0|      begin = parse_width(begin, end, specs, specs.width_ref, ctx);
 1528|      0|      break;
 1529|  1.04k|    case '.':
  ------------------
  |  Branch (1529:5): [True: 1.04k, False: 1.04k]
  ------------------
 1530|  1.04k|      enter_state(state::precision,
 1531|  1.04k|                  in(arg_type, float_set | string_set | cstring_set));
 1532|  1.04k|      begin = parse_precision(begin, end, specs, specs.precision_ref, ctx);
 1533|  1.04k|      break;
 1534|      0|    case 'L':
  ------------------
  |  Branch (1534:5): [True: 0, False: 2.09k]
  ------------------
 1535|      0|      enter_state(state::locale, is_arithmetic_type(arg_type));
 1536|      0|      specs.set_localized();
 1537|      0|      ++begin;
 1538|      0|      break;
 1539|      0|    case 'd': return parse_presentation_type(pres::dec, integral_set);
  ------------------
  |  Branch (1539:5): [True: 0, False: 2.09k]
  ------------------
 1540|      0|    case 'X': specs.set_upper(); FMT_FALLTHROUGH;
  ------------------
  |  |  183|      0|#  define FMT_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  |  Branch (1540:5): [True: 0, False: 2.09k]
  ------------------
 1541|      0|    case 'x': return parse_presentation_type(pres::hex, integral_set);
  ------------------
  |  Branch (1541:5): [True: 0, False: 2.09k]
  ------------------
 1542|      0|    case 'o': return parse_presentation_type(pres::oct, integral_set);
  ------------------
  |  Branch (1542:5): [True: 0, False: 2.09k]
  ------------------
 1543|      0|    case 'B': specs.set_upper(); FMT_FALLTHROUGH;
  ------------------
  |  |  183|      0|#  define FMT_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  |  Branch (1543:5): [True: 0, False: 2.09k]
  ------------------
 1544|      0|    case 'b': return parse_presentation_type(pres::bin, integral_set);
  ------------------
  |  Branch (1544:5): [True: 0, False: 2.09k]
  ------------------
 1545|      0|    case 'E': specs.set_upper(); FMT_FALLTHROUGH;
  ------------------
  |  |  183|      0|#  define FMT_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  |  Branch (1545:5): [True: 0, False: 2.09k]
  ------------------
 1546|      0|    case 'e': return parse_presentation_type(pres::exp, float_set);
  ------------------
  |  Branch (1546:5): [True: 0, False: 2.09k]
  ------------------
 1547|      0|    case 'F': specs.set_upper(); FMT_FALLTHROUGH;
  ------------------
  |  |  183|      0|#  define FMT_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  |  Branch (1547:5): [True: 0, False: 2.09k]
  ------------------
 1548|      0|    case 'f': return parse_presentation_type(pres::fixed, float_set);
  ------------------
  |  Branch (1548:5): [True: 0, False: 2.09k]
  ------------------
 1549|      0|    case 'G': specs.set_upper(); FMT_FALLTHROUGH;
  ------------------
  |  |  183|      0|#  define FMT_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  |  Branch (1549:5): [True: 0, False: 2.09k]
  ------------------
 1550|  1.04k|    case 'g': return parse_presentation_type(pres::general, float_set);
  ------------------
  |  Branch (1550:5): [True: 1.04k, False: 1.04k]
  ------------------
 1551|      0|    case 'A': specs.set_upper(); FMT_FALLTHROUGH;
  ------------------
  |  |  183|      0|#  define FMT_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  |  Branch (1551:5): [True: 0, False: 2.09k]
  ------------------
 1552|      0|    case 'a': return parse_presentation_type(pres::hexfloat, float_set);
  ------------------
  |  Branch (1552:5): [True: 0, False: 2.09k]
  ------------------
 1553|      0|    case 'c':
  ------------------
  |  Branch (1553:5): [True: 0, False: 2.09k]
  ------------------
 1554|      0|      if (arg_type == type::bool_type) report_error("invalid format specifier");
  ------------------
  |  Branch (1554:11): [True: 0, False: 0]
  ------------------
 1555|      0|      return parse_presentation_type(pres::chr, integral_set);
 1556|      0|    case 's':
  ------------------
  |  Branch (1556:5): [True: 0, False: 2.09k]
  ------------------
 1557|      0|      return parse_presentation_type(pres::string,
 1558|      0|                                     bool_set | string_set | cstring_set);
 1559|      0|    case 'p':
  ------------------
  |  Branch (1559:5): [True: 0, False: 2.09k]
  ------------------
 1560|      0|      return parse_presentation_type(pres::pointer, pointer_set | cstring_set);
 1561|      0|    case '?':
  ------------------
  |  Branch (1561:5): [True: 0, False: 2.09k]
  ------------------
 1562|      0|      return parse_presentation_type(pres::debug,
 1563|      0|                                     char_set | string_set | cstring_set);
 1564|      0|    case '}': return begin;
  ------------------
  |  Branch (1564:5): [True: 0, False: 2.09k]
  ------------------
 1565|      0|    default:  {
  ------------------
  |  Branch (1565:5): [True: 0, False: 2.09k]
  ------------------
 1566|      0|      if (*begin == '}') return begin;
  ------------------
  |  Branch (1566:11): [True: 0, False: 0]
  ------------------
 1567|       |      // Parse fill and alignment.
 1568|      0|      auto fill_end = begin + code_point_length(begin);
 1569|      0|      if (end - fill_end <= 0) {
  ------------------
  |  Branch (1569:11): [True: 0, False: 0]
  ------------------
 1570|      0|        report_error("invalid format specifier");
 1571|      0|        return begin;
 1572|      0|      }
 1573|      0|      if (*begin == '{') {
  ------------------
  |  Branch (1573:11): [True: 0, False: 0]
  ------------------
 1574|      0|        report_error("invalid fill character '{'");
 1575|      0|        return begin;
 1576|      0|      }
 1577|      0|      auto alignment = parse_align(to_ascii(*fill_end));
 1578|      0|      enter_state(state::align, alignment != align::none);
 1579|      0|      specs.set_fill(
 1580|      0|          basic_string_view<Char>(begin, to_unsigned(fill_end - begin)));
 1581|      0|      specs.set_align(alignment);
 1582|      0|      begin = fill_end + 1;
 1583|      0|    }
 1584|  2.09k|    }
 1585|  1.04k|    if (begin == end) return begin;
  ------------------
  |  Branch (1585:9): [True: 0, False: 1.04k]
  ------------------
 1586|  1.04k|    c = to_ascii(*begin);
 1587|  1.04k|  }
 1588|  1.04k|}
_ZNK3fmt3v126detail6bufferIjE8capacityEv:
 1801|  4.23k|  constexpr auto capacity() const noexcept -> size_t { return capacity_; }
_ZN3fmt3v126detail4copyIjPjS3_TnNSt3__19enable_ifIXoontcvNS1_23is_back_insert_iteratorIT1_NS4_17integral_constantIbLb1EEEEE_EntoocvNS1_10has_appendIS7_T0_vEE_EcvNS1_10has_insertIS7_SC_vEE_EEiE4typeELi0EEES7_SC_SC_S7_:
 1925|  4.23k|FMT_CONSTEXPR auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt {
 1926|  14.3k|  while (begin != end) *out++ = static_cast<T>(*begin++);
  ------------------
  |  Branch (1926:10): [True: 10.0k, False: 4.23k]
  ------------------
 1927|  4.23k|  return out;
 1928|  4.23k|}
_ZN3fmt3v126detail6bufferIcE6appendIcEEvPKT_S7_:
 1832|  4.08k|  FMT_CONSTEXPR20 void append(const U* begin, const U* end) {
 1833|  4.08k|    static_assert(std::is_same<T, U>() || std::is_same<U, char>(), "");
 1834|  6.07k|    while (begin != end) {
  ------------------
  |  Branch (1834:12): [True: 1.98k, False: 4.08k]
  ------------------
 1835|  1.98k|      auto size = size_;
 1836|  1.98k|      auto free_cap = capacity_ - size;
 1837|  1.98k|      auto count = to_unsigned(end - begin);
 1838|  1.98k|      if (free_cap < count) {
  ------------------
  |  Branch (1838:11): [True: 0, False: 1.98k]
  ------------------
 1839|      0|        grow_(*this, size + count);
 1840|      0|        size = size_;
 1841|      0|        free_cap = capacity_ - size;
 1842|      0|        count = count < free_cap ? count : free_cap;
  ------------------
  |  Branch (1842:17): [True: 0, False: 0]
  ------------------
 1843|      0|      }
 1844|       |      // A loop is faster than memcpy on small sizes.
 1845|  1.98k|      T* out = ptr_ + size;
 1846|  40.7k|      for (size_t i = 0; i < count; ++i) out[i] = static_cast<T>(begin[i]);
  ------------------
  |  Branch (1846:26): [True: 38.7k, False: 1.98k]
  ------------------
 1847|  1.98k|      size_ += count;
 1848|  1.98k|      begin += count;
 1849|  1.98k|    }
 1850|  4.08k|  }
_ZN3fmt3v1214basic_appenderIcEC2ERNS0_6detail6bufferIcEE:
 2447|  2.09k|  constexpr basic_appender(detail::buffer<T>& buf) : container(&buf) {}
_ZN3fmt3v1216basic_format_argINS0_7contextEEC2Ev:
 2482|  2.09k|  constexpr basic_format_arg() : type_(detail::type::none_type) {}
_ZN3fmt3v126detail5valueINS0_7contextEEC2Ev:
 2167|  2.09k|  constexpr FMT_INLINE value() : no_value() {}
_ZNK3fmt3v1216basic_format_argINS0_7contextEE5visitINS0_6detail21default_arg_formatterIcEEEEDTclfp_Li0EEEOT_:
 2500|  1.04k|  FMT_CONSTEXPR FMT_INLINE auto visit(Visitor&& vis) const -> decltype(vis(0)) {
 2501|  1.04k|    using detail::map;
 2502|  1.04k|    switch (type_) {
  ------------------
  |  Branch (2502:13): [True: 1.04k, False: 0]
  ------------------
 2503|      0|    case detail::type::none_type:        break;
  ------------------
  |  Branch (2503:5): [True: 0, False: 1.04k]
  ------------------
 2504|      0|    case detail::type::int_type:         return vis(value_.int_value);
  ------------------
  |  Branch (2504:5): [True: 0, False: 1.04k]
  ------------------
 2505|      0|    case detail::type::uint_type:        return vis(value_.uint_value);
  ------------------
  |  Branch (2505:5): [True: 0, False: 1.04k]
  ------------------
 2506|      0|    case detail::type::long_long_type:   return vis(value_.long_long_value);
  ------------------
  |  Branch (2506:5): [True: 0, False: 1.04k]
  ------------------
 2507|      0|    case detail::type::ulong_long_type:  return vis(value_.ulong_long_value);
  ------------------
  |  Branch (2507:5): [True: 0, False: 1.04k]
  ------------------
 2508|      0|    case detail::type::int128_type:      return vis(map(value_.int128_value));
  ------------------
  |  Branch (2508:5): [True: 0, False: 1.04k]
  ------------------
 2509|      0|    case detail::type::uint128_type:     return vis(map(value_.uint128_value));
  ------------------
  |  Branch (2509:5): [True: 0, False: 1.04k]
  ------------------
 2510|      0|    case detail::type::bool_type:        return vis(value_.bool_value);
  ------------------
  |  Branch (2510:5): [True: 0, False: 1.04k]
  ------------------
 2511|      0|    case detail::type::char_type:        return vis(value_.char_value);
  ------------------
  |  Branch (2511:5): [True: 0, False: 1.04k]
  ------------------
 2512|      0|    case detail::type::float_type:       return vis(value_.float_value);
  ------------------
  |  Branch (2512:5): [True: 0, False: 1.04k]
  ------------------
 2513|  1.04k|    case detail::type::double_type:      return vis(value_.double_value);
  ------------------
  |  Branch (2513:5): [True: 1.04k, False: 0]
  ------------------
 2514|      0|    case detail::type::long_double_type: return vis(value_.long_double_value);
  ------------------
  |  Branch (2514:5): [True: 0, False: 1.04k]
  ------------------
 2515|      0|    case detail::type::cstring_type:     return vis(value_.string.data);
  ------------------
  |  Branch (2515:5): [True: 0, False: 1.04k]
  ------------------
 2516|      0|    case detail::type::string_type:      return vis(value_.string.str());
  ------------------
  |  Branch (2516:5): [True: 0, False: 1.04k]
  ------------------
 2517|      0|    case detail::type::pointer_type:     return vis(value_.pointer);
  ------------------
  |  Branch (2517:5): [True: 0, False: 1.04k]
  ------------------
 2518|      0|    case detail::type::custom_type:      return vis(handle(value_.custom));
  ------------------
  |  Branch (2518:5): [True: 0, False: 1.04k]
  ------------------
 2519|  1.04k|    }
 2520|      0|    return vis(monostate());
 2521|  1.04k|  }
_ZZN3fmt3v126detail13get_containerINS0_14basic_appenderIcEEEERNT_14container_typeES5_EN8accessorC2ES4_:
  495|  6.40k|    constexpr accessor(OutputIt base) : OutputIt(base) {}
_ZNK3fmt3v1211basic_specs9fill_unitIcEET_v:
  797|    178|  template <typename Char> constexpr auto fill_unit() const -> Char {
  798|    178|    using uchar = unsigned char;
  799|    178|    return Char(uchar(fill_data_[0]) | uchar(fill_data_[1]) << 8 |
  800|    178|                uchar(fill_data_[2]) << 16);
  801|    178|  }
_ZN3fmt3v126detail4copyIcPKcNS0_14basic_appenderIcEETnNSt3__19enable_ifIXaacvNS1_23is_back_insert_iteratorIT1_NS7_17integral_constantIbLb1EEEEE_EcvNS1_10has_appendISA_T0_vEE_EEiE4typeELi0EEESA_SF_SF_SA_:
 1906|  3.90k|FMT_CONSTEXPR auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt {
 1907|  3.90k|  get_container(out).append(begin, end);
 1908|  3.90k|  return out;
 1909|  3.90k|}
_ZN3fmt3v126detail6bufferIjEC2EPFvRS3_mEPjmm:
 1773|  8.05k|      : ptr_(p), size_(sz), capacity_(cap), grow_(grow) {}
_ZN3fmt3v126detail19parse_format_stringIcNS1_14format_handlerIcEEEEvNS0_17basic_string_viewIT_EEOT0_:
 1639|  1.04k|                                       Handler&& handler) {
 1640|  1.04k|  auto begin = fmt.data(), end = begin + fmt.size();
 1641|  1.04k|  auto p = begin;
 1642|  2.09k|  while (p != end) {
  ------------------
  |  Branch (1642:10): [True: 1.04k, False: 1.04k]
  ------------------
 1643|  1.04k|    auto c = *p++;
 1644|  1.04k|    if (c == '{') {
  ------------------
  |  Branch (1644:9): [True: 1.04k, False: 0]
  ------------------
 1645|  1.04k|      handler.on_text(begin, p - 1);
 1646|  1.04k|      begin = p = parse_replacement_field(p - 1, end, handler);
 1647|  1.04k|    } else if (c == '}') {
  ------------------
  |  Branch (1647:16): [True: 0, False: 0]
  ------------------
 1648|      0|      if (p == end || *p != '}')
  ------------------
  |  Branch (1648:11): [True: 0, False: 0]
  |  Branch (1648:23): [True: 0, False: 0]
  ------------------
 1649|      0|        return handler.on_error("unmatched '}' in format string");
 1650|      0|      handler.on_text(begin, p);
 1651|      0|      begin = ++p;
 1652|      0|    }
 1653|  1.04k|  }
 1654|  1.04k|  handler.on_text(begin, end);
 1655|  1.04k|}
_ZN3fmt3v126detail23parse_replacement_fieldIcRNS1_14format_handlerIcEEEEPKT_S8_S8_OT0_:
 1594|  1.04k|    -> const Char* {
 1595|  1.04k|  ++begin;
 1596|  1.04k|  if (begin == end) {
  ------------------
  |  Branch (1596:7): [True: 0, False: 1.04k]
  ------------------
 1597|      0|    handler.on_error("invalid format string");
 1598|      0|    return end;
 1599|      0|  }
 1600|  1.04k|  int arg_id = 0;
 1601|  1.04k|  switch (*begin) {
 1602|      0|  case '}':
  ------------------
  |  Branch (1602:3): [True: 0, False: 1.04k]
  ------------------
 1603|      0|    handler.on_replacement_field(handler.on_arg_id(), begin);
 1604|      0|    return begin + 1;
 1605|      0|  case '{': handler.on_text(begin, begin + 1); return begin + 1;
  ------------------
  |  Branch (1605:3): [True: 0, False: 1.04k]
  ------------------
 1606|  1.04k|  case ':': arg_id = handler.on_arg_id(); break;
  ------------------
  |  Branch (1606:3): [True: 1.04k, False: 0]
  ------------------
 1607|      0|  default:  {
  ------------------
  |  Branch (1607:3): [True: 0, False: 1.04k]
  ------------------
 1608|      0|    struct id_adapter {
 1609|      0|      Handler& handler;
 1610|      0|      int arg_id;
 1611|       |
 1612|      0|      FMT_CONSTEXPR void on_index(int id) { arg_id = handler.on_arg_id(id); }
 1613|      0|      FMT_CONSTEXPR void on_name(basic_string_view<Char> id) {
 1614|      0|        arg_id = handler.on_arg_id(id);
 1615|      0|      }
 1616|      0|    } adapter = {handler, 0};
 1617|      0|    begin = parse_arg_id(begin, end, adapter);
 1618|      0|    arg_id = adapter.arg_id;
 1619|      0|    Char c = begin != end ? *begin : Char();
  ------------------
  |  Branch (1619:14): [True: 0, False: 0]
  ------------------
 1620|      0|    if (c == '}') {
  ------------------
  |  Branch (1620:9): [True: 0, False: 0]
  ------------------
 1621|      0|      handler.on_replacement_field(arg_id, begin);
 1622|      0|      return begin + 1;
 1623|      0|    }
 1624|      0|    if (c != ':') {
  ------------------
  |  Branch (1624:9): [True: 0, False: 0]
  ------------------
 1625|      0|      handler.on_error("missing '}' in format string");
 1626|      0|      return end;
 1627|      0|    }
 1628|      0|    break;
 1629|      0|  }
 1630|  1.04k|  }
 1631|  1.04k|  begin = handler.on_format_specs(arg_id, begin + 1, end);
 1632|  1.04k|  if (begin == end || *begin != '}')
  ------------------
  |  Branch (1632:7): [True: 0, False: 1.04k]
  |  Branch (1632:23): [True: 0, False: 1.04k]
  ------------------
 1633|      0|    return handler.on_error("unknown format specifier"), end;
 1634|  1.04k|  return begin + 1;
 1635|  1.04k|}
_ZNK3fmt3v1216basic_format_argINS0_7contextEEcvbEv:
 2489|  1.04k|  constexpr explicit operator bool() const noexcept {
 2490|  1.04k|    return type_ != detail::type::none_type;
 2491|  1.04k|  }
_ZN3fmt3v1216basic_format_argINS0_7contextEE13format_customEPKcRNS0_13parse_contextIcEERS2_:
 2525|  1.04k|      -> bool {
 2526|  1.04k|    if (type_ != detail::type::custom_type) return false;
  ------------------
  |  Branch (2526:9): [True: 1.04k, False: 0]
  ------------------
 2527|      0|    parse_ctx.advance_to(parse_begin);
 2528|      0|    value_.custom.format(value_.custom.value, parse_ctx, ctx);
 2529|      0|    return true;
 2530|  1.04k|  }
_ZN3fmt3v126detail7arg_refIcEC2Ei:
 1272|  2.09k|  FMT_CONSTEXPR arg_ref(int idx = 0) : index(idx) {}
_ZNK3fmt3v1216basic_format_argINS0_7contextEE4typeEv:
 2492|  1.04k|  auto type() const -> detail::type { return type_; }
_ZNK3fmt3v1216basic_format_argINS0_7contextEE5visitINS0_6detail13arg_formatterIcEEEEDTclfp_Li0EEEOT_:
 2500|  1.04k|  FMT_CONSTEXPR FMT_INLINE auto visit(Visitor&& vis) const -> decltype(vis(0)) {
 2501|  1.04k|    using detail::map;
 2502|  1.04k|    switch (type_) {
  ------------------
  |  Branch (2502:13): [True: 1.04k, False: 0]
  ------------------
 2503|      0|    case detail::type::none_type:        break;
  ------------------
  |  Branch (2503:5): [True: 0, False: 1.04k]
  ------------------
 2504|      0|    case detail::type::int_type:         return vis(value_.int_value);
  ------------------
  |  Branch (2504:5): [True: 0, False: 1.04k]
  ------------------
 2505|      0|    case detail::type::uint_type:        return vis(value_.uint_value);
  ------------------
  |  Branch (2505:5): [True: 0, False: 1.04k]
  ------------------
 2506|      0|    case detail::type::long_long_type:   return vis(value_.long_long_value);
  ------------------
  |  Branch (2506:5): [True: 0, False: 1.04k]
  ------------------
 2507|      0|    case detail::type::ulong_long_type:  return vis(value_.ulong_long_value);
  ------------------
  |  Branch (2507:5): [True: 0, False: 1.04k]
  ------------------
 2508|      0|    case detail::type::int128_type:      return vis(map(value_.int128_value));
  ------------------
  |  Branch (2508:5): [True: 0, False: 1.04k]
  ------------------
 2509|      0|    case detail::type::uint128_type:     return vis(map(value_.uint128_value));
  ------------------
  |  Branch (2509:5): [True: 0, False: 1.04k]
  ------------------
 2510|      0|    case detail::type::bool_type:        return vis(value_.bool_value);
  ------------------
  |  Branch (2510:5): [True: 0, False: 1.04k]
  ------------------
 2511|      0|    case detail::type::char_type:        return vis(value_.char_value);
  ------------------
  |  Branch (2511:5): [True: 0, False: 1.04k]
  ------------------
 2512|      0|    case detail::type::float_type:       return vis(value_.float_value);
  ------------------
  |  Branch (2512:5): [True: 0, False: 1.04k]
  ------------------
 2513|  1.04k|    case detail::type::double_type:      return vis(value_.double_value);
  ------------------
  |  Branch (2513:5): [True: 1.04k, False: 0]
  ------------------
 2514|      0|    case detail::type::long_double_type: return vis(value_.long_double_value);
  ------------------
  |  Branch (2514:5): [True: 0, False: 1.04k]
  ------------------
 2515|      0|    case detail::type::cstring_type:     return vis(value_.string.data);
  ------------------
  |  Branch (2515:5): [True: 0, False: 1.04k]
  ------------------
 2516|      0|    case detail::type::string_type:      return vis(value_.string.str());
  ------------------
  |  Branch (2516:5): [True: 0, False: 1.04k]
  ------------------
 2517|      0|    case detail::type::pointer_type:     return vis(value_.pointer);
  ------------------
  |  Branch (2517:5): [True: 0, False: 1.04k]
  ------------------
 2518|      0|    case detail::type::custom_type:      return vis(handle(value_.custom));
  ------------------
  |  Branch (2518:5): [True: 0, False: 1.04k]
  ------------------
 2519|  1.04k|    }
 2520|      0|    return vis(monostate());
 2521|  1.04k|  }
_ZN3fmt3v1213parse_contextIcEC2ENS0_17basic_string_viewIcEEi:
  857|  1.04k|      : fmt_(fmt), next_arg_id_(next_arg_id) {}

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

_ZN3fmt3v1219basic_memory_bufferIcLm500ENS0_6detail9allocatorIcEEEC2ERKS4_:
  824|  3.04k|      : detail::buffer<T>(grow), alloc_(alloc) {
  825|  3.04k|    this->set(store_, SIZE);
  826|  3.04k|    if (detail::is_constant_evaluated()) detail::fill_n(store_, SIZE, T());
  ------------------
  |  Branch (826:9): [Folded, False: 3.04k]
  ------------------
  827|  3.04k|  }
_ZN3fmt3v126detail16abort_fuzzing_ifEb:
  240|    362|FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) {
  241|    362|  ignore_unused(condition);
  242|    362|#ifdef FMT_FUZZ
  243|    362|  if (condition) throw std::runtime_error("fuzzing limit reached");
  ------------------
  |  Branch (243:7): [True: 0, False: 362]
  ------------------
  244|    362|#endif
  245|    362|}
_ZN3fmt3v126detail9max_valueImEET_v:
  410|    894|template <typename T> constexpr auto max_value() -> T {
  411|    894|  return (std::numeric_limits<T>::max)();
  412|    894|}
_ZN3fmt3v1219basic_memory_bufferIcLm500ENS0_6detail9allocatorIcEEED2Ev:
  828|  3.04k|  FMT_CONSTEXPR20 ~basic_memory_buffer() { deallocate(); }
_ZN3fmt3v1219basic_memory_bufferIcLm500ENS0_6detail9allocatorIcEEE10deallocateEv:
  789|  3.04k|  FMT_CONSTEXPR20 void deallocate() {
  790|  3.04k|    T* data = this->data();
  791|  3.04k|    if (data != store_) alloc_.deallocate(data, this->capacity());
  ------------------
  |  Branch (791:9): [True: 0, False: 3.04k]
  ------------------
  792|  3.04k|  }
_ZN3fmt3v126detail7uint128C2Emm:
  298|  2.07k|  constexpr uint128(uint64_t hi, uint64_t lo) : lo_(lo), hi_(hi) {}
_ZNK3fmt3v126detail7uint1284highEv:
  301|  5.59k|  constexpr auto high() const noexcept -> uint64_t { return hi_; }
_ZNK3fmt3v126detail7uint1283lowEv:
  302|  3.99k|  constexpr auto low() const noexcept -> uint64_t { return lo_; }
_ZN3fmt3v126detail7uint128pLEm:
  374|  1.76k|  FMT_CONSTEXPR20 auto operator+=(uint64_t n) noexcept -> uint128& {
  375|  1.76k|    if (is_constant_evaluated()) {
  ------------------
  |  Branch (375:9): [Folded, False: 1.76k]
  ------------------
  376|      0|      lo_ += n;
  377|      0|      hi_ += (lo_ < n ? 1 : 0);
  ------------------
  |  Branch (377:15): [True: 0, False: 0]
  ------------------
  378|      0|      return *this;
  379|      0|    }
  380|  1.76k|#if FMT_HAS_BUILTIN(__builtin_addcll) && !defined(__ibmxl__)
  381|  1.76k|    ullong carry;
  382|  1.76k|    lo_ = __builtin_addcll(lo_, n, 0, &carry);
  383|  1.76k|    hi_ += carry;
  384|       |#elif FMT_HAS_BUILTIN(__builtin_ia32_addcarryx_u64) && !defined(__ibmxl__)
  385|       |    ullong result;
  386|       |    auto carry = __builtin_ia32_addcarryx_u64(0, lo_, n, &result);
  387|       |    lo_ = result;
  388|       |    hi_ += carry;
  389|       |#elif defined(_MSC_VER) && defined(_M_AMD64)
  390|       |    auto carry = _addcarry_u64(0, lo_, n, &lo_);
  391|       |    _addcarry_u64(carry, hi_, 0, &hi_);
  392|       |#else
  393|       |    lo_ += n;
  394|       |    hi_ += (lo_ < n ? 1 : 0);
  395|       |#endif
  396|  1.76k|    return *this;
  397|  1.76k|  }
_ZN3fmt3v126detail20num_significand_bitsIdEEiv:
 1537|  10.1k|template <typename Float> constexpr auto num_significand_bits() -> int {
 1538|       |  // std::numeric_limits may not support __float128.
 1539|  10.1k|  return is_float128<Float>() ? 112
  ------------------
  |  Branch (1539:10): [Folded, False: 10.1k]
  ------------------
 1540|  10.1k|                              : (std::numeric_limits<Float>::digits -
 1541|  10.1k|                                 (has_implicit_bit<Float>() ? 1 : 0));
  ------------------
  |  Branch (1541:35): [True: 10.1k, Folded]
  ------------------
 1542|  10.1k|}
_ZN3fmt3v126detail9max_valueIiEET_v:
  410|    376|template <typename T> constexpr auto max_value() -> T {
  411|    376|  return (std::numeric_limits<T>::max)();
  412|    376|}
_ZN3fmt3v126detail6fill_nINS0_14basic_appenderIcEEicEET_S5_T0_RKT1_:
  541|    512|    -> OutputIt {
  542|    892|  for (Size i = 0; i < count; ++i) *out++ = value;
  ------------------
  |  Branch (542:20): [True: 380, False: 512]
  ------------------
  543|    512|  return out;
  544|    512|}
_ZN3fmt3v126detail8num_bitsIjEEiv:
  413|  21.0k|template <typename T> constexpr auto num_bits() -> int {
  414|  21.0k|  return std::numeric_limits<T>::digits;
  415|  21.0k|}
_ZNK3fmt3v126detail6bigint9get_bigitEi:
 2701|  3.00k|  FMT_CONSTEXPR auto get_bigit(int i) const -> bigit {
 2702|  3.00k|    return i >= exp_ && i < num_bigits() ? bigits_[i - exp_] : 0;
  ------------------
  |  Branch (2702:12): [True: 2.93k, False: 67]
  |  Branch (2702:25): [True: 2.09k, False: 840]
  ------------------
 2703|  3.00k|  }
_ZN3fmt3v126detail6bigint15subtract_bigitsEijRj:
 2705|   731k|  FMT_CONSTEXPR void subtract_bigits(int index, bigit other, bigit& borrow) {
 2706|   731k|    auto result = double_bigit(bigits_[index]) - other - borrow;
 2707|   731k|    bigits_[index] = static_cast<bigit>(result);
 2708|   731k|    borrow = static_cast<bigit>(result >> (bigit_bits * 2 - 1));
 2709|   731k|  }
_ZN3fmt3v1219basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEE6resizeEm:
  891|   177k|  FMT_CONSTEXPR void resize(size_t count) { this->try_resize(count); }
_ZN3fmt3v126detail6bigint20remove_leading_zerosEv:
 2711|   165k|  FMT_CONSTEXPR void remove_leading_zeros() {
 2712|   165k|    int num_bigits = static_cast<int>(bigits_.size()) - 1;
 2713|   173k|    while (num_bigits > 0 && bigits_[num_bigits] == 0) --num_bigits;
  ------------------
  |  Branch (2713:12): [True: 171k, False: 2.58k]
  |  Branch (2713:30): [True: 7.80k, False: 163k]
  ------------------
 2714|   165k|    bigits_.resize(to_unsigned(num_bigits + 1));
 2715|   165k|  }
_ZN3fmt3v126detail6bigint16subtract_alignedERKS2_:
 2718|   161k|  FMT_CONSTEXPR void subtract_aligned(const bigint& other) {
 2719|   161k|    FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints");
  ------------------
  |  |  402|   161k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 161k, False: 0]
  |  |  ------------------
  |  |  403|   161k|         ? (void)0                                                          \
  |  |  404|   161k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2720|   161k|    FMT_ASSERT(compare(*this, other) >= 0, "");
  ------------------
  |  |  402|   161k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 161k, False: 0]
  |  |  ------------------
  |  |  403|   161k|         ? (void)0                                                          \
  |  |  404|   161k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2721|   161k|    bigit borrow = 0;
 2722|   161k|    int i = other.exp_ - exp_;
 2723|   889k|    for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j)
  ------------------
  |  Branch (2723:50): [True: 728k, False: 161k]
  ------------------
 2724|   728k|      subtract_bigits(i, other.bigits_[j], borrow);
 2725|   161k|    if (borrow != 0) subtract_bigits(i, 0, borrow);
  ------------------
  |  Branch (2725:9): [True: 3.68k, False: 158k]
  ------------------
 2726|   161k|    FMT_ASSERT(borrow == 0, "");
  ------------------
  |  |  402|   161k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 161k, False: 0]
  |  |  ------------------
  |  |  403|   161k|         ? (void)0                                                          \
  |  |  404|   161k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2727|   161k|    remove_leading_zeros();
 2728|   161k|  }
_ZN3fmt3v126detail6bigint8multiplyEj:
 2730|  48.9k|  FMT_CONSTEXPR void multiply(uint32_t value) {
 2731|  48.9k|    bigit carry = 0;
 2732|  48.9k|    const double_bigit wide_value = value;
 2733|   491k|    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
  ------------------
  |  Branch (2733:44): [True: 442k, False: 48.9k]
  ------------------
 2734|   442k|      double_bigit result = bigits_[i] * wide_value + carry;
 2735|   442k|      bigits_[i] = static_cast<bigit>(result);
 2736|   442k|      carry = static_cast<bigit>(result >> bigit_bits);
 2737|   442k|    }
 2738|  48.9k|    if (carry != 0) bigits_.push_back(carry);
  ------------------
  |  Branch (2738:9): [True: 4.33k, False: 44.5k]
  ------------------
 2739|  48.9k|  }
_ZN3fmt3v126detail6bigintC2Ev:
 2775|  3.82k|  FMT_CONSTEXPR bigint() : exp_(0) {}
_ZN3fmt3v126detail6bigint6assignImTnNSt3__19enable_ifIXoosr3std7is_sameIT_mEE5valuesr3std7is_sameIS6_oEE5valueEiE4typeELi0EEEvS6_:
 2764|  1.98k|  FMT_CONSTEXPR void assign(UInt n) {
 2765|  1.98k|    size_t num_bigits = 0;
 2766|  1.98k|    do {
 2767|  1.98k|      bigits_[num_bigits++] = static_cast<bigit>(n);
 2768|  1.98k|      n >>= bigit_bits;
 2769|  1.98k|    } while (n != 0);
  ------------------
  |  Branch (2769:14): [True: 0, False: 1.98k]
  ------------------
 2770|  1.98k|    bigits_.resize(num_bigits);
 2771|  1.98k|    exp_ = 0;
 2772|  1.98k|  }
_ZN3fmt3v126detail6bigint6assignERKS2_:
 2781|    495|  FMT_CONSTEXPR void assign(const bigint& other) {
 2782|    495|    auto size = other.bigits_.size();
 2783|    495|    bigits_.resize(size);
 2784|    495|    auto data = other.bigits_.data();
 2785|    495|    copy<bigit>(data, data + size, bigits_.data());
 2786|    495|    exp_ = other.exp_;
 2787|    495|  }
_ZNK3fmt3v126detail6bigint10num_bigitsEv:
 2794|   748k|  FMT_CONSTEXPR auto num_bigits() const -> int {
 2795|   748k|    return static_cast<int>(bigits_.size()) + exp_;
 2796|   748k|  }
_ZN3fmt3v126detail6bigintlSEi:
 2798|  3.15k|  FMT_CONSTEXPR auto operator<<=(int shift) -> bigint& {
 2799|  3.15k|    FMT_ASSERT(shift >= 0, "");
  ------------------
  |  |  402|  3.15k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 3.15k, False: 0]
  |  |  ------------------
  |  |  403|  3.15k|         ? (void)0                                                          \
  |  |  404|  3.15k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2800|  3.15k|    exp_ += shift / bigit_bits;
 2801|  3.15k|    shift %= bigit_bits;
 2802|  3.15k|    if (shift == 0) return *this;
  ------------------
  |  Branch (2802:9): [True: 75, False: 3.08k]
  ------------------
 2803|  3.08k|    bigit carry = 0;
 2804|  22.2k|    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
  ------------------
  |  Branch (2804:44): [True: 19.1k, False: 3.08k]
  ------------------
 2805|  19.1k|      bigit c = bigits_[i] >> (bigit_bits - shift);
 2806|  19.1k|      bigits_[i] = (bigits_[i] << shift) + carry;
 2807|  19.1k|      carry = c;
 2808|  19.1k|    }
 2809|  3.08k|    if (carry != 0) bigits_.push_back(carry);
  ------------------
  |  Branch (2809:9): [True: 492, False: 2.59k]
  ------------------
 2810|  3.08k|    return *this;
 2811|  3.15k|  }
_ZN3fmt3v126detail7compareERKNS1_6bigintES4_:
 2819|   371k|  friend FMT_CONSTEXPR auto compare(const bigint& b1, const bigint& b2) -> int {
 2820|   371k|    int num_bigits1 = b1.num_bigits(), num_bigits2 = b2.num_bigits();
 2821|   371k|    if (num_bigits1 != num_bigits2) return num_bigits1 > num_bigits2 ? 1 : -1;
  ------------------
  |  Branch (2821:9): [True: 28.5k, False: 342k]
  |  Branch (2821:44): [True: 12.7k, False: 15.7k]
  ------------------
 2822|   342k|    int i = static_cast<int>(b1.bigits_.size()) - 1;
 2823|   342k|    int j = static_cast<int>(b2.bigits_.size()) - 1;
 2824|   342k|    int end = i - j;
 2825|   342k|    if (end < 0) end = 0;
  ------------------
  |  Branch (2825:9): [True: 148, False: 342k]
  ------------------
 2826|   349k|    for (; i >= end; --i, --j) {
  ------------------
  |  Branch (2826:12): [True: 344k, False: 4.77k]
  ------------------
 2827|   344k|      bigit b1_bigit = b1.bigits_[i], b2_bigit = b2.bigits_[j];
 2828|   344k|      if (b1_bigit != b2_bigit) return b1_bigit > b2_bigit ? 1 : -1;
  ------------------
  |  Branch (2828:11): [True: 337k, False: 6.71k]
  |  Branch (2828:40): [True: 305k, False: 31.9k]
  ------------------
 2829|   344k|    }
 2830|  4.77k|    if (i != j) return i > j ? 1 : -1;
  ------------------
  |  Branch (2830:9): [True: 4.29k, False: 480]
  |  Branch (2830:24): [True: 4.29k, False: 0]
  ------------------
 2831|    480|    return 0;
 2832|  4.77k|  }
_ZN3fmt3v126detail11add_compareERKNS1_6bigintES4_S4_:
 2836|    955|                                        const bigint& rhs) -> int {
 2837|    955|    int max_lhs_bigits = max_of(lhs1.num_bigits(), lhs2.num_bigits());
 2838|    955|    int num_rhs_bigits = rhs.num_bigits();
 2839|    955|    if (max_lhs_bigits + 1 < num_rhs_bigits) return -1;
  ------------------
  |  Branch (2839:9): [True: 45, False: 910]
  ------------------
 2840|    910|    if (max_lhs_bigits > num_rhs_bigits) return 1;
  ------------------
  |  Branch (2840:9): [True: 0, False: 910]
  ------------------
 2841|    910|    double_bigit borrow = 0;
 2842|    910|    int min_exp = min_of(min_of(lhs1.exp_, lhs2.exp_), rhs.exp_);
 2843|  1.01k|    for (int i = num_rhs_bigits - 1; i >= min_exp; --i) {
  ------------------
  |  Branch (2843:38): [True: 1.00k, False: 9]
  ------------------
 2844|  1.00k|      double_bigit sum = double_bigit(lhs1.get_bigit(i)) + lhs2.get_bigit(i);
 2845|  1.00k|      bigit rhs_bigit = rhs.get_bigit(i);
 2846|  1.00k|      if (sum > rhs_bigit + borrow) return 1;
  ------------------
  |  Branch (2846:11): [True: 271, False: 731]
  ------------------
 2847|    731|      borrow = rhs_bigit + borrow - sum;
 2848|    731|      if (borrow > 1) return -1;
  ------------------
  |  Branch (2848:11): [True: 630, False: 101]
  ------------------
 2849|    101|      borrow <<= bigit_bits;
 2850|    101|    }
 2851|      9|    return borrow != 0 ? -1 : 0;
  ------------------
  |  Branch (2851:12): [True: 0, False: 9]
  ------------------
 2852|    910|  }
_ZN3fmt3v126detail6bigintaSIiEEvT_:
 2789|  1.95k|  template <typename Int> FMT_CONSTEXPR void operator=(Int n) {
 2790|  1.95k|    FMT_ASSERT(n > 0, "");
  ------------------
  |  |  402|  1.95k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 1.95k, False: 0]
  |  |  ------------------
  |  |  403|  1.95k|         ? (void)0                                                          \
  |  |  404|  1.95k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2791|  1.95k|    assign(uint64_or_128_t<Int>(n));
 2792|  1.95k|  }
_ZN3fmt3v126detail6bigintmLIiEERS2_T_:
 2813|  48.9k|  template <typename Int> FMT_CONSTEXPR auto operator*=(Int value) -> bigint& {
 2814|  48.9k|    FMT_ASSERT(value > 0, "");
  ------------------
  |  |  402|  48.9k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 48.9k, False: 0]
  |  |  ------------------
  |  |  403|  48.9k|         ? (void)0                                                          \
  |  |  404|  48.9k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2815|  48.9k|    multiply(uint32_or_64_or_128_t<Int>(value));
 2816|  48.9k|    return *this;
 2817|  48.9k|  }
_ZN3fmt3v126detail6bigint12assign_pow10Ei:
 2855|    955|  FMT_CONSTEXPR20 void assign_pow10(int exp) {
 2856|    955|    FMT_ASSERT(exp >= 0, "");
  ------------------
  |  |  402|    955|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 955, False: 0]
  |  |  ------------------
  |  |  403|    955|         ? (void)0                                                          \
  |  |  404|    955|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2857|    955|    if (exp == 0) return *this = 1;
  ------------------
  |  Branch (2857:9): [True: 33, False: 922]
  ------------------
 2858|    922|    int bitmask = 1 << (num_bits<unsigned>() -
 2859|    922|                        countl_zero(static_cast<uint32_t>(exp)) - 1);
 2860|       |    // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by
 2861|       |    // repeated squaring and multiplication.
 2862|    922|    *this = 5;
 2863|    922|    bitmask >>= 1;
 2864|  5.15k|    while (bitmask != 0) {
  ------------------
  |  Branch (2864:12): [True: 4.23k, False: 922]
  ------------------
 2865|  4.23k|      square();
 2866|  4.23k|      if ((exp & bitmask) != 0) *this *= 5;
  ------------------
  |  Branch (2866:11): [True: 2.10k, False: 2.12k]
  ------------------
 2867|  4.23k|      bitmask >>= 1;
 2868|  4.23k|    }
 2869|    922|    *this <<= exp;  // Multiply by pow(2, exp) by shifting.
 2870|    922|  }
_ZN3fmt3v126detail6bigint6squareEv:
 2872|  4.23k|  FMT_CONSTEXPR20 void square() {
 2873|  4.23k|    int num_bigits = static_cast<int>(bigits_.size());
 2874|  4.23k|    int num_result_bigits = 2 * num_bigits;
 2875|  4.23k|    basic_memory_buffer<bigit, bigits_capacity> n(std::move(bigits_));
 2876|  4.23k|    bigits_.resize(to_unsigned(num_result_bigits));
 2877|  4.23k|    auto sum = uint128_t();
 2878|  14.3k|    for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) {
  ------------------
  |  Branch (2878:31): [True: 10.0k, False: 4.23k]
  ------------------
 2879|       |      // Compute bigit at position bigit_index of the result by adding
 2880|       |      // cross-product terms n[i] * n[j] such that i + j == bigit_index.
 2881|  43.1k|      for (int i = 0, j = bigit_index; j >= 0; ++i, --j) {
  ------------------
  |  Branch (2881:40): [True: 33.0k, False: 10.0k]
  ------------------
 2882|       |        // Most terms are multiplied twice which can be optimized in the future.
 2883|  33.0k|        sum += double_bigit(n[i]) * n[j];
 2884|  33.0k|      }
 2885|  10.0k|      bigits_[bigit_index] = static_cast<bigit>(sum);
 2886|  10.0k|      sum >>= num_bits<bigit>();  // Compute the carry.
 2887|  10.0k|    }
 2888|       |    // Do the same for the top half.
 2889|  14.3k|    for (int bigit_index = num_bigits; bigit_index < num_result_bigits;
  ------------------
  |  Branch (2889:40): [True: 10.0k, False: 4.23k]
  ------------------
 2890|  10.0k|         ++bigit_index) {
 2891|  33.0k|      for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;)
  ------------------
  |  Branch (2891:57): [True: 22.9k, False: 10.0k]
  ------------------
 2892|  22.9k|        sum += double_bigit(n[i++]) * n[j--];
 2893|  10.0k|      bigits_[bigit_index] = static_cast<bigit>(sum);
 2894|  10.0k|      sum >>= num_bits<bigit>();
 2895|  10.0k|    }
 2896|  4.23k|    remove_leading_zeros();
 2897|  4.23k|    exp_ *= 2;
 2898|  4.23k|  }
_ZN3fmt3v126detail6fill_nIPjjjEET_S4_T0_RKT1_:
  541|    167|    -> OutputIt {
  542|  2.36k|  for (Size i = 0; i < count; ++i) *out++ = value;
  ------------------
  |  Branch (542:20): [True: 2.19k, False: 167]
  ------------------
  543|    167|  return out;
  544|    167|}
_ZN3fmt3v126detail6bigint5alignERKS2_:
 2902|  31.9k|  FMT_CONSTEXPR void align(const bigint& other) {
 2903|  31.9k|    int exp_difference = exp_ - other.exp_;
 2904|  31.9k|    if (exp_difference <= 0) return;
  ------------------
  |  Branch (2904:9): [True: 31.8k, False: 167]
  ------------------
 2905|    167|    int num_bigits = static_cast<int>(bigits_.size());
 2906|    167|    bigits_.resize(to_unsigned(num_bigits + exp_difference));
 2907|    627|    for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
  ------------------
  |  Branch (2907:58): [True: 460, False: 167]
  ------------------
 2908|    460|      bigits_[j] = bigits_[i];
 2909|    167|    fill_n(bigits_.data(), to_unsigned(exp_difference), 0U);
 2910|    167|    exp_ -= exp_difference;
 2911|    167|  }
_ZN3fmt3v126detail6bigint13divmod_assignERKS2_:
 2915|  47.7k|  FMT_CONSTEXPR auto divmod_assign(const bigint& divisor) -> int {
 2916|  47.7k|    FMT_ASSERT(this != &divisor, "");
  ------------------
  |  |  402|  47.7k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 47.7k, False: 0]
  |  |  ------------------
  |  |  403|  47.7k|         ? (void)0                                                          \
  |  |  404|  47.7k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2917|  47.7k|    if (compare(*this, divisor) < 0) return 0;
  ------------------
  |  Branch (2917:9): [True: 15.7k, False: 31.9k]
  ------------------
 2918|  31.9k|    FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, "");
  ------------------
  |  |  402|  31.9k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 31.9k, False: 0]
  |  |  ------------------
  |  |  403|  31.9k|         ? (void)0                                                          \
  |  |  404|  31.9k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2919|  31.9k|    align(divisor);
 2920|  31.9k|    int quotient = 0;
 2921|   161k|    do {
 2922|   161k|      subtract_aligned(divisor);
 2923|   161k|      ++quotient;
 2924|   161k|    } while (compare(*this, divisor) >= 0);
  ------------------
  |  Branch (2924:14): [True: 129k, False: 31.9k]
  ------------------
 2925|  31.9k|    return quotient;
 2926|  47.7k|  }
_ZN3fmt3v126detail6bigint6assignIoTnNSt3__19enable_ifIXoosr3std7is_sameIT_mEE5valuesr3std7is_sameIS6_oEE5valueEiE4typeELi0EEEvS6_:
 2764|    529|  FMT_CONSTEXPR void assign(UInt n) {
 2765|    529|    size_t num_bigits = 0;
 2766|  1.05k|    do {
 2767|  1.05k|      bigits_[num_bigits++] = static_cast<bigit>(n);
 2768|  1.05k|      n >>= bigit_bits;
 2769|  1.05k|    } while (n != 0);
  ------------------
  |  Branch (2769:14): [True: 529, False: 529]
  ------------------
 2770|    529|    bigits_.resize(num_bigits);
 2771|    529|    exp_ = 0;
 2772|    529|  }
_ZN3fmt3v126detail6bigintaSIoEEvT_:
 2789|    529|  template <typename Int> FMT_CONSTEXPR void operator=(Int n) {
 2790|    529|    FMT_ASSERT(n > 0, "");
  ------------------
  |  |  402|    529|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 529, False: 0]
  |  |  ------------------
  |  |  403|    529|         ? (void)0                                                          \
  |  |  404|    529|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2791|    529|    assign(uint64_or_128_t<Int>(n));
 2792|    529|  }
_ZN3fmt3v126detail8num_bitsImEEiv:
  413|    662|template <typename T> constexpr auto num_bits() -> int {
  414|    662|  return std::numeric_limits<T>::digits;
  415|    662|}
_ZN3fmt3v126detail6bigint8multiplyIoTnNSt3__19enable_ifIXoosr3std7is_sameIT_mEE5valuesr3std7is_sameIS6_oEE5valueEiE4typeELi0EEEvS6_:
 2743|    426|  FMT_CONSTEXPR void multiply(UInt value) {
 2744|    426|    using half_uint =
 2745|    426|        conditional_t<std::is_same<UInt, uint128_t>::value, uint64_t, uint32_t>;
 2746|    426|    const int shift = num_bits<half_uint>() - bigit_bits;
 2747|    426|    const UInt lower = static_cast<half_uint>(value);
 2748|    426|    const UInt upper = value >> num_bits<half_uint>();
 2749|    426|    UInt carry = 0;
 2750|  5.65k|    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
  ------------------
  |  Branch (2750:44): [True: 5.23k, False: 426]
  ------------------
 2751|  5.23k|      UInt result = lower * bigits_[i] + static_cast<bigit>(carry);
 2752|  5.23k|      carry = (upper * bigits_[i] << shift) + (result >> bigit_bits) +
 2753|  5.23k|              (carry >> bigit_bits);
 2754|  5.23k|      bigits_[i] = static_cast<bigit>(result);
 2755|  5.23k|    }
 2756|  1.00k|    while (carry != 0) {
  ------------------
  |  Branch (2756:12): [True: 579, False: 426]
  ------------------
 2757|    579|      bigits_.push_back(static_cast<bigit>(carry));
 2758|    579|      carry >>= bigit_bits;
 2759|    579|    }
 2760|    426|  }
_ZN3fmt3v126detail6bigintmLIoEERS2_T_:
 2813|    426|  template <typename Int> FMT_CONSTEXPR auto operator*=(Int value) -> bigint& {
 2814|    426|    FMT_ASSERT(value > 0, "");
  ------------------
  |  |  402|    426|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 426, False: 0]
  |  |  ------------------
  |  |  403|    426|         ? (void)0                                                          \
  |  |  404|    426|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2815|    426|    multiply(uint32_or_64_or_128_t<Int>(value));
 2816|    426|    return *this;
 2817|    426|  }
_ZN3fmt3v126detail6bigintaSIyEEvT_:
 2789|     29|  template <typename Int> FMT_CONSTEXPR void operator=(Int n) {
 2790|     29|    FMT_ASSERT(n > 0, "");
  ------------------
  |  |  402|     29|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 29, False: 0]
  |  |  ------------------
  |  |  403|     29|         ? (void)0                                                          \
  |  |  404|     29|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2791|     29|    assign(uint64_or_128_t<Int>(n));
 2792|     29|  }
_ZN3fmt3v126detail13copy_noinlineIcPcNS0_14basic_appenderIcEEEET1_T0_S7_S6_:
  561|    174|                                              OutputIt out) -> OutputIt {
  562|    174|  return copy<OutChar>(begin, end, out);
  563|    174|}
_ZN3fmt3v126detail13exponent_maskIdEENS1_9dragonbox10float_infoIT_vE12carrier_uintEv:
 1546|  3.91k|    typename dragonbox::float_info<Float>::carrier_uint {
 1547|  3.91k|  using float_uint = typename dragonbox::float_info<Float>::carrier_uint;
 1548|  3.91k|  return ((float_uint(1) << dragonbox::float_info<Float>::exponent_bits) - 1)
 1549|  3.91k|         << num_significand_bits<Float>();
 1550|  3.91k|}
_ZN3fmt3v126detail13exponent_biasIdEEiv:
 1551|  2.62k|template <typename Float> constexpr auto exponent_bias() -> int {
 1552|       |  // std::numeric_limits may not support __float128.
 1553|  2.62k|  return is_float128<Float>() ? 16383
  ------------------
  |  Branch (1553:10): [Folded, False: 2.62k]
  ------------------
 1554|  2.62k|                              : std::numeric_limits<Float>::max_exponent - 1;
 1555|  2.62k|}
_ZN3fmt3v126detail7getsignIcEET_NS0_4signE:
 1048|    681|template <typename Char> constexpr auto getsign(sign s) -> Char {
 1049|    681|  return static_cast<Char>(static_cast<char>(
 1050|    681|      ((' ' << 24) | ('+' << 16) | ('-' << 8)) >> (static_cast<int>(s) * 8)));
 1051|    681|}
_ZN3fmt3v126detail11countl_zeroEj:
  448|    922|FMT_CONSTEXPR20 inline auto countl_zero(uint32_t n) -> int {
  449|    922|#ifdef FMT_BUILTIN_CLZ
  450|    922|  if (!is_constant_evaluated()) return FMT_BUILTIN_CLZ(n);
  ------------------
  |  |  196|    922|#    define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
  ------------------
  |  Branch (450:7): [True: 922, Folded]
  ------------------
  451|      0|#endif
  452|      0|  return countl_zero_fallback(n);
  453|    922|}
_ZN3fmt3v126detail11countl_zeroEm:
  455|    118|FMT_CONSTEXPR20 inline auto countl_zero(uint64_t n) -> int {
  456|    118|#ifdef FMT_BUILTIN_CLZLL
  457|    118|  if (!is_constant_evaluated()) return FMT_BUILTIN_CLZLL(n);
  ------------------
  |  |  199|    118|#    define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
  ------------------
  |  Branch (457:7): [True: 118, Folded]
  ------------------
  458|      0|#endif
  459|      0|  return countl_zero_fallback(n);
  460|    118|}
_ZN3fmt3v126detail7digits2Em:
 1020|  7.88k|inline auto digits2(size_t value) noexcept -> const char* {
 1021|       |  // Align data since unaligned access may be slower when crossing a
 1022|       |  // hardware-specific boundary.
 1023|  7.88k|  alignas(2) static constexpr char data[] =
 1024|  7.88k|      "0001020304050607080910111213141516171819"
 1025|  7.88k|      "2021222324252627282930313233343536373839"
 1026|  7.88k|      "4041424344454647484950515253545556575859"
 1027|  7.88k|      "6061626364656667686970717273747576777879"
 1028|  7.88k|      "8081828384858687888990919293949596979899";
 1029|  7.88k|  return &data[value * 2];
 1030|  7.88k|}
_ZN3fmt3v126detail15do_count_digitsEm:
 1076|  1.91k|inline auto do_count_digits(uint64_t n) -> int {
 1077|       |  // This has comparable performance to the version by Kendall Willets
 1078|       |  // (https://github.com/fmtlib/format-benchmark/blob/master/digits10)
 1079|       |  // but uses smaller tables.
 1080|       |  // Maps bsr(n) to ceil(log10(pow(2, bsr(n) + 1) - 1)).
 1081|  1.91k|  static constexpr uint8_t bsr2log10[] = {
 1082|  1.91k|      1,  1,  1,  2,  2,  2,  3,  3,  3,  4,  4,  4,  4,  5,  5,  5,
 1083|  1.91k|      6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  9,  9,  9,  10, 10, 10,
 1084|  1.91k|      10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15,
 1085|  1.91k|      15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19, 20};
 1086|  1.91k|  auto t = bsr2log10[FMT_BUILTIN_CLZLL(n | 1) ^ 63];
  ------------------
  |  |  199|  1.91k|#    define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
  ------------------
 1087|  1.91k|  static constexpr uint64_t zero_or_powers_of_10[] = {
 1088|  1.91k|      0, 0, FMT_POWERS_OF_10(1U), FMT_POWERS_OF_10(1000000000ULL),
  ------------------
  |  | 1014|  1.91k|  factor * 10, (factor) * 100, (factor) * 1000, (factor) * 10000, \
  |  | 1015|  1.91k|      (factor) * 100000, (factor) * 1000000, (factor) * 10000000, \
  |  | 1016|  1.91k|      (factor) * 100000000, (factor) * 1000000000
  ------------------
                    0, 0, FMT_POWERS_OF_10(1U), FMT_POWERS_OF_10(1000000000ULL),
  ------------------
  |  | 1014|  1.91k|  factor * 10, (factor) * 100, (factor) * 1000, (factor) * 10000, \
  |  | 1015|  1.91k|      (factor) * 100000, (factor) * 1000000, (factor) * 10000000, \
  |  | 1016|  1.91k|      (factor) * 100000000, (factor) * 1000000000
  ------------------
 1089|  1.91k|      10000000000000000000ULL};
 1090|  1.91k|  return t - (n < zero_or_powers_of_10[t]);
 1091|  1.91k|}
_ZN3fmt3v126detail12count_digitsEm:
 1096|  1.91k|FMT_CONSTEXPR20 inline auto count_digits(uint64_t n) -> int {
 1097|  1.91k|#ifdef FMT_BUILTIN_CLZLL
 1098|  1.91k|  if (!is_constant_evaluated() && !FMT_OPTIMIZE_SIZE) return do_count_digits(n);
  ------------------
  |  |  303|      0|#  define FMT_OPTIMIZE_SIZE 0
  ------------------
  |  Branch (1098:7): [True: 0, Folded]
  |  Branch (1098:35): [True: 0, Folded]
  ------------------
 1099|      0|#endif
 1100|      0|  return count_digits_fallback(n);
 1101|  1.91k|}
_ZN3fmt3v126detail6equal2EPKcS3_:
 1202|  1.04k|inline auto equal2(const char* lhs, const char* rhs) -> bool {
 1203|  1.04k|  return memcmp(lhs, rhs, 2) == 0;
 1204|  1.04k|}
_ZN3fmt3v126detail7umul128Emm:
 1414|  1.91k|FMT_INLINE auto umul128(uint64_t x, uint64_t y) noexcept -> uint128 {
 1415|  1.91k|#if FMT_USE_INT128
 1416|  1.91k|  auto p = static_cast<native_uint128>(x) * static_cast<native_uint128>(y);
 1417|  1.91k|  return {static_cast<uint64_t>(p >> 64), static_cast<uint64_t>(p)};
 1418|       |#elif defined(_MSC_VER) && defined(_M_AMD64)
 1419|       |  auto hi = uint64_t();
 1420|       |  auto lo = _umul128(x, y, &hi);
 1421|       |  return {hi, lo};
 1422|       |#else
 1423|       |  const uint64_t mask = static_cast<uint64_t>(max_value<uint32_t>());
 1424|       |
 1425|       |  uint64_t a = x >> 32;
 1426|       |  uint64_t b = x & mask;
 1427|       |  uint64_t c = y >> 32;
 1428|       |  uint64_t d = y & mask;
 1429|       |
 1430|       |  uint64_t ac = a * c;
 1431|       |  uint64_t bc = b * c;
 1432|       |  uint64_t ad = a * d;
 1433|       |  uint64_t bd = b * d;
 1434|       |
 1435|       |  uint64_t intermediate = (bd >> 32) + (ad & mask) + (bc & mask);
 1436|       |
 1437|       |  return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32),
 1438|       |          (intermediate << 32) + (bd & mask)};
 1439|       |#endif
 1440|  1.91k|}
_ZN3fmt3v126detail9dragonbox16floor_log10_pow2Ei:
 1445|  1.76k|inline auto floor_log10_pow2(int e) noexcept -> int {
 1446|  1.76k|  FMT_ASSERT(e <= 2620 && e >= -2620, "too large exponent");
  ------------------
  |  |  402|  3.52k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:7): [True: 1.76k, False: 0]
  |  |  |  Branch (402:7): [True: 1.76k, False: 0]
  |  |  ------------------
  |  |  403|  1.76k|         ? (void)0                                                          \
  |  |  404|  1.76k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1447|  1.76k|  static_assert((-1 >> 1) == -1, "right shift is not arithmetic");
 1448|  1.76k|  return (e * 315653) >> 20;
 1449|  1.76k|}
_ZN3fmt3v126detail9dragonbox16floor_log2_pow10Ei:
 1451|  1.91k|inline auto floor_log2_pow10(int e) noexcept -> int {
 1452|  1.91k|  FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent");
  ------------------
  |  |  402|  3.82k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:7): [True: 1.91k, False: 0]
  |  |  |  Branch (402:7): [True: 1.91k, False: 0]
  |  |  ------------------
  |  |  403|  1.91k|         ? (void)0                                                          \
  |  |  404|  1.91k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1453|  1.91k|  return (e * 1741647) >> 19;
 1454|  1.91k|}
_ZN3fmt3v126detail9dragonbox15umul128_upper64Emm:
 1457|  2.57k|inline auto umul128_upper64(uint64_t x, uint64_t y) noexcept -> uint64_t {
 1458|  2.57k|#if FMT_USE_INT128
 1459|  2.57k|  auto p = static_cast<native_uint128>(x) * static_cast<native_uint128>(y);
 1460|  2.57k|  return static_cast<uint64_t>(p >> 64);
 1461|       |#elif defined(_MSC_VER) && defined(_M_AMD64)
 1462|       |  return __umulh(x, y);
 1463|       |#else
 1464|       |  return umul128(x, y).high();
 1465|       |#endif
 1466|  2.57k|}
_ZN3fmt3v126detail9dragonbox16umul192_upper128EmNS1_7uint128E:
 1470|  1.76k|inline auto umul192_upper128(uint64_t x, uint128 y) noexcept -> uint128 {
 1471|  1.76k|  uint128 r = umul128(x, y.high());
 1472|  1.76k|  r += umul128_upper64(x, y.low());
 1473|  1.76k|  return r;
 1474|  1.76k|}
_ZN3fmt3v126detail16compute_exp_sizeEi:
 1557|    506|FMT_CONSTEXPR inline auto compute_exp_size(int exp) -> int {
 1558|    506|  auto prefix_size = 2;  // sign + 'e'
 1559|    506|  auto abs_exp = exp >= 0 ? exp : -exp;
  ------------------
  |  Branch (1559:18): [True: 155, False: 351]
  ------------------
 1560|    506|  if (abs_exp < 100) return prefix_size + 2;
  ------------------
  |  Branch (1560:7): [True: 147, False: 359]
  ------------------
 1561|    359|  return prefix_size + (abs_exp >= 1000 ? 4 : 3);
  ------------------
  |  Branch (1561:25): [True: 0, False: 359]
  ------------------
 1562|    506|}
_ZN3fmt3v126detail20get_significand_sizeERKNS1_14big_decimal_fpE:
 2399|    957|constexpr auto get_significand_size(const big_decimal_fp& f) -> int {
 2400|    957|  return f.significand_size;
 2401|    957|}
_ZN3fmt3v126detail9use_fixedEii:
 2505|  1.91k|constexpr auto use_fixed(int exp, int exp_upper) -> bool {
 2506|  1.91k|  return exp >= -4 && exp < exp_upper;
  ------------------
  |  Branch (2506:10): [True: 1.21k, False: 702]
  |  Branch (2506:23): [True: 860, False: 352]
  ------------------
 2507|  1.91k|}
_ZN3fmt3v126detail13format_dragonENS1_8basic_fpIoEEjiRNS1_6bufferIcEERi:
 2941|    955|                                          buffer<char>& buf, int& exp10) {
 2942|    955|  bigint numerator;    // 2 * R in (FPP)^2.
 2943|    955|  bigint denominator;  // 2 * S in (FPP)^2.
 2944|       |  // lower and upper are differences between value and corresponding boundaries.
 2945|    955|  bigint lower;             // (M^- in (FPP)^2).
 2946|    955|  bigint upper_store;       // upper's value if different from lower.
 2947|    955|  bigint* upper = nullptr;  // (M^+ in (FPP)^2).
 2948|       |  // Shift numerator and denominator by an extra bit or two (if lower boundary
 2949|       |  // is closer) to make lower and upper integers. This eliminates multiplication
 2950|       |  // by 2 during later computations.
 2951|    955|  bool is_predecessor_closer = (flags & dragon::predecessor_closer) != 0;
 2952|    955|  int shift = is_predecessor_closer ? 2 : 1;
  ------------------
  |  Branch (2952:15): [True: 145, False: 810]
  ------------------
 2953|    955|  if (value.e >= 0) {
  ------------------
  |  Branch (2953:7): [True: 209, False: 746]
  ------------------
 2954|    209|    numerator = value.f;
 2955|    209|    numerator <<= value.e + shift;
 2956|    209|    lower = 1;
 2957|    209|    lower <<= value.e;
 2958|    209|    if (is_predecessor_closer) {
  ------------------
  |  Branch (2958:9): [True: 47, False: 162]
  ------------------
 2959|     47|      upper_store = 1;
 2960|     47|      upper_store <<= value.e + 1;
 2961|     47|      upper = &upper_store;
 2962|     47|    }
 2963|    209|    denominator.assign_pow10(exp10);
 2964|    209|    denominator <<= shift;
 2965|    746|  } else if (exp10 < 0) {
  ------------------
  |  Branch (2965:14): [True: 426, False: 320]
  ------------------
 2966|    426|    numerator.assign_pow10(-exp10);
 2967|    426|    lower.assign(numerator);
 2968|    426|    if (is_predecessor_closer) {
  ------------------
  |  Branch (2968:9): [True: 69, False: 357]
  ------------------
 2969|     69|      upper_store.assign(numerator);
 2970|     69|      upper_store <<= 1;
 2971|     69|      upper = &upper_store;
 2972|     69|    }
 2973|    426|    numerator *= value.f;
 2974|    426|    numerator <<= shift;
 2975|    426|    denominator = 1;
 2976|    426|    denominator <<= shift - value.e;
 2977|    426|  } else {
 2978|    320|    numerator = value.f;
 2979|    320|    numerator <<= shift;
 2980|    320|    denominator.assign_pow10(exp10);
 2981|    320|    denominator <<= shift - value.e;
 2982|    320|    lower = 1;
 2983|    320|    if (is_predecessor_closer) {
  ------------------
  |  Branch (2983:9): [True: 29, False: 291]
  ------------------
 2984|     29|      upper_store = 1ULL << 1;
 2985|     29|      upper = &upper_store;
 2986|     29|    }
 2987|    320|  }
 2988|    955|  int even = static_cast<int>((value.f & 1) == 0);
 2989|    955|  if (!upper) upper = &lower;
  ------------------
  |  Branch (2989:7): [True: 810, False: 145]
  ------------------
 2990|    955|  bool shortest = num_digits < 0;
 2991|    955|  if ((flags & dragon::fixup) != 0) {
  ------------------
  |  Branch (2991:7): [True: 0, False: 955]
  ------------------
 2992|      0|    if (add_compare(numerator, *upper, denominator) + even <= 0) {
  ------------------
  |  Branch (2992:9): [True: 0, False: 0]
  ------------------
 2993|      0|      --exp10;
 2994|      0|      numerator *= 10;
 2995|      0|      if (num_digits < 0) {
  ------------------
  |  Branch (2995:11): [True: 0, False: 0]
  ------------------
 2996|      0|        lower *= 10;
 2997|      0|        if (upper != &lower) *upper *= 10;
  ------------------
  |  Branch (2997:13): [True: 0, False: 0]
  ------------------
 2998|      0|      }
 2999|      0|    }
 3000|      0|    if ((flags & dragon::fixed) != 0) adjust_precision(num_digits, exp10 + 1);
  ------------------
  |  Branch (3000:9): [True: 0, False: 0]
  ------------------
 3001|      0|  }
 3002|       |  // Invariant: value == (numerator / denominator) * pow(10, exp10).
 3003|    955|  if (shortest) {
  ------------------
  |  Branch (3003:7): [True: 0, False: 955]
  ------------------
 3004|       |    // Generate the shortest representation.
 3005|      0|    num_digits = 0;
 3006|      0|    char* data = buf.data();
 3007|      0|    for (;;) {
 3008|      0|      int digit = numerator.divmod_assign(denominator);
 3009|      0|      bool low = compare(numerator, lower) - even < 0;  // numerator <[=] lower.
 3010|       |      // numerator + upper >[=] pow10:
 3011|      0|      bool high = add_compare(numerator, *upper, denominator) + even > 0;
 3012|      0|      data[num_digits++] = static_cast<char>('0' + digit);
 3013|      0|      if (low || high) {
  ------------------
  |  Branch (3013:11): [True: 0, False: 0]
  |  Branch (3013:18): [True: 0, False: 0]
  ------------------
 3014|      0|        if (!low) {
  ------------------
  |  Branch (3014:13): [True: 0, False: 0]
  ------------------
 3015|      0|          ++data[num_digits - 1];
 3016|      0|        } else if (high) {
  ------------------
  |  Branch (3016:20): [True: 0, False: 0]
  ------------------
 3017|      0|          int result = add_compare(numerator, numerator, denominator);
 3018|       |          // Round half to even.
 3019|      0|          if (result > 0 || (result == 0 && (digit % 2) != 0))
  ------------------
  |  Branch (3019:15): [True: 0, False: 0]
  |  Branch (3019:30): [True: 0, False: 0]
  |  Branch (3019:45): [True: 0, False: 0]
  ------------------
 3020|      0|            ++data[num_digits - 1];
 3021|      0|        }
 3022|      0|        buf.try_resize(to_unsigned(num_digits));
 3023|      0|        exp10 -= num_digits - 1;
 3024|      0|        return;
 3025|      0|      }
 3026|      0|      numerator *= 10;
 3027|      0|      lower *= 10;
 3028|      0|      if (upper != &lower) *upper *= 10;
  ------------------
  |  Branch (3028:11): [True: 0, False: 0]
  ------------------
 3029|      0|    }
 3030|      0|  }
 3031|       |  // Generate the given number of digits.
 3032|    955|  exp10 -= num_digits - 1;
 3033|    955|  if (num_digits <= 0) {
  ------------------
  |  Branch (3033:7): [True: 0, False: 955]
  ------------------
 3034|      0|    auto digit = '0';
 3035|      0|    if (num_digits == 0) {
  ------------------
  |  Branch (3035:9): [True: 0, False: 0]
  ------------------
 3036|      0|      denominator *= 10;
 3037|      0|      digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0';
  ------------------
  |  Branch (3037:15): [True: 0, False: 0]
  ------------------
 3038|      0|    }
 3039|      0|    buf.push_back(digit);
 3040|      0|    return;
 3041|      0|  }
 3042|    955|  buf.try_resize(to_unsigned(num_digits));
 3043|  47.7k|  for (int i = 0; i < num_digits - 1; ++i) {
  ------------------
  |  Branch (3043:19): [True: 46.7k, False: 955]
  ------------------
 3044|  46.7k|    int digit = numerator.divmod_assign(denominator);
 3045|  46.7k|    buf[i] = static_cast<char>('0' + digit);
 3046|  46.7k|    numerator *= 10;
 3047|  46.7k|  }
 3048|    955|  int digit = numerator.divmod_assign(denominator);
 3049|    955|  auto result = add_compare(numerator, numerator, denominator);
 3050|    955|  if (result > 0 || (result == 0 && (digit % 2) != 0)) {
  ------------------
  |  Branch (3050:7): [True: 271, False: 684]
  |  Branch (3050:22): [True: 9, False: 675]
  |  Branch (3050:37): [True: 3, False: 6]
  ------------------
 3051|    274|    if (digit == 9) {
  ------------------
  |  Branch (3051:9): [True: 35, False: 239]
  ------------------
 3052|     35|      const auto overflow = '0' + 10;
 3053|     35|      buf[num_digits - 1] = overflow;
 3054|       |      // Propagate the carry.
 3055|    100|      for (int i = num_digits - 1; i > 0 && buf[i] == overflow; --i) {
  ------------------
  |  Branch (3055:36): [True: 100, False: 0]
  |  Branch (3055:45): [True: 65, False: 35]
  ------------------
 3056|     65|        buf[i] = '0';
 3057|     65|        ++buf[i - 1];
 3058|     65|      }
 3059|     35|      if (buf[0] == overflow) {
  ------------------
  |  Branch (3059:11): [True: 0, False: 35]
  ------------------
 3060|      0|        buf[0] = '1';
 3061|      0|        if ((flags & dragon::fixed) != 0)
  ------------------
  |  Branch (3061:13): [True: 0, False: 0]
  ------------------
 3062|      0|          buf.push_back('0');
 3063|      0|        else
 3064|      0|          ++exp10;
 3065|      0|      }
 3066|     35|      return;
 3067|     35|    }
 3068|    239|    ++digit;
 3069|    239|  }
 3070|    920|  buf[num_digits - 1] = static_cast<char>('0' + digit);
 3071|    920|}
_ZN3fmt3v1219basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEE10deallocateEv:
  789|  8.05k|  FMT_CONSTEXPR20 void deallocate() {
  790|  8.05k|    T* data = this->data();
  791|  8.05k|    if (data != store_) alloc_.deallocate(data, this->capacity());
  ------------------
  |  Branch (791:9): [True: 0, False: 8.05k]
  ------------------
  792|  8.05k|  }
_ZN3fmt3v1219basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEE4moveERS5_:
  853|  4.23k|  FMT_CONSTEXPR20 void move(basic_memory_buffer& other) {
  854|  4.23k|    T* data = other.data();
  855|  4.23k|    size_t size = other.size(), capacity = other.capacity();
  856|  4.23k|    if (!move_alloc(other)) return;
  ------------------
  |  Branch (856:9): [True: 0, False: 4.23k]
  ------------------
  857|  4.23k|    if (data == other.store_) {
  ------------------
  |  Branch (857:9): [True: 4.23k, False: 0]
  ------------------
  858|  4.23k|      this->set(store_, capacity);
  859|  4.23k|      detail::copy<T>(other.store_, other.store_ + size, store_);
  860|  4.23k|    } else {
  861|      0|      this->set(data, capacity);
  862|       |      // Set pointer to the inline array so that delete is not called
  863|       |      // when deallocating.
  864|      0|      other.set(other.store_, 0);
  865|      0|      other.clear();
  866|      0|    }
  867|  4.23k|    this->resize(size);
  868|  4.23k|  }
_ZN3fmt3v126detaileqENS1_9allocatorIjEES3_:
  742|  4.23k|  constexpr friend auto operator==(allocator, allocator) noexcept -> bool {
  743|  4.23k|    return true;  // All instances of this allocator are equivalent.
  744|  4.23k|  }
_ZN3fmt3v1219basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEE10move_allocIS4_TnNSt3__19enable_ifIXntsr3std16allocator_traitsIT_E38propagate_on_container_move_assignmentE5valueEiE4typeELi0EEEbRS5_:
  842|  4.23k|  FMT_CONSTEXPR20 auto move_alloc(basic_memory_buffer& other) -> bool {
  843|  4.23k|    T* data = other.data();
  844|  4.23k|    if (alloc_ == other.alloc_ || data == other.store_) return true;
  ------------------
  |  Branch (844:9): [True: 4.23k, False: 0]
  |  Branch (844:35): [True: 0, False: 0]
  ------------------
  845|      0|    size_t size = other.size();
  846|       |    // Perform copy operation, allocators are different.
  847|      0|    this->resize(size);
  848|      0|    detail::copy<T>(data, data + size, this->data());
  849|      0|    return false;
  850|  4.23k|  }
_ZN3fmt3v126detail10to_pointerIcEEPT_NS0_14basic_appenderIS3_EEm:
  514|    783|FMT_CONSTEXPR20 auto to_pointer(basic_appender<T> it, size_t n) -> T* {
  515|    783|  buffer<T>& buf = get_container(it);
  516|    783|  buf.try_reserve(buf.size() + n);
  517|    783|  auto size = buf.size();
  518|    783|  if (buf.capacity() < size + n) return nullptr;
  ------------------
  |  Branch (518:7): [True: 0, False: 783]
  ------------------
  519|    783|  buf.try_resize(size + n);
  520|    783|  return buf.data() + size;
  521|    783|}
_ZN3fmt3v126detail12write2digitsIcEEvPT_m:
 1208|  7.01k|FMT_CONSTEXPR20 FMT_INLINE void write2digits(Char* out, size_t value) {
 1209|  7.01k|  if (!is_constant_evaluated() && std::is_same<Char, char>::value &&
  ------------------
  |  Branch (1209:7): [True: 0, Folded]
  |  Branch (1209:35): [True: 0, Folded]
  ------------------
 1210|  7.01k|      !FMT_OPTIMIZE_SIZE) {
  ------------------
  |  |  303|      0|#  define FMT_OPTIMIZE_SIZE 0
  ------------------
  |  Branch (1210:7): [True: 0, Folded]
  ------------------
 1211|  7.01k|    memcpy(out, digits2(value), 2);
 1212|  7.01k|    return;
 1213|  7.01k|  }
 1214|      0|  *out++ = static_cast<Char>('0' + value / 10);
 1215|      0|  *out = static_cast<Char>('0' + value % 10);
 1216|      0|}
_ZN3fmt3v126detail17do_format_decimalIcmEEPT_S4_T0_i:
 1232|    953|    -> Char* {
 1233|    953|  FMT_ASSERT(size >= count_digits(value), "invalid digit count");
  ------------------
  |  |  402|    953|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 953, False: 0]
  |  |  ------------------
  |  |  403|    953|         ? (void)0                                                          \
  |  |  404|    953|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1234|    953|  unsigned n = to_unsigned(size);
 1235|  6.36k|  while (value >= 100) {
  ------------------
  |  Branch (1235:10): [True: 5.40k, False: 953]
  ------------------
 1236|  5.40k|    n -= 2;
 1237|  5.40k|    if (!is_constant_evaluated() && num_bits<UInt>() == 32) {
  ------------------
  |  Branch (1237:9): [True: 0, Folded]
  |  Branch (1237:37): [Folded, False: 0]
  ------------------
 1238|      0|      auto p = value * static_cast<uint64_t>((1ull << 39) / 100 + 1);
 1239|      0|      write2digits_i(out + n, p >> (39 - 7) & ((1 << 7) - 1));
 1240|      0|      value = static_cast<UInt>(p >> 39) +
 1241|      0|              (static_cast<UInt>(value >= (100u << 25)) << 25);
 1242|  5.40k|    } else {
 1243|       |      // Integer division is slow so do it for a group of two digits instead
 1244|       |      // of for every digit. The idea comes from the talk by Alexandrescu
 1245|       |      // "Three Optimization Tips for C++". See speed-test for a comparison.
 1246|  5.40k|      write2digits(out + n, static_cast<unsigned>(value % 100));
 1247|  5.40k|      value /= 100;
 1248|  5.40k|    }
 1249|  5.40k|  }
 1250|    953|  if (value >= 10) {
  ------------------
  |  Branch (1250:7): [True: 522, False: 431]
  ------------------
 1251|    522|    n -= 2;
 1252|    522|    write2digits(out + n, static_cast<unsigned>(value));
 1253|    522|  } else {
 1254|    431|    out[--n] = static_cast<Char>('0' + value);
 1255|    431|  }
 1256|    953|  return out + n;
 1257|    953|}
_ZN3fmt3v126detail14format_decimalIcmEEPT_S4_T0_i:
 1261|    718|                                             int num_digits) -> Char* {
 1262|    718|  do_format_decimal(out, value, num_digits);
 1263|    718|  return out + num_digits;
 1264|    718|}
_ZN3fmt3v126detail14format_decimalIcmNS0_14basic_appenderIcEETnNSt3__19enable_ifIXntsr3std10is_pointerINS5_9remove_cvINS5_16remove_referenceIT1_E4typeEE4typeEEE5valueEiE4typeELi0EEES9_S9_T0_i:
 1269|    235|    -> OutputIt {
 1270|    235|  if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
  ------------------
  |  Branch (1270:12): [True: 235, False: 0]
  ------------------
 1271|    235|    do_format_decimal(ptr, value, num_digits);
 1272|    235|    return out;
 1273|    235|  }
 1274|       |  // Buffer is large enough to hold all digits (digits10 + 1).
 1275|      0|  char buffer[digits10<UInt>() + 1];
 1276|      0|  if (is_constant_evaluated()) fill_n(buffer, sizeof(buffer), '\0');
  ------------------
  |  Branch (1276:7): [Folded, False: 0]
  ------------------
 1277|      0|  do_format_decimal(buffer, value, num_digits);
 1278|      0|  return copy_noinline<Char>(buffer, buffer + num_digits, out);
 1279|    235|}
_ZN3fmt3v126detail7reserveIcEENS0_14basic_appenderIT_EES5_m:
  489|  1.54k|    -> basic_appender<T> {
  490|  1.54k|  buffer<T>& buf = get_container(it);
  491|  1.54k|  buf.try_reserve(buf.size() + n);
  492|  1.54k|  return it;
  493|  1.54k|}
_ZN3fmt3v126detail13base_iteratorINS0_14basic_appenderIcEEEET_S5_S5_:
  533|  1.54k|constexpr auto base_iterator(Iterator, Iterator it) -> Iterator {
  534|  1.54k|  return it;
  535|  1.54k|}
_ZN3fmt3v126detail15write_nonfiniteIcNS0_14basic_appenderIcEEEET0_S5_bNS0_12format_specsENS0_4signE:
 2375|    178|                                     format_specs specs, sign s) -> OutputIt {
 2376|    178|  auto str =
 2377|    178|      isnan ? (specs.upper() ? "NAN" : "nan") : (specs.upper() ? "INF" : "inf");
  ------------------
  |  Branch (2377:7): [True: 174, False: 4]
  |  Branch (2377:16): [True: 0, False: 174]
  |  Branch (2377:50): [True: 0, False: 4]
  ------------------
 2378|    178|  constexpr size_t str_size = 3;
 2379|    178|  auto size = str_size + (s != sign::none ? 1 : 0);
  ------------------
  |  Branch (2379:27): [True: 170, False: 8]
  ------------------
 2380|       |  // Replace '0'-padding with space for non-finite values.
 2381|    178|  const bool is_zero_fill =
 2382|    178|      specs.fill_size() == 1 && specs.fill_unit<Char>() == '0';
  ------------------
  |  Branch (2382:7): [True: 178, False: 0]
  |  Branch (2382:33): [True: 0, False: 178]
  ------------------
 2383|    178|  if (is_zero_fill) specs.set_fill(' ');
  ------------------
  |  Branch (2383:7): [True: 0, False: 178]
  ------------------
 2384|    178|  return write_padded<Char>(out, specs, size,
 2385|    178|                            [=](reserve_iterator<OutputIt> it) {
 2386|    178|                              if (s != sign::none)
 2387|    178|                                *it++ = detail::getsign<Char>(s);
 2388|    178|                              return copy<Char>(str, str + str_size, it);
 2389|    178|                            });
 2390|    178|}
_ZN3fmt3v126detail12write_paddedIcLNS0_5alignE1ENS0_14basic_appenderIcEEZNS1_15write_nonfiniteIcS5_EET0_S7_bNS0_12format_specsENS0_4signEEUlS5_E_EET1_SB_RKS8_mOT2_:
 1736|    178|                            size_t size, F&& f) -> OutputIt {
 1737|    178|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1738|    178|}
_ZN3fmt3v126detail12write_paddedIcLNS0_5alignE1ENS0_14basic_appenderIcEERZNS1_15write_nonfiniteIcS5_EET0_S7_bNS0_12format_specsENS0_4signEEUlS5_E_EET1_SC_RKS8_mmOT2_:
 1715|    178|                                size_t size, size_t width, F&& f) -> OutputIt {
 1716|    178|  static_assert(default_align == align::left || default_align == align::right,
 1717|    178|                "");
 1718|    178|  unsigned spec_width = to_unsigned(specs.width);
 1719|    178|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1719:20): [True: 0, False: 178]
  ------------------
 1720|       |  // Shifts are encoded as string literals because static constexpr is not
 1721|       |  // supported in constexpr functions.
 1722|    178|  auto* shifts =
 1723|    178|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1723:7): [True: 178, Folded]
  ------------------
 1724|    178|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1725|    178|  size_t right_padding = padding - left_padding;
 1726|    178|  auto it = reserve(out, size + padding * specs.fill_size());
 1727|    178|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1727:7): [True: 0, False: 178]
  ------------------
 1728|    178|  it = f(it);
 1729|    178|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1729:7): [True: 0, False: 178]
  ------------------
 1730|    178|  return base_iterator(out, it);
 1731|    178|}
_ZZN3fmt3v126detail15write_nonfiniteIcNS0_14basic_appenderIcEEEET0_S5_bNS0_12format_specsENS0_4signEENKUlS4_E_clES4_:
 2385|    178|                            [=](reserve_iterator<OutputIt> it) {
 2386|    178|                              if (s != sign::none)
  ------------------
  |  Branch (2386:35): [True: 170, False: 8]
  ------------------
 2387|    170|                                *it++ = detail::getsign<Char>(s);
 2388|    178|                              return copy<Char>(str, str + str_size, it);
 2389|    178|                            });
_ZN3fmt3v126detail23fallback_digit_groupingIcEC2ENS0_10locale_refEb:
 2511|    334|  constexpr fallback_digit_grouping(locale_ref, bool) {}
_ZNK3fmt3v126detail23fallback_digit_groupingIcE16count_separatorsEi:
 2515|    334|  constexpr auto count_separators(int) const -> int { return 0; }
_ZNK3fmt3v126detail23fallback_digit_groupingIcE13has_separatorEv:
 2513|    334|  constexpr auto has_separator() const -> bool { return false; }
_ZN3fmt3v126detail6selectILb0EPcNS0_14basic_appenderIcEETnNSt3__19enable_ifIXntT_EiE4typeELi0EEET1_T0_SA_:
 1694|    548|auto select(T, F false_value) -> F {
 1695|    548|  return false_value;
 1696|    548|}
_ZN3fmt3v126detail14write_exponentIcNS0_14basic_appenderIcEEEET0_iS5_:
 1566|    506|FMT_CONSTEXPR auto write_exponent(int exp, OutputIt out) -> OutputIt {
 1567|    506|  FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range");
  ------------------
  |  |  402|  1.01k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:7): [True: 506, False: 0]
  |  |  |  Branch (402:7): [True: 506, False: 0]
  |  |  ------------------
  |  |  403|    506|         ? (void)0                                                          \
  |  |  404|    506|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1568|    506|  if (exp < 0) {
  ------------------
  |  Branch (1568:7): [True: 351, False: 155]
  ------------------
 1569|    351|    *out++ = static_cast<Char>('-');
 1570|    351|    exp = -exp;
 1571|    351|  } else {
 1572|    155|    *out++ = static_cast<Char>('+');
 1573|    155|  }
 1574|    506|  auto uexp = static_cast<uint32_t>(exp);
 1575|    506|  if (is_constant_evaluated()) {
  ------------------
  |  Branch (1575:7): [Folded, False: 506]
  ------------------
 1576|      0|    if (uexp < 10) *out++ = '0';
  ------------------
  |  Branch (1576:9): [True: 0, False: 0]
  ------------------
 1577|      0|    return format_decimal<Char>(out, uexp, count_digits(uexp));
 1578|      0|  }
 1579|    506|  if (uexp >= 100u) {
  ------------------
  |  Branch (1579:7): [True: 359, False: 147]
  ------------------
 1580|    359|    const char* top = digits2(uexp / 100);
 1581|    359|    if (uexp >= 1000u) *out++ = static_cast<Char>(top[0]);
  ------------------
  |  Branch (1581:9): [True: 0, False: 359]
  ------------------
 1582|    359|    *out++ = static_cast<Char>(top[1]);
 1583|    359|    uexp %= 100;
 1584|    359|  }
 1585|    506|  const char* d = digits2(uexp);
 1586|    506|  *out++ = static_cast<Char>(d[0]);
 1587|    506|  *out++ = static_cast<Char>(d[1]);
 1588|    506|  return out;
 1589|    506|}
_ZN3fmt3v126detail21default_arg_formatterIcEclIdTnNSt3__19enable_ifIXsr10is_builtinIT_EE5valueEiE4typeELi0EEEvS7_:
 3687|  1.04k|  void operator()(T value) {
 3688|  1.04k|    write<Char>(out, value);
 3689|  1.04k|  }
_ZN3fmt3v126detail5writeIcNS0_14basic_appenderIcEEdTnNSt3__19enable_ifIXsr13is_fast_floatIT1_EE5valueEiE4typeELi0EEET0_SA_S7_:
 3530|  1.04k|FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt {
 3531|  1.04k|  if (is_constant_evaluated()) return write<Char>(out, value, format_specs());
  ------------------
  |  Branch (3531:7): [Folded, False: 1.04k]
  ------------------
 3532|       |
 3533|  1.04k|  auto s = detail::signbit(value) ? sign::minus : sign::none;
  ------------------
  |  Branch (3533:12): [True: 441, False: 605]
  ------------------
 3534|  1.04k|  auto mask = exponent_mask<fast_float_t<T>>();
 3535|  1.04k|  if ((bit_cast<decltype(mask)>(value) & mask) == mask)
  ------------------
  |  Branch (3535:7): [True: 89, False: 957]
  ------------------
 3536|     89|    return write_nonfinite<Char>(out, std::isnan(value), {}, s);
 3537|       |
 3538|    957|  auto dec = dragonbox::to_decimal(static_cast<fast_float_t<T>>(value));
 3539|    957|  auto significand = dec.significand;
 3540|    957|  int significand_size = count_digits(significand);
 3541|    957|  int exponent = dec.exponent + significand_size - 1;
 3542|    957|  if (use_fixed(exponent, detail::exp_upper<T>())) {
  ------------------
  |  Branch (3542:7): [True: 409, False: 548]
  ------------------
 3543|    409|    return write_fixed<Char, fallback_digit_grouping<Char>>(
 3544|    409|        out, dec, significand_size, Char('.'), {}, s);
 3545|    409|  }
 3546|       |
 3547|       |  // Write value in the exponential format.
 3548|    548|  const char* prefix = "e+";
 3549|    548|  int abs_exponent = exponent;
 3550|    548|  if (exponent < 0) {
  ------------------
  |  Branch (3550:7): [True: 351, False: 197]
  ------------------
 3551|    351|    abs_exponent = -exponent;
 3552|    351|    prefix = "e-";
 3553|    351|  }
 3554|    548|  auto has_decimal_point = significand_size != 1;
 3555|    548|  size_t size = std::is_pointer<OutputIt>::value
  ------------------
  |  Branch (3555:17): [Folded, False: 548]
  ------------------
 3556|    548|                    ? 0u
 3557|    548|                    : to_unsigned((s != sign::none ? 1 : 0) + significand_size +
  ------------------
  |  Branch (3557:36): [True: 201, False: 347]
  ------------------
 3558|    548|                                  (has_decimal_point ? 1 : 0) +
  ------------------
  |  Branch (3558:36): [True: 544, False: 4]
  ------------------
 3559|    548|                                  (abs_exponent >= 100 ? 5 : 4));
  ------------------
  |  Branch (3559:36): [True: 359, False: 189]
  ------------------
 3560|    548|  if (auto ptr = to_pointer<Char>(out, size)) {
  ------------------
  |  Branch (3560:12): [True: 548, False: 0]
  ------------------
 3561|    548|    if (s != sign::none) *ptr++ = Char('-');
  ------------------
  |  Branch (3561:9): [True: 201, False: 347]
  ------------------
 3562|    548|    if (has_decimal_point) {
  ------------------
  |  Branch (3562:9): [True: 544, False: 4]
  ------------------
 3563|    544|      auto begin = ptr;
 3564|    544|      ptr = format_decimal<Char>(ptr, significand, significand_size + 1);
 3565|    544|      *begin = begin[1];
 3566|    544|      begin[1] = '.';
 3567|    544|    } else {
 3568|      4|      *ptr++ = static_cast<Char>('0' + significand);
 3569|      4|    }
 3570|    548|    if (std::is_same<Char, char>::value) {
  ------------------
  |  Branch (3570:9): [True: 548, Folded]
  ------------------
 3571|    548|      memcpy(ptr, prefix, 2);
 3572|    548|      ptr += 2;
 3573|    548|    } else {
 3574|      0|      *ptr++ = static_cast<Char>(prefix[0]);
 3575|      0|      *ptr++ = static_cast<Char>(prefix[1]);
 3576|      0|    }
 3577|    548|    if (abs_exponent >= 100) {
  ------------------
  |  Branch (3577:9): [True: 359, False: 189]
  ------------------
 3578|    359|      *ptr++ = static_cast<Char>('0' + abs_exponent / 100);
 3579|    359|      abs_exponent %= 100;
 3580|    359|    }
 3581|    548|    write2digits(ptr, static_cast<unsigned>(abs_exponent));
 3582|    548|    return select<std::is_pointer<OutputIt>::value>(ptr + 2, out);
 3583|    548|  }
 3584|      0|  auto it = reserve(out, size);
 3585|      0|  if (s != sign::none) *it++ = Char('-');
  ------------------
  |  Branch (3585:7): [True: 0, False: 0]
  ------------------
 3586|       |  // Insert a decimal point after the first digit and add an exponent.
 3587|      0|  it = write_significand(it, significand, significand_size, 1,
 3588|      0|                         has_decimal_point ? Char('.') : Char());
  ------------------
  |  Branch (3588:26): [True: 0, False: 0]
  ------------------
 3589|      0|  *it++ = Char('e');
 3590|      0|  it = write_exponent<Char>(exponent, it);
 3591|      0|  return base_iterator(out, it);
 3592|    548|}
_ZN3fmt3v126detail7signbitIdTnNSt3__19enable_ifIXsr17is_floating_pointIT_EE5valueEiE4typeELi0EEEbS5_:
 2669|  2.09k|FMT_INLINE FMT_CONSTEXPR auto signbit(T value) -> bool {
 2670|  2.09k|  if (is_constant_evaluated()) {
  ------------------
  |  Branch (2670:7): [Folded, False: 2.09k]
  ------------------
 2671|       |#ifdef __cpp_if_constexpr
 2672|       |    if constexpr (std::numeric_limits<double>::is_iec559) {
 2673|       |      auto bits = detail::bit_cast<uint64_t>(static_cast<double>(value));
 2674|       |      return (bits >> (num_bits<uint64_t>() - 1)) != 0;
 2675|       |    }
 2676|       |#endif
 2677|      0|  }
 2678|  2.09k|  return std::signbit(static_cast<double>(value));
 2679|  2.09k|}
_ZN3fmt3v126detail9exp_upperIdEEiv:
 2497|  1.91k|template <typename T> FMT_CONSTEVAL auto exp_upper() -> int {
 2498|  1.91k|  return std::numeric_limits<T>::digits10 != 0
  ------------------
  |  Branch (2498:10): [True: 1.91k, Folded]
  ------------------
 2499|  1.91k|             ? min_of(16, std::numeric_limits<T>::digits10 + 1)
 2500|  1.91k|             : 16;
 2501|  1.91k|}
_ZN3fmt3v126detail11write_fixedIcNS1_23fallback_digit_groupingIcEENS0_14basic_appenderIcEENS1_9dragonbox10decimal_fpIdEEEET1_SA_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refE:
 2528|    409|                                 locale_ref loc = {}) -> OutputIt {
 2529|    409|  using iterator = reserve_iterator<OutputIt>;
 2530|       |
 2531|    409|  int exp = f.exponent + significand_size;
 2532|    409|  long long size = significand_size + (s != sign::none ? 1 : 0);
  ------------------
  |  Branch (2532:40): [True: 155, False: 254]
  ------------------
 2533|    409|  if (f.exponent >= 0) {
  ------------------
  |  Branch (2533:7): [True: 160, False: 249]
  ------------------
 2534|       |    // 1234e5 -> 123400000[.0+]
 2535|    160|    size += f.exponent;
 2536|    160|    int num_zeros = specs.precision - exp;
 2537|    160|    abort_fuzzing_if(num_zeros > 5000);
 2538|    160|    if (specs.alt()) {
  ------------------
  |  Branch (2538:9): [True: 0, False: 160]
  ------------------
 2539|      0|      ++size;
 2540|      0|      if (num_zeros <= 0 && specs.type() != presentation_type::fixed)
  ------------------
  |  Branch (2540:11): [True: 0, False: 0]
  |  Branch (2540:29): [True: 0, False: 0]
  ------------------
 2541|      0|        num_zeros = 0;
 2542|      0|      if (num_zeros > 0) size += num_zeros;
  ------------------
  |  Branch (2542:11): [True: 0, False: 0]
  ------------------
 2543|      0|    }
 2544|    160|    auto grouping = Grouping(loc, specs.localized());
 2545|    160|    size += grouping.count_separators(exp);
 2546|    160|    return write_padded<Char, align::right>(
 2547|    160|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2548|    160|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2549|    160|          it = write_significand<Char>(it, f.significand, significand_size,
 2550|    160|                                       f.exponent, grouping);
 2551|    160|          if (!specs.alt()) return it;
 2552|    160|          *it++ = decimal_point;
 2553|    160|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
 2554|    160|        });
 2555|    160|  }
 2556|    249|  if (exp > 0) {
  ------------------
  |  Branch (2556:7): [True: 174, False: 75]
  ------------------
 2557|       |    // 1234e-2 -> 12.34[0+]
 2558|    174|    int num_zeros = specs.alt() ? specs.precision - significand_size : 0;
  ------------------
  |  Branch (2558:21): [True: 0, False: 174]
  ------------------
 2559|    174|    size += 1 + max_of(num_zeros, 0);
 2560|    174|    auto grouping = Grouping(loc, specs.localized());
 2561|    174|    size += grouping.count_separators(exp);
 2562|    174|    return write_padded<Char, align::right>(
 2563|    174|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2564|    174|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2565|    174|          it = write_significand(it, f.significand, significand_size, exp,
 2566|    174|                                 decimal_point, grouping);
 2567|    174|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
 2568|    174|        });
 2569|    174|  }
 2570|       |  // 1234e-6 -> 0.001234
 2571|     75|  int num_zeros = -exp;
 2572|     75|  if (significand_size == 0 && specs.precision >= 0 &&
  ------------------
  |  Branch (2572:7): [True: 0, False: 75]
  |  Branch (2572:32): [True: 0, False: 0]
  ------------------
 2573|      0|      specs.precision < num_zeros) {
  ------------------
  |  Branch (2573:7): [True: 0, False: 0]
  ------------------
 2574|      0|    num_zeros = specs.precision;
 2575|      0|  }
 2576|     75|  bool pointy = num_zeros != 0 || significand_size != 0 || specs.alt();
  ------------------
  |  Branch (2576:17): [True: 38, False: 37]
  |  Branch (2576:35): [True: 37, False: 0]
  |  Branch (2576:60): [True: 0, False: 0]
  ------------------
 2577|     75|  size += 1 + (pointy ? 1 : 0) + num_zeros;
  ------------------
  |  Branch (2577:16): [True: 75, False: 0]
  ------------------
 2578|     75|  return write_padded<Char, align::right>(
 2579|     75|      out, specs, static_cast<size_t>(size), [&](iterator it) {
 2580|     75|        if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2581|     75|        *it++ = Char('0');
 2582|     75|        if (!pointy) return it;
 2583|     75|        *it++ = decimal_point;
 2584|     75|        it = detail::fill_n(it, num_zeros, Char('0'));
 2585|     75|        return write_significand<Char>(it, f.significand, significand_size);
 2586|     75|      });
 2587|    249|}
_ZN3fmt3v126detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEEZNS1_11write_fixedIcNS1_23fallback_digit_groupingIcEES5_NS1_9dragonbox10decimal_fpIdEEEET1_SC_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEEUlS5_E_EESC_SC_SJ_mOSD_:
 1736|    160|                            size_t size, F&& f) -> OutputIt {
 1737|    160|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1738|    160|}
_ZN3fmt3v126detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEERZNS1_11write_fixedIcNS1_23fallback_digit_groupingIcEES5_NS1_9dragonbox10decimal_fpIdEEEET1_SC_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEEUlS5_E_EESC_SC_SJ_mmOSD_:
 1715|    160|                                size_t size, size_t width, F&& f) -> OutputIt {
 1716|    160|  static_assert(default_align == align::left || default_align == align::right,
 1717|    160|                "");
 1718|    160|  unsigned spec_width = to_unsigned(specs.width);
 1719|    160|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1719:20): [True: 0, False: 160]
  ------------------
 1720|       |  // Shifts are encoded as string literals because static constexpr is not
 1721|       |  // supported in constexpr functions.
 1722|    160|  auto* shifts =
 1723|    160|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1723:7): [Folded, False: 160]
  ------------------
 1724|    160|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1725|    160|  size_t right_padding = padding - left_padding;
 1726|    160|  auto it = reserve(out, size + padding * specs.fill_size());
 1727|    160|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1727:7): [True: 0, False: 160]
  ------------------
 1728|    160|  it = f(it);
 1729|    160|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1729:7): [True: 0, False: 160]
  ------------------
 1730|    160|  return base_iterator(out, it);
 1731|    160|}
_ZZN3fmt3v126detail11write_fixedIcNS1_23fallback_digit_groupingIcEENS0_14basic_appenderIcEENS1_9dragonbox10decimal_fpIdEEEET1_SA_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEENKUlS6_E_clES6_:
 2547|    160|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2548|    160|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2548:15): [True: 57, False: 103]
  ------------------
 2549|    160|          it = write_significand<Char>(it, f.significand, significand_size,
 2550|    160|                                       f.exponent, grouping);
 2551|    160|          if (!specs.alt()) return it;
  ------------------
  |  Branch (2551:15): [True: 160, False: 0]
  ------------------
 2552|      0|          *it++ = decimal_point;
 2553|      0|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
  ------------------
  |  Branch (2553:18): [True: 0, False: 0]
  ------------------
 2554|    160|        });
_ZN3fmt3v126detail17write_significandIcNS0_14basic_appenderIcEEmNS1_23fallback_digit_groupingIcEEEET0_S7_T1_iiRKT2_:
 2420|    160|                                       const Grouping& grouping) -> OutputIt {
 2421|    160|  if (!grouping.has_separator()) {
  ------------------
  |  Branch (2421:7): [True: 160, False: 0]
  ------------------
 2422|    160|    out = write_significand<Char>(out, significand, significand_size);
 2423|    160|    return detail::fill_n(out, exponent, static_cast<Char>('0'));
 2424|    160|  }
 2425|      0|  auto buffer = memory_buffer();
 2426|      0|  write_significand<char>(appender(buffer), significand, significand_size);
 2427|      0|  detail::fill_n(appender(buffer), exponent, '0');
 2428|      0|  return grouping.apply(out, string_view(buffer.data(), buffer.size()));
 2429|    160|}
_ZN3fmt3v126detail17write_significandIcNS0_14basic_appenderIcEEmEET0_S5_T1_i:
 2414|    235|                              int significand_size) -> OutputIt {
 2415|    235|  return format_decimal<Char>(out, significand, significand_size);
 2416|    235|}
_ZN3fmt3v126detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEEZNS1_11write_fixedIcNS1_23fallback_digit_groupingIcEES5_NS1_9dragonbox10decimal_fpIdEEEET1_SC_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEEUlS5_E0_EESC_SC_SJ_mOSD_:
 1736|    174|                            size_t size, F&& f) -> OutputIt {
 1737|    174|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1738|    174|}
_ZN3fmt3v126detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEERZNS1_11write_fixedIcNS1_23fallback_digit_groupingIcEES5_NS1_9dragonbox10decimal_fpIdEEEET1_SC_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEEUlS5_E0_EESC_SC_SJ_mmOSD_:
 1715|    174|                                size_t size, size_t width, F&& f) -> OutputIt {
 1716|    174|  static_assert(default_align == align::left || default_align == align::right,
 1717|    174|                "");
 1718|    174|  unsigned spec_width = to_unsigned(specs.width);
 1719|    174|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1719:20): [True: 0, False: 174]
  ------------------
 1720|       |  // Shifts are encoded as string literals because static constexpr is not
 1721|       |  // supported in constexpr functions.
 1722|    174|  auto* shifts =
 1723|    174|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1723:7): [Folded, False: 174]
  ------------------
 1724|    174|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1725|    174|  size_t right_padding = padding - left_padding;
 1726|    174|  auto it = reserve(out, size + padding * specs.fill_size());
 1727|    174|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1727:7): [True: 0, False: 174]
  ------------------
 1728|    174|  it = f(it);
 1729|    174|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1729:7): [True: 0, False: 174]
  ------------------
 1730|    174|  return base_iterator(out, it);
 1731|    174|}
_ZZN3fmt3v126detail11write_fixedIcNS1_23fallback_digit_groupingIcEENS0_14basic_appenderIcEENS1_9dragonbox10decimal_fpIdEEEET1_SA_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEENKUlS6_E0_clES6_:
 2563|    174|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2564|    174|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2564:15): [True: 63, False: 111]
  ------------------
 2565|    174|          it = write_significand(it, f.significand, significand_size, exp,
 2566|    174|                                 decimal_point, grouping);
 2567|    174|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
  ------------------
  |  Branch (2567:18): [True: 0, False: 174]
  ------------------
 2568|    174|        });
_ZN3fmt3v126detail17write_significandINS0_14basic_appenderIcEEcmNS1_23fallback_digit_groupingIcEEEET_S7_T1_iiT0_RKT2_:
 2481|    174|                                       const Grouping& grouping) -> OutputIt {
 2482|    174|  if (!grouping.has_separator()) {
  ------------------
  |  Branch (2482:7): [True: 174, False: 0]
  ------------------
 2483|    174|    return write_significand(out, significand, significand_size, integral_size,
 2484|    174|                             decimal_point);
 2485|    174|  }
 2486|      0|  auto buffer = basic_memory_buffer<Char>();
 2487|      0|  write_significand(basic_appender<Char>(buffer), significand, significand_size,
 2488|      0|                    integral_size, decimal_point);
 2489|      0|  grouping.apply(
 2490|      0|      out, basic_string_view<Char>(buffer.data(), to_unsigned(integral_size)));
 2491|      0|  return detail::copy_noinline<Char>(buffer.data() + integral_size,
 2492|      0|                                     buffer.end(), out);
 2493|    174|}
_ZN3fmt3v126detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEEZNS1_11write_fixedIcNS1_23fallback_digit_groupingIcEES5_NS1_9dragonbox10decimal_fpIdEEEET1_SC_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEEUlS5_E1_EESC_SC_SJ_mOSD_:
 1736|     75|                            size_t size, F&& f) -> OutputIt {
 1737|     75|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1738|     75|}
_ZN3fmt3v126detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEERZNS1_11write_fixedIcNS1_23fallback_digit_groupingIcEES5_NS1_9dragonbox10decimal_fpIdEEEET1_SC_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEEUlS5_E1_EESC_SC_SJ_mmOSD_:
 1715|     75|                                size_t size, size_t width, F&& f) -> OutputIt {
 1716|     75|  static_assert(default_align == align::left || default_align == align::right,
 1717|     75|                "");
 1718|     75|  unsigned spec_width = to_unsigned(specs.width);
 1719|     75|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1719:20): [True: 0, False: 75]
  ------------------
 1720|       |  // Shifts are encoded as string literals because static constexpr is not
 1721|       |  // supported in constexpr functions.
 1722|     75|  auto* shifts =
 1723|     75|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1723:7): [Folded, False: 75]
  ------------------
 1724|     75|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1725|     75|  size_t right_padding = padding - left_padding;
 1726|     75|  auto it = reserve(out, size + padding * specs.fill_size());
 1727|     75|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1727:7): [True: 0, False: 75]
  ------------------
 1728|     75|  it = f(it);
 1729|     75|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1729:7): [True: 0, False: 75]
  ------------------
 1730|     75|  return base_iterator(out, it);
 1731|     75|}
_ZZN3fmt3v126detail11write_fixedIcNS1_23fallback_digit_groupingIcEENS0_14basic_appenderIcEENS1_9dragonbox10decimal_fpIdEEEET1_SA_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEENKUlS6_E1_clES6_:
 2579|     75|      out, specs, static_cast<size_t>(size), [&](iterator it) {
 2580|     75|        if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2580:13): [True: 35, False: 40]
  ------------------
 2581|     75|        *it++ = Char('0');
 2582|     75|        if (!pointy) return it;
  ------------------
  |  Branch (2582:13): [True: 0, False: 75]
  ------------------
 2583|     75|        *it++ = decimal_point;
 2584|     75|        it = detail::fill_n(it, num_zeros, Char('0'));
 2585|     75|        return write_significand<Char>(it, f.significand, significand_size);
 2586|     75|      });
_ZN3fmt3v126detail17write_significandINS0_14basic_appenderIcEEmcTnNSt3__19enable_ifIXntsr3std10is_pointerINS5_9remove_cvINS5_16remove_referenceIT_E4typeEE4typeEEE5valueEiE4typeELi0EEES9_S9_T0_iiT1_:
 2457|    174|                              Char decimal_point) -> OutputIt {
 2458|       |  // Buffer is large enough to hold digits (digits10 + 1) and a decimal point.
 2459|    174|  Char buffer[digits10<UInt>() + 2];
 2460|    174|  auto end = write_significand(buffer, significand, significand_size,
 2461|    174|                               integral_size, decimal_point);
 2462|    174|  return detail::copy_noinline<Char>(buffer, end, out);
 2463|    174|}
_ZN3fmt3v126detail17write_significandIcmTnNSt3__19enable_ifIXsr3std11is_integralIT0_EE5valueEiE4typeELi0EEEPT_S9_S5_iiS8_:
 2434|    174|                              int integral_size, Char decimal_point) -> Char* {
 2435|    174|  if (!decimal_point) return format_decimal(out, significand, significand_size);
  ------------------
  |  Branch (2435:7): [True: 0, False: 174]
  ------------------
 2436|    174|  out += significand_size + 1;
 2437|    174|  Char* end = out;
 2438|    174|  int floating_size = significand_size - integral_size;
 2439|    713|  for (int i = floating_size / 2; i > 0; --i) {
  ------------------
  |  Branch (2439:35): [True: 539, False: 174]
  ------------------
 2440|    539|    out -= 2;
 2441|    539|    write2digits(out, static_cast<size_t>(significand % 100));
 2442|    539|    significand /= 100;
 2443|    539|  }
 2444|    174|  if (floating_size % 2 != 0) {
  ------------------
  |  Branch (2444:7): [True: 104, False: 70]
  ------------------
 2445|    104|    *--out = static_cast<Char>('0' + significand % 10);
 2446|    104|    significand /= 10;
 2447|    104|  }
 2448|    174|  *--out = decimal_point;
 2449|    174|  format_decimal(out - integral_size, significand, integral_size);
 2450|    174|  return end;
 2451|    174|}
_ZN3fmt3v126detail8basic_fpIoEC2Ev:
 1599|    955|  constexpr basic_fp() : f(0), e(0) {}
_ZN3fmt3v1219basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEEC2ERKS4_:
  824|  3.82k|      : detail::buffer<T>(grow), alloc_(alloc) {
  825|  3.82k|    this->set(store_, SIZE);
  826|  3.82k|    if (detail::is_constant_evaluated()) detail::fill_n(store_, SIZE, T());
  ------------------
  |  Branch (826:9): [Folded, False: 3.82k]
  ------------------
  827|  3.82k|  }
_ZN3fmt3v1219basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEEC2EOS5_:
  874|  4.23k|      : detail::buffer<T>(grow) {
  875|  4.23k|    move(other);
  876|  4.23k|  }
_ZN3fmt3v1219basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEED2Ev:
  828|  8.05k|  FMT_CONSTEXPR20 ~basic_memory_buffer() { deallocate(); }
_ZN3fmt3v126detail11write_floatIcNS0_14basic_appenderIcEENS1_14big_decimal_fpEEET0_S6_RKT1_RKNS0_12format_specsENS0_4signEiNS0_10locale_refE:
 2632|    957|                                 int exp_upper, locale_ref loc) -> OutputIt {
 2633|    957|  if (is_constant_evaluated()) {
  ------------------
  |  Branch (2633:7): [Folded, False: 957]
  ------------------
 2634|      0|    return do_write_float<Char, fallback_digit_grouping<Char>>(out, f, specs, s,
 2635|      0|                                                               exp_upper, loc);
 2636|    957|  } else {
 2637|    957|    return do_write_float<Char, digit_grouping<Char>>(out, f, specs, s,
 2638|    957|                                                      exp_upper, loc);
 2639|    957|  }
 2640|    957|}
_ZN3fmt3v126detail14do_write_floatIcNS1_14digit_groupingIcEENS0_14basic_appenderIcEENS1_14big_decimal_fpEEET1_S8_RKT2_RKNS0_12format_specsENS0_4signEiNS0_10locale_refE:
 2593|    957|                                    int exp_upper, locale_ref loc) -> OutputIt {
 2594|    957|  Char point = specs.localized() ? detail::decimal_point<Char>(loc) : Char('.');
  ------------------
  |  Branch (2594:16): [True: 0, False: 957]
  ------------------
 2595|    957|  int significand_size = get_significand_size(f);
 2596|    957|  int exp = f.exponent + significand_size - 1;
 2597|    957|  if (specs.type() == presentation_type::fixed ||
  ------------------
  |  Branch (2597:7): [True: 0, False: 957]
  ------------------
 2598|    957|      (specs.type() != presentation_type::exp &&
  ------------------
  |  Branch (2598:8): [True: 957, False: 0]
  ------------------
 2599|    957|       use_fixed(exp, specs.precision > 0 ? specs.precision : exp_upper))) {
  ------------------
  |  Branch (2599:8): [True: 451, False: 506]
  |  Branch (2599:23): [True: 957, False: 0]
  ------------------
 2600|    451|    return write_fixed<Char, Grouping>(out, f, significand_size, point, specs,
 2601|    451|                                       s, loc);
 2602|    451|  }
 2603|       |
 2604|       |  // Write value in the exponential format.
 2605|    506|  int num_zeros = 0;
 2606|    506|  long long size = significand_size + (s != sign::none ? 1 : 0);
  ------------------
  |  Branch (2606:40): [True: 178, False: 328]
  ------------------
 2607|    506|  if (specs.alt()) {
  ------------------
  |  Branch (2607:7): [True: 0, False: 506]
  ------------------
 2608|      0|    num_zeros = max_of(specs.precision - significand_size, 0);
 2609|      0|    size += num_zeros;
 2610|    506|  } else if (significand_size == 1) {
  ------------------
  |  Branch (2610:14): [True: 0, False: 506]
  ------------------
 2611|      0|    point = Char();
 2612|      0|  }
 2613|    506|  size += (point ? 1 : 0) + compute_exp_size(exp);
  ------------------
  |  Branch (2613:12): [True: 506, False: 0]
  ------------------
 2614|    506|  char exp_char = specs.upper() ? 'E' : 'e';
  ------------------
  |  Branch (2614:19): [True: 0, False: 506]
  ------------------
 2615|    506|  auto write = [=](reserve_iterator<OutputIt> it) {
 2616|    506|    if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2617|       |    // Insert a decimal point after the first digit and add an exponent.
 2618|    506|    it = write_significand(it, f.significand, significand_size, 1, point);
 2619|    506|    if (num_zeros > 0) it = detail::fill_n(it, num_zeros, Char('0'));
 2620|    506|    *it++ = Char(exp_char);
 2621|    506|    return write_exponent<Char>(exp, it);
 2622|    506|  };
 2623|    506|  size_t usize = static_cast<size_t>(size);
 2624|    506|  return specs.width > 0
  ------------------
  |  Branch (2624:10): [True: 0, False: 506]
  ------------------
 2625|    506|             ? write_padded<Char, align::right>(out, specs, usize, write)
 2626|    506|             : base_iterator(out, write(reserve(out, usize)));
 2627|    957|}
_ZN3fmt3v126detail11write_fixedIcNS1_14digit_groupingIcEENS0_14basic_appenderIcEENS1_14big_decimal_fpEEET1_S8_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refE:
 2528|    451|                                 locale_ref loc = {}) -> OutputIt {
 2529|    451|  using iterator = reserve_iterator<OutputIt>;
 2530|       |
 2531|    451|  int exp = f.exponent + significand_size;
 2532|    451|  long long size = significand_size + (s != sign::none ? 1 : 0);
  ------------------
  |  Branch (2532:40): [True: 178, False: 273]
  ------------------
 2533|    451|  if (f.exponent >= 0) {
  ------------------
  |  Branch (2533:7): [True: 202, False: 249]
  ------------------
 2534|       |    // 1234e5 -> 123400000[.0+]
 2535|    202|    size += f.exponent;
 2536|    202|    int num_zeros = specs.precision - exp;
 2537|    202|    abort_fuzzing_if(num_zeros > 5000);
 2538|    202|    if (specs.alt()) {
  ------------------
  |  Branch (2538:9): [True: 0, False: 202]
  ------------------
 2539|      0|      ++size;
 2540|      0|      if (num_zeros <= 0 && specs.type() != presentation_type::fixed)
  ------------------
  |  Branch (2540:11): [True: 0, False: 0]
  |  Branch (2540:29): [True: 0, False: 0]
  ------------------
 2541|      0|        num_zeros = 0;
 2542|      0|      if (num_zeros > 0) size += num_zeros;
  ------------------
  |  Branch (2542:11): [True: 0, False: 0]
  ------------------
 2543|      0|    }
 2544|    202|    auto grouping = Grouping(loc, specs.localized());
 2545|    202|    size += grouping.count_separators(exp);
 2546|    202|    return write_padded<Char, align::right>(
 2547|    202|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2548|    202|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2549|    202|          it = write_significand<Char>(it, f.significand, significand_size,
 2550|    202|                                       f.exponent, grouping);
 2551|    202|          if (!specs.alt()) return it;
 2552|    202|          *it++ = decimal_point;
 2553|    202|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
 2554|    202|        });
 2555|    202|  }
 2556|    249|  if (exp > 0) {
  ------------------
  |  Branch (2556:7): [True: 174, False: 75]
  ------------------
 2557|       |    // 1234e-2 -> 12.34[0+]
 2558|    174|    int num_zeros = specs.alt() ? specs.precision - significand_size : 0;
  ------------------
  |  Branch (2558:21): [True: 0, False: 174]
  ------------------
 2559|    174|    size += 1 + max_of(num_zeros, 0);
 2560|    174|    auto grouping = Grouping(loc, specs.localized());
 2561|    174|    size += grouping.count_separators(exp);
 2562|    174|    return write_padded<Char, align::right>(
 2563|    174|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2564|    174|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2565|    174|          it = write_significand(it, f.significand, significand_size, exp,
 2566|    174|                                 decimal_point, grouping);
 2567|    174|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
 2568|    174|        });
 2569|    174|  }
 2570|       |  // 1234e-6 -> 0.001234
 2571|     75|  int num_zeros = -exp;
 2572|     75|  if (significand_size == 0 && specs.precision >= 0 &&
  ------------------
  |  Branch (2572:7): [True: 0, False: 75]
  |  Branch (2572:32): [True: 0, False: 0]
  ------------------
 2573|      0|      specs.precision < num_zeros) {
  ------------------
  |  Branch (2573:7): [True: 0, False: 0]
  ------------------
 2574|      0|    num_zeros = specs.precision;
 2575|      0|  }
 2576|     75|  bool pointy = num_zeros != 0 || significand_size != 0 || specs.alt();
  ------------------
  |  Branch (2576:17): [True: 38, False: 37]
  |  Branch (2576:35): [True: 37, False: 0]
  |  Branch (2576:60): [True: 0, False: 0]
  ------------------
 2577|     75|  size += 1 + (pointy ? 1 : 0) + num_zeros;
  ------------------
  |  Branch (2577:16): [True: 75, False: 0]
  ------------------
 2578|     75|  return write_padded<Char, align::right>(
 2579|     75|      out, specs, static_cast<size_t>(size), [&](iterator it) {
 2580|     75|        if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2581|     75|        *it++ = Char('0');
 2582|     75|        if (!pointy) return it;
 2583|     75|        *it++ = decimal_point;
 2584|     75|        it = detail::fill_n(it, num_zeros, Char('0'));
 2585|     75|        return write_significand<Char>(it, f.significand, significand_size);
 2586|     75|      });
 2587|    249|}
_ZN3fmt3v126detail14digit_groupingIcEC2ENS0_10locale_refEb:
 1917|    376|  explicit digit_grouping(locale_ref loc, bool localized = true) {
 1918|    376|    if (!localized) return;
  ------------------
  |  Branch (1918:9): [True: 376, False: 0]
  ------------------
 1919|      0|    auto sep = thousands_sep<Char>(loc);
 1920|      0|    grouping_ = std::move(sep.grouping);
 1921|      0|    if (sep.thousands_sep) thousands_sep_.assign(1, sep.thousands_sep);
  ------------------
  |  Branch (1921:9): [True: 0, False: 0]
  ------------------
 1922|      0|  }
_ZNK3fmt3v126detail14digit_groupingIcE16count_separatorsEi:
 1928|    376|  auto count_separators(int num_digits) const -> int {
 1929|    376|    int count = 0;
 1930|    376|    auto state = initial_state();
 1931|    376|    while (num_digits > next(state)) ++count;
  ------------------
  |  Branch (1931:12): [True: 0, False: 376]
  ------------------
 1932|    376|    return count;
 1933|    376|  }
_ZNK3fmt3v126detail14digit_groupingIcE13initial_stateEv:
 1904|    376|  auto initial_state() const -> next_state { return {grouping_.begin(), 0}; }
_ZNK3fmt3v126detail14digit_groupingIcE4nextERNS3_10next_stateE:
 1907|    376|  auto next(next_state& state) const -> int {
 1908|    376|    if (thousands_sep_.empty()) return max_value<int>();
  ------------------
  |  Branch (1908:9): [True: 376, False: 0]
  ------------------
 1909|      0|    if (state.group == grouping_.end()) return state.pos += grouping_.back();
  ------------------
  |  Branch (1909:9): [True: 0, False: 0]
  ------------------
 1910|      0|    if (*state.group <= 0 || *state.group == max_value<char>())
  ------------------
  |  Branch (1910:9): [True: 0, False: 0]
  |  Branch (1910:30): [True: 0, False: 0]
  ------------------
 1911|      0|      return max_value<int>();
 1912|      0|    state.pos += *state.group++;
 1913|      0|    return state.pos;
 1914|      0|  }
_ZN3fmt3v126detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEEZNS1_11write_fixedIcNS1_14digit_groupingIcEES5_NS1_14big_decimal_fpEEET1_SA_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEEUlS5_E_EESA_SA_SH_mOSB_:
 1736|    202|                            size_t size, F&& f) -> OutputIt {
 1737|    202|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1738|    202|}
_ZN3fmt3v126detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEERZNS1_11write_fixedIcNS1_14digit_groupingIcEES5_NS1_14big_decimal_fpEEET1_SA_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEEUlS5_E_EESA_SA_SH_mmOSB_:
 1715|    202|                                size_t size, size_t width, F&& f) -> OutputIt {
 1716|    202|  static_assert(default_align == align::left || default_align == align::right,
 1717|    202|                "");
 1718|    202|  unsigned spec_width = to_unsigned(specs.width);
 1719|    202|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1719:20): [True: 0, False: 202]
  ------------------
 1720|       |  // Shifts are encoded as string literals because static constexpr is not
 1721|       |  // supported in constexpr functions.
 1722|    202|  auto* shifts =
 1723|    202|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1723:7): [Folded, False: 202]
  ------------------
 1724|    202|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1725|    202|  size_t right_padding = padding - left_padding;
 1726|    202|  auto it = reserve(out, size + padding * specs.fill_size());
 1727|    202|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1727:7): [True: 0, False: 202]
  ------------------
 1728|    202|  it = f(it);
 1729|    202|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1729:7): [True: 0, False: 202]
  ------------------
 1730|    202|  return base_iterator(out, it);
 1731|    202|}
_ZZN3fmt3v126detail11write_fixedIcNS1_14digit_groupingIcEENS0_14basic_appenderIcEENS1_14big_decimal_fpEEET1_S8_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEENKUlS6_E_clES6_:
 2547|    202|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2548|    202|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2548:15): [True: 80, False: 122]
  ------------------
 2549|    202|          it = write_significand<Char>(it, f.significand, significand_size,
 2550|    202|                                       f.exponent, grouping);
 2551|    202|          if (!specs.alt()) return it;
  ------------------
  |  Branch (2551:15): [True: 202, False: 0]
  ------------------
 2552|      0|          *it++ = decimal_point;
 2553|      0|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
  ------------------
  |  Branch (2553:18): [True: 0, False: 0]
  ------------------
 2554|    202|        });
_ZN3fmt3v126detail17write_significandIcNS0_14basic_appenderIcEEPKcNS1_14digit_groupingIcEEEET0_S9_T1_iiRKT2_:
 2420|    202|                                       const Grouping& grouping) -> OutputIt {
 2421|    202|  if (!grouping.has_separator()) {
  ------------------
  |  Branch (2421:7): [True: 202, False: 0]
  ------------------
 2422|    202|    out = write_significand<Char>(out, significand, significand_size);
 2423|    202|    return detail::fill_n(out, exponent, static_cast<Char>('0'));
 2424|    202|  }
 2425|      0|  auto buffer = memory_buffer();
 2426|      0|  write_significand<char>(appender(buffer), significand, significand_size);
 2427|      0|  detail::fill_n(appender(buffer), exponent, '0');
 2428|      0|  return grouping.apply(out, string_view(buffer.data(), buffer.size()));
 2429|    202|}
_ZNK3fmt3v126detail14digit_groupingIcE13has_separatorEv:
 1926|    376|  auto has_separator() const -> bool { return !thousands_sep_.empty(); }
_ZN3fmt3v126detail17write_significandIcNS0_14basic_appenderIcEEEET0_S5_PKci:
 2409|    277|                                 int significand_size) -> OutputIt {
 2410|    277|  return copy<Char>(significand, significand + significand_size, out);
 2411|    277|}
_ZN3fmt3v126detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEEZNS1_11write_fixedIcNS1_14digit_groupingIcEES5_NS1_14big_decimal_fpEEET1_SA_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEEUlS5_E0_EESA_SA_SH_mOSB_:
 1736|    174|                            size_t size, F&& f) -> OutputIt {
 1737|    174|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1738|    174|}
_ZN3fmt3v126detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEERZNS1_11write_fixedIcNS1_14digit_groupingIcEES5_NS1_14big_decimal_fpEEET1_SA_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEEUlS5_E0_EESA_SA_SH_mmOSB_:
 1715|    174|                                size_t size, size_t width, F&& f) -> OutputIt {
 1716|    174|  static_assert(default_align == align::left || default_align == align::right,
 1717|    174|                "");
 1718|    174|  unsigned spec_width = to_unsigned(specs.width);
 1719|    174|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1719:20): [True: 0, False: 174]
  ------------------
 1720|       |  // Shifts are encoded as string literals because static constexpr is not
 1721|       |  // supported in constexpr functions.
 1722|    174|  auto* shifts =
 1723|    174|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1723:7): [Folded, False: 174]
  ------------------
 1724|    174|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1725|    174|  size_t right_padding = padding - left_padding;
 1726|    174|  auto it = reserve(out, size + padding * specs.fill_size());
 1727|    174|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1727:7): [True: 0, False: 174]
  ------------------
 1728|    174|  it = f(it);
 1729|    174|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1729:7): [True: 0, False: 174]
  ------------------
 1730|    174|  return base_iterator(out, it);
 1731|    174|}
_ZZN3fmt3v126detail11write_fixedIcNS1_14digit_groupingIcEENS0_14basic_appenderIcEENS1_14big_decimal_fpEEET1_S8_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEENKUlS6_E0_clES6_:
 2563|    174|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2564|    174|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2564:15): [True: 63, False: 111]
  ------------------
 2565|    174|          it = write_significand(it, f.significand, significand_size, exp,
 2566|    174|                                 decimal_point, grouping);
 2567|    174|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
  ------------------
  |  Branch (2567:18): [True: 0, False: 174]
  ------------------
 2568|    174|        });
_ZN3fmt3v126detail17write_significandINS0_14basic_appenderIcEEcPKcNS1_14digit_groupingIcEEEET_S9_T1_iiT0_RKT2_:
 2481|    174|                                       const Grouping& grouping) -> OutputIt {
 2482|    174|  if (!grouping.has_separator()) {
  ------------------
  |  Branch (2482:7): [True: 174, False: 0]
  ------------------
 2483|    174|    return write_significand(out, significand, significand_size, integral_size,
 2484|    174|                             decimal_point);
 2485|    174|  }
 2486|      0|  auto buffer = basic_memory_buffer<Char>();
 2487|      0|  write_significand(basic_appender<Char>(buffer), significand, significand_size,
 2488|      0|                    integral_size, decimal_point);
 2489|      0|  grouping.apply(
 2490|      0|      out, basic_string_view<Char>(buffer.data(), to_unsigned(integral_size)));
 2491|      0|  return detail::copy_noinline<Char>(buffer.data() + integral_size,
 2492|      0|                                     buffer.end(), out);
 2493|    174|}
_ZN3fmt3v126detail17write_significandINS0_14basic_appenderIcEEcEET_S5_PKciiT0_:
 2468|    680|                                     Char decimal_point) -> OutputIt {
 2469|    680|  out = detail::copy_noinline<Char>(significand, significand + integral_size,
 2470|    680|                                    out);
 2471|    680|  if (!decimal_point) return out;
  ------------------
  |  Branch (2471:7): [True: 0, False: 680]
  ------------------
 2472|    680|  *out++ = decimal_point;
 2473|    680|  return detail::copy_noinline<Char>(significand + integral_size,
 2474|    680|                                     significand + significand_size, out);
 2475|    680|}
_ZN3fmt3v126detail13copy_noinlineIcPKcNS0_14basic_appenderIcEEEET1_T0_S8_S7_:
  561|  3.45k|                                              OutputIt out) -> OutputIt {
  562|  3.45k|  return copy<OutChar>(begin, end, out);
  563|  3.45k|}
_ZN3fmt3v126detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEEZNS1_11write_fixedIcNS1_14digit_groupingIcEES5_NS1_14big_decimal_fpEEET1_SA_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEEUlS5_E1_EESA_SA_SH_mOSB_:
 1736|     75|                            size_t size, F&& f) -> OutputIt {
 1737|     75|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1738|     75|}
_ZN3fmt3v126detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEERZNS1_11write_fixedIcNS1_14digit_groupingIcEES5_NS1_14big_decimal_fpEEET1_SA_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEEUlS5_E1_EESA_SA_SH_mmOSB_:
 1715|     75|                                size_t size, size_t width, F&& f) -> OutputIt {
 1716|     75|  static_assert(default_align == align::left || default_align == align::right,
 1717|     75|                "");
 1718|     75|  unsigned spec_width = to_unsigned(specs.width);
 1719|     75|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1719:20): [True: 0, False: 75]
  ------------------
 1720|       |  // Shifts are encoded as string literals because static constexpr is not
 1721|       |  // supported in constexpr functions.
 1722|     75|  auto* shifts =
 1723|     75|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1723:7): [Folded, False: 75]
  ------------------
 1724|     75|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1725|     75|  size_t right_padding = padding - left_padding;
 1726|     75|  auto it = reserve(out, size + padding * specs.fill_size());
 1727|     75|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1727:7): [True: 0, False: 75]
  ------------------
 1728|     75|  it = f(it);
 1729|     75|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1729:7): [True: 0, False: 75]
  ------------------
 1730|     75|  return base_iterator(out, it);
 1731|     75|}
_ZZN3fmt3v126detail11write_fixedIcNS1_14digit_groupingIcEENS0_14basic_appenderIcEENS1_14big_decimal_fpEEET1_S8_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEENKUlS6_E1_clES6_:
 2579|     75|      out, specs, static_cast<size_t>(size), [&](iterator it) {
 2580|     75|        if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2580:13): [True: 35, False: 40]
  ------------------
 2581|     75|        *it++ = Char('0');
 2582|     75|        if (!pointy) return it;
  ------------------
  |  Branch (2582:13): [True: 0, False: 75]
  ------------------
 2583|     75|        *it++ = decimal_point;
 2584|     75|        it = detail::fill_n(it, num_zeros, Char('0'));
 2585|     75|        return write_significand<Char>(it, f.significand, significand_size);
 2586|     75|      });
_ZZN3fmt3v126detail14do_write_floatIcNS1_14digit_groupingIcEENS0_14basic_appenderIcEENS1_14big_decimal_fpEEET1_S8_RKT2_RKNS0_12format_specsENS0_4signEiNS0_10locale_refEENKUlS6_E_clES6_:
 2615|    506|  auto write = [=](reserve_iterator<OutputIt> it) {
 2616|    506|    if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2616:9): [True: 178, False: 328]
  ------------------
 2617|       |    // Insert a decimal point after the first digit and add an exponent.
 2618|    506|    it = write_significand(it, f.significand, significand_size, 1, point);
 2619|    506|    if (num_zeros > 0) it = detail::fill_n(it, num_zeros, Char('0'));
  ------------------
  |  Branch (2619:9): [True: 0, False: 506]
  ------------------
 2620|    506|    *it++ = Char(exp_char);
 2621|    506|    return write_exponent<Char>(exp, it);
 2622|    506|  };
_ZN3fmt3v126detail14format_handlerIcE7on_textEPKcS5_:
 3791|  2.09k|  void on_text(const Char* begin, const Char* end) {
 3792|  2.09k|    copy_noinline<Char>(begin, end, ctx.out());
 3793|  2.09k|  }
_ZN3fmt3v126detail14format_handlerIcE9on_arg_idEv:
 3795|  1.04k|  FMT_CONSTEXPR auto on_arg_id() -> int { return parse_ctx.next_arg_id(); }
_ZN3fmt3v126detail14format_handlerIcE15on_format_specsEiPKcS5_:
 3812|  1.04k|      -> const Char* {
 3813|  1.04k|    auto arg = ctx.arg(id);
 3814|  1.04k|    if (!arg) report_error("argument not found");
  ------------------
  |  Branch (3814:9): [True: 0, False: 1.04k]
  ------------------
 3815|       |    // Not using a visitor for custom types gives better codegen.
 3816|  1.04k|    if (arg.format_custom(begin, parse_ctx, ctx)) return parse_ctx.begin();
  ------------------
  |  Branch (3816:9): [True: 0, False: 1.04k]
  ------------------
 3817|       |
 3818|  1.04k|    auto specs = dynamic_format_specs<Char>();
 3819|  1.04k|    begin = parse_format_specs(begin, end, specs, parse_ctx, arg.type());
 3820|  1.04k|    if (specs.dynamic()) {
  ------------------
  |  Branch (3820:9): [True: 0, False: 1.04k]
  ------------------
 3821|      0|      handle_dynamic_spec(specs.dynamic_width(), specs.width, specs.width_ref,
 3822|      0|                          ctx);
 3823|      0|      handle_dynamic_spec(specs.dynamic_precision(), specs.precision,
 3824|      0|                          specs.precision_ref, ctx);
 3825|      0|    }
 3826|       |
 3827|  1.04k|    arg.visit(arg_formatter<Char>{ctx.out(), specs, ctx.locale()});
 3828|  1.04k|    return begin;
 3829|  1.04k|  }
_ZN3fmt3v126detail12format_floatIdEEiT_iRKNS0_12format_specsEbRNS1_6bufferIcEE:
 3175|    957|                                  buffer<char>& buf) -> int {
 3176|       |  // float is passed as double to reduce the number of instantiations.
 3177|    957|  static_assert(!std::is_same<Float, float>::value, "");
 3178|    957|  auto converted_value = convert_float(value);
 3179|       |
 3180|    957|  const bool fixed = specs.type() == presentation_type::fixed;
 3181|    957|  if (value == 0) {
  ------------------
  |  Branch (3181:7): [True: 2, False: 955]
  ------------------
 3182|      2|    if (precision <= 0 || !fixed) {
  ------------------
  |  Branch (3182:9): [True: 0, False: 2]
  |  Branch (3182:27): [True: 2, False: 0]
  ------------------
 3183|      2|      buf.push_back('0');
 3184|      2|      return 0;
 3185|      2|    }
 3186|      0|    buf.try_resize(to_unsigned(precision));
 3187|      0|    fill_n(buf.data(), precision, '0');
 3188|      0|    return -precision;
 3189|      2|  }
 3190|       |
 3191|    955|  int exp = 0;
 3192|    955|  bool use_dragon = true;
 3193|    955|  unsigned dragon_flags = 0;
 3194|    955|  if (!is_fast_float<Float>() || is_constant_evaluated()) {
  ------------------
  |  Branch (3194:7): [Folded, False: 0]
  |  Branch (3194:7): [Folded, False: 955]
  |  Branch (3194:34): [Folded, False: 0]
  ------------------
 3195|      0|    const auto inv_log2_10 = 0.3010299956639812;  // 1 / log2(10)
 3196|      0|    using info = dragonbox::float_info<decltype(converted_value)>;
 3197|      0|    const auto f = basic_fp<typename info::carrier_uint>(converted_value);
 3198|       |    // Compute exp, an approximate power of 10, such that
 3199|       |    //   10^(exp - 1) <= value < 10^exp or 10^exp <= value < 10^(exp + 1).
 3200|       |    // This is based on log10(value) == log2(value) / log2(10) and approximation
 3201|       |    // of log2(value) by e + num_fraction_bits idea from double-conversion.
 3202|      0|    auto e = (f.e + count_digits<1>(f.f) - 1) * inv_log2_10 - 1e-10;
 3203|      0|    exp = static_cast<int>(e);
 3204|      0|    if (e > exp) ++exp;  // Compute ceil.
  ------------------
  |  Branch (3204:9): [True: 0, False: 0]
  ------------------
 3205|      0|    dragon_flags = dragon::fixup;
 3206|    955|  } else {
 3207|       |    // Extract significand bits and exponent bits.
 3208|    955|    using info = dragonbox::float_info<double>;
 3209|    955|    auto br = bit_cast<uint64_t>(static_cast<double>(value));
 3210|       |
 3211|    955|    const uint64_t significand_mask =
 3212|    955|        (static_cast<uint64_t>(1) << num_significand_bits<double>()) - 1;
 3213|    955|    uint64_t significand = (br & significand_mask);
 3214|    955|    int exponent = static_cast<int>((br & exponent_mask<double>()) >>
 3215|    955|                                    num_significand_bits<double>());
 3216|       |
 3217|    955|    if (exponent != 0) {  // Check if normal.
  ------------------
  |  Branch (3217:9): [True: 837, False: 118]
  ------------------
 3218|    837|      exponent -= exponent_bias<double>() + num_significand_bits<double>();
 3219|    837|      significand |=
 3220|    837|          (static_cast<uint64_t>(1) << num_significand_bits<double>());
 3221|    837|      significand <<= 1;
 3222|    837|    } else {
 3223|       |      // Normalize subnormal inputs.
 3224|    118|      FMT_ASSERT(significand != 0, "zeros should not appear here");
  ------------------
  |  |  402|    118|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 118, False: 0]
  |  |  ------------------
  |  |  403|    118|         ? (void)0                                                          \
  |  |  404|    118|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 3225|    118|      int shift = countl_zero(significand);
 3226|    118|      FMT_ASSERT(shift >= num_bits<uint64_t>() - num_significand_bits<double>(),
  ------------------
  |  |  402|    118|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 118, False: 0]
  |  |  ------------------
  |  |  403|    118|         ? (void)0                                                          \
  |  |  404|    118|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 3227|    118|                 "");
 3228|    118|      shift -= (num_bits<uint64_t>() - num_significand_bits<double>() - 2);
 3229|    118|      exponent = (std::numeric_limits<double>::min_exponent -
 3230|    118|                  num_significand_bits<double>()) -
 3231|    118|                 shift;
 3232|    118|      significand <<= shift;
 3233|    118|    }
 3234|       |
 3235|       |    // Compute the first several nonzero decimal significand digits.
 3236|       |    // We call the number we get the first segment.
 3237|    955|    const int k = info::kappa - dragonbox::floor_log10_pow2(exponent);
 3238|    955|    exp = -k;
 3239|    955|    const int beta = exponent + dragonbox::floor_log2_pow10(k);
 3240|    955|    uint64_t first_segment;
 3241|    955|    bool has_more_segments;
 3242|    955|    int digits_in_the_first_segment;
 3243|    955|    {
 3244|    955|      const auto r = dragonbox::umul192_upper128(
 3245|    955|          significand << beta, dragonbox::get_cached_power(k));
 3246|    955|      first_segment = r.high();
 3247|    955|      has_more_segments = r.low() != 0;
 3248|       |
 3249|       |      // The first segment can have 18 ~ 19 digits.
 3250|    955|      if (first_segment >= 1000000000000000000ULL) {
  ------------------
  |  Branch (3250:11): [True: 713, False: 242]
  ------------------
 3251|    713|        digits_in_the_first_segment = 19;
 3252|    713|      } else {
 3253|       |        // When it is of 18-digits, we align it to 19-digits by adding a bogus
 3254|       |        // zero at the end.
 3255|    242|        digits_in_the_first_segment = 18;
 3256|    242|        first_segment *= 10;
 3257|    242|      }
 3258|    955|    }
 3259|       |
 3260|       |    // Compute the actual number of decimal digits to print.
 3261|    955|    if (fixed) adjust_precision(precision, exp + digits_in_the_first_segment);
  ------------------
  |  Branch (3261:9): [True: 0, False: 955]
  ------------------
 3262|       |
 3263|       |    // Use Dragon4 only when there might be not enough digits in the first
 3264|       |    // segment.
 3265|    955|    if (digits_in_the_first_segment > precision) {
  ------------------
  |  Branch (3265:9): [True: 0, False: 955]
  ------------------
 3266|      0|      use_dragon = false;
 3267|       |
 3268|      0|      if (precision <= 0) {
  ------------------
  |  Branch (3268:11): [True: 0, False: 0]
  ------------------
 3269|      0|        exp += digits_in_the_first_segment;
 3270|       |
 3271|      0|        if (precision < 0) {
  ------------------
  |  Branch (3271:13): [True: 0, False: 0]
  ------------------
 3272|       |          // Nothing to do, since all we have are just leading zeros.
 3273|      0|          buf.try_resize(0);
 3274|      0|        } else {
 3275|       |          // We may need to round-up.
 3276|      0|          buf.try_resize(1);
 3277|      0|          if ((first_segment | static_cast<uint64_t>(has_more_segments)) >
  ------------------
  |  Branch (3277:15): [True: 0, False: 0]
  ------------------
 3278|      0|              5000000000000000000ULL) {
 3279|      0|            buf[0] = '1';
 3280|      0|          } else {
 3281|      0|            buf[0] = '0';
 3282|      0|          }
 3283|      0|        }
 3284|      0|      }  // precision <= 0
 3285|      0|      else {
 3286|      0|        exp += digits_in_the_first_segment - precision;
 3287|       |
 3288|       |        // When precision > 0, we divide the first segment into three
 3289|       |        // subsegments, each with 9, 9, and 0 ~ 1 digits so that each fits
 3290|       |        // in 32-bits which usually allows faster calculation than in
 3291|       |        // 64-bits. Since some compiler (e.g. MSVC) doesn't know how to optimize
 3292|       |        // division-by-constant for large 64-bit divisors, we do it here
 3293|       |        // manually. The magic number 7922816251426433760 below is equal to
 3294|       |        // ceil(2^(64+32) / 10^10).
 3295|      0|        const uint32_t first_subsegment = static_cast<uint32_t>(
 3296|      0|            dragonbox::umul128_upper64(first_segment, 7922816251426433760ULL) >>
 3297|      0|            32);
 3298|      0|        const uint64_t second_third_subsegments =
 3299|      0|            first_segment - first_subsegment * 10000000000ULL;
 3300|       |
 3301|      0|        uint64_t prod;
 3302|      0|        uint32_t digits;
 3303|      0|        bool should_round_up;
 3304|      0|        int number_of_digits_to_print = min_of(precision, 9);
 3305|       |
 3306|       |        // Print a 9-digits subsegment, either the first or the second.
 3307|      0|        auto print_subsegment = [&](uint32_t subsegment, char* buffer) {
 3308|      0|          int number_of_digits_printed = 0;
 3309|       |
 3310|       |          // If we want to print an odd number of digits from the subsegment,
 3311|      0|          if ((number_of_digits_to_print & 1) != 0) {
 3312|       |            // Convert to 64-bit fixed-point fractional form with 1-digit
 3313|       |            // integer part. The magic number 720575941 is a good enough
 3314|       |            // approximation of 2^(32 + 24) / 10^8; see
 3315|       |            // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case
 3316|       |            // for details.
 3317|      0|            prod = ((subsegment * static_cast<uint64_t>(720575941)) >> 24) + 1;
 3318|      0|            digits = static_cast<uint32_t>(prod >> 32);
 3319|      0|            *buffer = static_cast<char>('0' + digits);
 3320|      0|            number_of_digits_printed++;
 3321|      0|          }
 3322|       |          // If we want to print an even number of digits from the
 3323|       |          // first_subsegment,
 3324|      0|          else {
 3325|       |            // Convert to 64-bit fixed-point fractional form with 2-digits
 3326|       |            // integer part. The magic number 450359963 is a good enough
 3327|       |            // approximation of 2^(32 + 20) / 10^7; see
 3328|       |            // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case
 3329|       |            // for details.
 3330|      0|            prod = ((subsegment * static_cast<uint64_t>(450359963)) >> 20) + 1;
 3331|      0|            digits = static_cast<uint32_t>(prod >> 32);
 3332|      0|            write2digits(buffer, digits);
 3333|      0|            number_of_digits_printed += 2;
 3334|      0|          }
 3335|       |
 3336|       |          // Print all digit pairs.
 3337|      0|          while (number_of_digits_printed < number_of_digits_to_print) {
 3338|      0|            prod = static_cast<uint32_t>(prod) * static_cast<uint64_t>(100);
 3339|      0|            digits = static_cast<uint32_t>(prod >> 32);
 3340|      0|            write2digits(buffer + number_of_digits_printed, digits);
 3341|      0|            number_of_digits_printed += 2;
 3342|      0|          }
 3343|      0|        };
 3344|       |
 3345|       |        // Print first subsegment.
 3346|      0|        print_subsegment(first_subsegment, buf.data());
 3347|       |
 3348|       |        // Perform rounding if the first subsegment is the last subsegment to
 3349|       |        // print.
 3350|      0|        if (precision <= 9) {
  ------------------
  |  Branch (3350:13): [True: 0, False: 0]
  ------------------
 3351|       |          // Rounding inside the subsegment.
 3352|       |          // We round-up if:
 3353|       |          //  - either the fractional part is strictly larger than 1/2, or
 3354|       |          //  - the fractional part is exactly 1/2 and the last digit is odd.
 3355|       |          // We rely on the following observations:
 3356|       |          //  - If fractional_part >= threshold, then the fractional part is
 3357|       |          //    strictly larger than 1/2.
 3358|       |          //  - If the MSB of fractional_part is set, then the fractional part
 3359|       |          //    must be at least 1/2.
 3360|       |          //  - When the MSB of fractional_part is set, either
 3361|       |          //    second_third_subsegments being nonzero or has_more_segments
 3362|       |          //    being true means there are further digits not printed, so the
 3363|       |          //    fractional part is strictly larger than 1/2.
 3364|      0|          if (precision < 9) {
  ------------------
  |  Branch (3364:15): [True: 0, False: 0]
  ------------------
 3365|      0|            uint32_t fractional_part = static_cast<uint32_t>(prod);
 3366|      0|            should_round_up =
 3367|      0|                fractional_part >= fractional_part_rounding_thresholds(
  ------------------
  |  Branch (3367:17): [True: 0, False: 0]
  ------------------
 3368|      0|                                       8 - number_of_digits_to_print) ||
 3369|      0|                ((fractional_part >> 31) &
  ------------------
  |  Branch (3369:17): [True: 0, False: 0]
  ------------------
 3370|      0|                 ((digits & 1) | (second_third_subsegments != 0) |
 3371|      0|                  has_more_segments)) != 0;
 3372|      0|          }
 3373|       |          // Rounding at the subsegment boundary.
 3374|       |          // In this case, the fractional part is at least 1/2 if and only if
 3375|       |          // second_third_subsegments >= 5000000000ULL, and is strictly larger
 3376|       |          // than 1/2 if we further have either second_third_subsegments >
 3377|       |          // 5000000000ULL or has_more_segments == true.
 3378|      0|          else {
 3379|      0|            should_round_up = second_third_subsegments > 5000000000ULL ||
  ------------------
  |  Branch (3379:31): [True: 0, False: 0]
  ------------------
 3380|      0|                              (second_third_subsegments == 5000000000ULL &&
  ------------------
  |  Branch (3380:32): [True: 0, False: 0]
  ------------------
 3381|      0|                               ((digits & 1) != 0 || has_more_segments));
  ------------------
  |  Branch (3381:33): [True: 0, False: 0]
  |  Branch (3381:54): [True: 0, False: 0]
  ------------------
 3382|      0|          }
 3383|      0|        }
 3384|       |        // Otherwise, print the second subsegment.
 3385|      0|        else {
 3386|       |          // Compilers are not aware of how to leverage the maximum value of
 3387|       |          // second_third_subsegments to find out a better magic number which
 3388|       |          // allows us to eliminate an additional shift. 1844674407370955162 =
 3389|       |          // ceil(2^64/10) < ceil(2^64*(10^9/(10^10 - 1))).
 3390|      0|          const uint32_t second_subsegment =
 3391|      0|              static_cast<uint32_t>(dragonbox::umul128_upper64(
 3392|      0|                  second_third_subsegments, 1844674407370955162ULL));
 3393|      0|          const uint32_t third_subsegment =
 3394|      0|              static_cast<uint32_t>(second_third_subsegments) -
 3395|      0|              second_subsegment * 10;
 3396|       |
 3397|      0|          number_of_digits_to_print = precision - 9;
 3398|      0|          print_subsegment(second_subsegment, buf.data() + 9);
 3399|       |
 3400|       |          // Rounding inside the subsegment.
 3401|      0|          if (precision < 18) {
  ------------------
  |  Branch (3401:15): [True: 0, False: 0]
  ------------------
 3402|       |            // The condition third_subsegment != 0 implies that the segment was
 3403|       |            // of 19 digits, so in this case the third segment should be
 3404|       |            // consisting of a genuine digit from the input.
 3405|      0|            uint32_t fractional_part = static_cast<uint32_t>(prod);
 3406|      0|            should_round_up =
 3407|      0|                fractional_part >= fractional_part_rounding_thresholds(
  ------------------
  |  Branch (3407:17): [True: 0, False: 0]
  ------------------
 3408|      0|                                       8 - number_of_digits_to_print) ||
 3409|      0|                ((fractional_part >> 31) &
  ------------------
  |  Branch (3409:17): [True: 0, False: 0]
  ------------------
 3410|      0|                 ((digits & 1) | (third_subsegment != 0) |
 3411|      0|                  has_more_segments)) != 0;
 3412|      0|          }
 3413|       |          // Rounding at the subsegment boundary.
 3414|      0|          else {
 3415|       |            // In this case, the segment must be of 19 digits, thus
 3416|       |            // the third subsegment should be consisting of a genuine digit from
 3417|       |            // the input.
 3418|      0|            should_round_up = third_subsegment > 5 ||
  ------------------
  |  Branch (3418:31): [True: 0, False: 0]
  ------------------
 3419|      0|                              (third_subsegment == 5 &&
  ------------------
  |  Branch (3419:32): [True: 0, False: 0]
  ------------------
 3420|      0|                               ((digits & 1) != 0 || has_more_segments));
  ------------------
  |  Branch (3420:33): [True: 0, False: 0]
  |  Branch (3420:54): [True: 0, False: 0]
  ------------------
 3421|      0|          }
 3422|      0|        }
 3423|       |
 3424|       |        // Round-up if necessary.
 3425|      0|        if (should_round_up) {
  ------------------
  |  Branch (3425:13): [True: 0, False: 0]
  ------------------
 3426|      0|          ++buf[precision - 1];
 3427|      0|          for (int i = precision - 1; i > 0 && buf[i] > '9'; --i) {
  ------------------
  |  Branch (3427:39): [True: 0, False: 0]
  |  Branch (3427:48): [True: 0, False: 0]
  ------------------
 3428|      0|            buf[i] = '0';
 3429|      0|            ++buf[i - 1];
 3430|      0|          }
 3431|      0|          if (buf[0] > '9') {
  ------------------
  |  Branch (3431:15): [True: 0, False: 0]
  ------------------
 3432|      0|            buf[0] = '1';
 3433|      0|            if (fixed)
  ------------------
  |  Branch (3433:17): [True: 0, False: 0]
  ------------------
 3434|      0|              buf[precision++] = '0';
 3435|      0|            else
 3436|      0|              ++exp;
 3437|      0|          }
 3438|      0|        }
 3439|      0|        buf.try_resize(to_unsigned(precision));
 3440|      0|      }
 3441|      0|    }  // if (digits_in_the_first_segment > precision)
 3442|    955|    else {
 3443|       |      // Adjust the exponent for its use in Dragon4.
 3444|    955|      exp += digits_in_the_first_segment - 1;
 3445|    955|    }
 3446|    955|  }
 3447|    955|  if (use_dragon) {
  ------------------
  |  Branch (3447:7): [True: 955, False: 0]
  ------------------
 3448|    955|    auto f = basic_fp<uint128_t>();
 3449|    955|    bool is_predecessor_closer = binary32 ? f.assign(static_cast<float>(value))
  ------------------
  |  Branch (3449:34): [True: 0, False: 955]
  ------------------
 3450|    955|                                          : f.assign(converted_value);
 3451|    955|    if (is_predecessor_closer) dragon_flags |= dragon::predecessor_closer;
  ------------------
  |  Branch (3451:9): [True: 145, False: 810]
  ------------------
 3452|    955|    if (fixed) dragon_flags |= dragon::fixed;
  ------------------
  |  Branch (3452:9): [True: 0, False: 955]
  ------------------
 3453|       |    // Limit precision to the maximum possible number of significant digits in
 3454|       |    // an IEEE754 double because we don't need to generate zeros.
 3455|    955|    const int max_double_digits = 767;
 3456|    955|    if (precision > max_double_digits) precision = max_double_digits;
  ------------------
  |  Branch (3456:9): [True: 0, False: 955]
  ------------------
 3457|    955|    format_dragon(f, dragon_flags, precision, buf, exp);
 3458|    955|  }
 3459|    955|  if (!fixed && !specs.alt()) {
  ------------------
  |  Branch (3459:7): [True: 955, False: 0]
  |  Branch (3459:17): [True: 955, False: 0]
  ------------------
 3460|       |    // Remove trailing zeros.
 3461|    955|    auto num_digits = buf.size();
 3462|  13.3k|    while (num_digits > 0 && buf[num_digits - 1] == '0') {
  ------------------
  |  Branch (3462:12): [True: 13.3k, False: 0]
  |  Branch (3462:30): [True: 12.3k, False: 955]
  ------------------
 3463|  12.3k|      --num_digits;
 3464|  12.3k|      ++exp;
 3465|  12.3k|    }
 3466|    955|    buf.try_resize(num_digits);
 3467|    955|  }
 3468|    955|  return exp;
 3469|    957|}
_ZN3fmt3v126detail13convert_floatIdEENSt3__111conditionalIXoosr3std7is_sameIT_fEE5valueeqcl8num_bitsIS5_EEclL_ZNS1_8num_bitsIdEEivEEEdS5_E4typeES5_:
 1685|  1.91k|constexpr auto convert_float(T value) -> convert_float_result<T> {
 1686|  1.91k|  return static_cast<convert_float_result<T>>(value);
 1687|  1.91k|}
_ZN3fmt3v126detail8basic_fpIoE6assignIdTnNSt3__19enable_ifIXntsr16is_double_doubleIT_EE5valueEiE4typeELi0EEEbS7_:
 1607|    955|  FMT_CONSTEXPR auto assign(Float n) -> bool {
 1608|    955|    static_assert(std::numeric_limits<Float>::digits <= 113, "unsupported FP");
 1609|       |    // Assume Float is in the format [sign][exponent][significand].
 1610|    955|    using carrier_uint = typename dragonbox::float_info<Float>::carrier_uint;
 1611|    955|    const auto num_float_significand_bits =
 1612|    955|        detail::num_significand_bits<Float>();
 1613|    955|    const auto implicit_bit = carrier_uint(1) << num_float_significand_bits;
 1614|    955|    const auto significand_mask = implicit_bit - 1;
 1615|    955|    auto u = bit_cast<carrier_uint>(n);
 1616|    955|    f = static_cast<F>(u & significand_mask);
 1617|    955|    auto biased_e = static_cast<int>((u & exponent_mask<Float>()) >>
 1618|    955|                                     num_float_significand_bits);
 1619|       |    // The predecessor is closer if n is a normalized power of 2 (f == 0)
 1620|       |    // other than the smallest normalized number (biased_e > 1).
 1621|    955|    auto is_predecessor_closer = f == 0 && biased_e > 1;
  ------------------
  |  Branch (1621:34): [True: 146, False: 809]
  |  Branch (1621:44): [True: 145, False: 1]
  ------------------
 1622|    955|    if (biased_e == 0)
  ------------------
  |  Branch (1622:9): [True: 118, False: 837]
  ------------------
 1623|    118|      biased_e = 1;  // Subnormals use biased exponent 1 (min exponent).
 1624|    837|    else if (has_implicit_bit<Float>())
  ------------------
  |  Branch (1624:14): [True: 837, Folded]
  ------------------
 1625|    837|      f += static_cast<F>(implicit_bit);
 1626|    955|    e = biased_e - exponent_bias<Float>() - num_float_significand_bits;
 1627|    955|    if (!has_implicit_bit<Float>()) ++e;
  ------------------
  |  Branch (1627:9): [Folded, False: 955]
  ------------------
 1628|    955|    return is_predecessor_closer;
 1629|    955|  }
_ZN3fmt3v126detail13arg_formatterIcEclIdTnNSt3__19enable_ifIXsr10is_builtinIT_EE5valueEiE4typeELi0EEEvS7_:
 3710|  1.04k|  FMT_CONSTEXPR FMT_INLINE void operator()(T value) {
 3711|  1.04k|    detail::write<Char>(out, value, specs, locale);
 3712|  1.04k|  }
_ZN3fmt3v126detail5writeIcNS0_14basic_appenderIcEEdTnNSt3__19enable_ifIXsr17is_floating_pointIT1_EE5valueEiE4typeELi0EEET0_SA_S7_NS0_12format_specsENS0_10locale_refE:
 3474|  1.04k|                           locale_ref loc = {}) -> OutputIt {
 3475|  1.04k|  if (specs.localized() && write_loc(out, value, specs, loc)) return out;
  ------------------
  |  Branch (3475:7): [True: 0, False: 1.04k]
  |  Branch (3475:7): [True: 0, False: 1.04k]
  |  Branch (3475:28): [True: 0, False: 0]
  ------------------
 3476|       |
 3477|       |  // Use signbit because value < 0 is false for NaN.
 3478|  1.04k|  sign s = detail::signbit(value) ? sign::minus : specs.sign();
  ------------------
  |  Branch (3478:12): [True: 441, False: 605]
  ------------------
 3479|       |
 3480|  1.04k|  if (!detail::isfinite(value))
  ------------------
  |  Branch (3480:7): [True: 89, False: 957]
  ------------------
 3481|     89|    return write_nonfinite<Char>(out, detail::isnan(value), specs, s);
 3482|       |
 3483|    957|  if (specs.align() == align::numeric && s != sign::none) {
  ------------------
  |  Branch (3483:7): [True: 0, False: 957]
  |  Branch (3483:42): [True: 0, False: 0]
  ------------------
 3484|      0|    *out++ = detail::getsign<Char>(s);
 3485|      0|    s = sign::none;
 3486|      0|    if (specs.width != 0) --specs.width;
  ------------------
  |  Branch (3486:9): [True: 0, False: 0]
  ------------------
 3487|      0|  }
 3488|       |
 3489|    957|  const int exp_upper = detail::exp_upper<T>();
 3490|    957|  int precision = specs.precision;
 3491|    957|  if (precision < 0) {
  ------------------
  |  Branch (3491:7): [True: 0, False: 957]
  ------------------
 3492|      0|    if (specs.type() != presentation_type::none) {
  ------------------
  |  Branch (3492:9): [True: 0, False: 0]
  ------------------
 3493|      0|      precision = 6;
 3494|      0|    } else if (is_fast_float<T>::value && !is_constant_evaluated()) {
  ------------------
  |  Branch (3494:16): [True: 0, Folded]
  |  Branch (3494:43): [True: 0, Folded]
  ------------------
 3495|       |      // Use Dragonbox for the shortest format.
 3496|      0|      auto dec = dragonbox::to_decimal(static_cast<fast_float_t<T>>(value));
 3497|      0|      return write_float<Char>(out, dec, specs, s, exp_upper, loc);
 3498|      0|    }
 3499|      0|  }
 3500|       |
 3501|    957|  memory_buffer buffer;
 3502|    957|  if (specs.type() == presentation_type::hexfloat) {
  ------------------
  |  Branch (3502:7): [True: 0, False: 957]
  ------------------
 3503|      0|    if (s != sign::none) buffer.push_back(detail::getsign<char>(s));
  ------------------
  |  Branch (3503:9): [True: 0, False: 0]
  ------------------
 3504|      0|    format_hexfloat(convert_float(value), specs, buffer);
 3505|      0|    return write_bytes<Char, align::right>(out, {buffer.data(), buffer.size()},
 3506|      0|                                           specs);
 3507|      0|  }
 3508|       |
 3509|    957|  if (specs.type() == presentation_type::exp) {
  ------------------
  |  Branch (3509:7): [True: 0, False: 957]
  ------------------
 3510|      0|    if (precision == max_value<int>())
  ------------------
  |  Branch (3510:9): [True: 0, False: 0]
  ------------------
 3511|      0|      report_error("number is too big");
 3512|      0|    else
 3513|      0|      ++precision;
 3514|      0|    if (specs.precision != 0) specs.set_alt();
  ------------------
  |  Branch (3514:9): [True: 0, False: 0]
  ------------------
 3515|    957|  } else if (specs.type() == presentation_type::fixed) {
  ------------------
  |  Branch (3515:14): [True: 0, False: 957]
  ------------------
 3516|      0|    if (specs.precision != 0) specs.set_alt();
  ------------------
  |  Branch (3516:9): [True: 0, False: 0]
  ------------------
 3517|    957|  } else if (precision == 0) {
  ------------------
  |  Branch (3517:14): [True: 0, False: 957]
  ------------------
 3518|      0|    precision = 1;
 3519|      0|  }
 3520|    957|  int exp = format_float(convert_float(value), precision, specs,
 3521|    957|                         std::is_same<T, float>(), buffer);
 3522|       |
 3523|    957|  specs.precision = precision;
 3524|    957|  auto f = big_decimal_fp{buffer.data(), static_cast<int>(buffer.size()), exp};
 3525|    957|  return write_float<Char>(out, f, specs, s, exp_upper, loc);
 3526|    957|}
_ZN3fmt3v126detail8isfiniteIdTnNSt3__19enable_ifIXaasr17is_floating_pointIT_EE5valuesr12has_isfiniteIS5_EE5valueEiE4typeELi0EEEbS5_:
 2655|  1.04k|FMT_CONSTEXPR20 auto isfinite(T value) -> bool {
 2656|  1.04k|  constexpr T inf = T(std::numeric_limits<double>::infinity());
 2657|  1.04k|  if (is_constant_evaluated())
  ------------------
  |  Branch (2657:7): [Folded, False: 1.04k]
  ------------------
 2658|      0|    return !detail::isnan(value) && value < inf && value > -inf;
  ------------------
  |  Branch (2658:12): [True: 0, False: 0]
  |  Branch (2658:37): [True: 0, False: 0]
  |  Branch (2658:52): [True: 0, False: 0]
  ------------------
 2659|  1.04k|  return std::isfinite(value);
 2660|  1.04k|}
_ZN3fmt3v126detail5isnanIdEEbT_:
 2642|     89|template <typename T> constexpr auto isnan(T value) -> bool {
 2643|     89|  return value != value;  // std::isnan doesn't support __float128.
 2644|     89|}
_ZN3fmt3v126detail9max_valueIjEET_v:
  410|    315|template <typename T> constexpr auto max_value() -> T {
  411|    315|  return (std::numeric_limits<T>::max)();
  412|    315|}
_ZN3fmt3v126detail8bit_castImdTnNSt3__19enable_ifIXeqstT_stT0_EiE4typeELi0EEES5_RKS6_:
  268|  3.91k|FMT_CONSTEXPR20 auto bit_cast(const From& from) -> To {
  269|       |#ifdef __cpp_lib_bit_cast
  270|       |  if (is_constant_evaluated()) return std::bit_cast<To>(from);
  271|       |#endif
  272|  3.91k|  auto to = To();
  273|       |  // The cast suppresses a bogus -Wclass-memaccess on GCC.
  274|  3.91k|  memcpy(static_cast<void*>(&to), &from, sizeof(to));
  275|  3.91k|  return to;
  276|  3.91k|}

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

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