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

_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|    359|FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) {
  241|    359|  ignore_unused(condition);
  242|    359|#ifdef FMT_FUZZ
  243|    359|  if (condition) throw std::runtime_error("fuzzing limit reached");
  ------------------
  |  Branch (243:7): [True: 0, False: 359]
  ------------------
  244|    359|#endif
  245|    359|}
_ZN3fmt3v126detail9max_valueImEET_v:
  410|    936|template <typename T> constexpr auto max_value() -> T {
  411|    936|  return (std::numeric_limits<T>::max)();
  412|    936|}
_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.08k|  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|  4.00k|  constexpr auto low() const noexcept -> uint64_t { return lo_; }
_ZN3fmt3v126detail7uint128pLEm:
  374|  1.75k|  FMT_CONSTEXPR20 auto operator+=(uint64_t n) noexcept -> uint128& {
  375|  1.75k|    if (is_constant_evaluated()) {
  ------------------
  |  Branch (375:9): [Folded, False: 1.75k]
  ------------------
  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.75k|#if FMT_HAS_BUILTIN(__builtin_addcll) && !defined(__ibmxl__)
  381|  1.75k|    ullong carry;
  382|  1.75k|    lo_ = __builtin_addcll(lo_, n, 0, &carry);
  383|  1.75k|    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.75k|    return *this;
  397|  1.75k|  }
_ZN3fmt3v126detail20num_significand_bitsIdEEiv:
 1565|  10.0k|template <typename Float> constexpr auto num_significand_bits() -> int {
 1566|       |  // std::numeric_limits may not support __float128.
 1567|  10.0k|  return is_float128<Float>() ? 112
  ------------------
  |  Branch (1567:10): [Folded, False: 10.0k]
  ------------------
 1568|  10.0k|                              : (std::numeric_limits<Float>::digits -
 1569|  10.0k|                                 (has_implicit_bit<Float>() ? 1 : 0));
  ------------------
  |  Branch (1569:35): [True: 10.0k, Folded]
  ------------------
 1570|  10.0k|}
_ZN3fmt3v126detail9max_valueIiEET_v:
  410|    381|template <typename T> constexpr auto max_value() -> T {
  411|    381|  return (std::numeric_limits<T>::max)();
  412|    381|}
_ZN3fmt3v126detail6fill_nINS0_14basic_appenderIcEEicEET_S5_T0_RKT1_:
  541|    491|    -> OutputIt {
  542|    809|  for (Size i = 0; i < count; ++i) *out++ = value;
  ------------------
  |  Branch (542:20): [True: 318, False: 491]
  ------------------
  543|    491|  return out;
  544|    491|}
_ZN3fmt3v126detail8num_bitsIjEEiv:
  413|  21.4k|template <typename T> constexpr auto num_bits() -> int {
  414|  21.4k|  return std::numeric_limits<T>::digits;
  415|  21.4k|}
_ZNK3fmt3v126detail6bigint9get_bigitEi:
 2728|  2.93k|  FMT_CONSTEXPR auto get_bigit(int i) const -> bigit {
 2729|  2.93k|    return i >= exp_ && i < num_bigits() ? bigits_[i - exp_] : 0;
  ------------------
  |  Branch (2729:12): [True: 2.88k, False: 50]
  |  Branch (2729:25): [True: 2.05k, False: 828]
  ------------------
 2730|  2.93k|  }
_ZN3fmt3v126detail6bigint15subtract_bigitsEijRj:
 2732|   792k|  FMT_CONSTEXPR void subtract_bigits(int index, bigit other, bigit& borrow) {
 2733|   792k|    auto result = double_bigit(bigits_[index]) - other - borrow;
 2734|   792k|    bigits_[index] = static_cast<bigit>(result);
 2735|   792k|    borrow = static_cast<bigit>(result >> (bigit_bits * 2 - 1));
 2736|   792k|  }
_ZN3fmt3v1219basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEE6resizeEm:
  891|   177k|  FMT_CONSTEXPR void resize(size_t count) { this->try_resize(count); }
_ZN3fmt3v126detail6bigint20remove_leading_zerosEv:
 2738|   165k|  FMT_CONSTEXPR void remove_leading_zeros() {
 2739|   165k|    int num_bigits = static_cast<int>(bigits_.size()) - 1;
 2740|   173k|    while (num_bigits > 0 && bigits_[num_bigits] == 0) --num_bigits;
  ------------------
  |  Branch (2740:12): [True: 170k, False: 2.57k]
  |  Branch (2740:30): [True: 7.40k, False: 163k]
  ------------------
 2741|   165k|    bigits_.resize(to_unsigned(num_bigits + 1));
 2742|   165k|  }
_ZN3fmt3v126detail6bigint16subtract_alignedERKS2_:
 2745|   161k|  FMT_CONSTEXPR void subtract_aligned(const bigint& other) {
 2746|   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)))
  ------------------
 2747|   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)))
  ------------------
 2748|   161k|    bigit borrow = 0;
 2749|   161k|    int i = other.exp_ - exp_;
 2750|   949k|    for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j)
  ------------------
  |  Branch (2750:50): [True: 787k, False: 161k]
  ------------------
 2751|   787k|      subtract_bigits(i, other.bigits_[j], borrow);
 2752|   161k|    if (borrow != 0) subtract_bigits(i, 0, borrow);
  ------------------
  |  Branch (2752:9): [True: 4.86k, False: 156k]
  ------------------
 2753|   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)))
  ------------------
 2754|   161k|    remove_leading_zeros();
 2755|   161k|  }
_ZN3fmt3v126detail6bigint8multiplyEj:
 2757|  48.5k|  FMT_CONSTEXPR void multiply(uint32_t value) {
 2758|  48.5k|    bigit carry = 0;
 2759|  48.5k|    const double_bigit wide_value = value;
 2760|   497k|    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
  ------------------
  |  Branch (2760:44): [True: 449k, False: 48.5k]
  ------------------
 2761|   449k|      double_bigit result = bigits_[i] * wide_value + carry;
 2762|   449k|      bigits_[i] = static_cast<bigit>(result);
 2763|   449k|      carry = static_cast<bigit>(result >> bigit_bits);
 2764|   449k|    }
 2765|  48.5k|    if (carry != 0) bigits_.push_back(carry);
  ------------------
  |  Branch (2765:9): [True: 3.94k, False: 44.5k]
  ------------------
 2766|  48.5k|  }
_ZN3fmt3v126detail6bigintC2Ev:
 2802|  3.79k|  FMT_CONSTEXPR bigint() : exp_(0) {}
_ZN3fmt3v126detail6bigint6assignImTnNSt3__19enable_ifIXoosr3std7is_sameIT_mEE5valuesr3std7is_sameIS6_oEE5valueEiE4typeELi0EEEvS6_:
 2791|  1.98k|  FMT_CONSTEXPR void assign(UInt n) {
 2792|  1.98k|    size_t num_bigits = 0;
 2793|  1.98k|    do {
 2794|  1.98k|      bigits_[num_bigits++] = static_cast<bigit>(n);
 2795|  1.98k|      n >>= bigit_bits;
 2796|  1.98k|    } while (n != 0);
  ------------------
  |  Branch (2796:14): [True: 0, False: 1.98k]
  ------------------
 2797|  1.98k|    bigits_.resize(num_bigits);
 2798|  1.98k|    exp_ = 0;
 2799|  1.98k|  }
_ZN3fmt3v126detail6bigint6assignERKS2_:
 2808|    461|  FMT_CONSTEXPR void assign(const bigint& other) {
 2809|    461|    auto size = other.bigits_.size();
 2810|    461|    bigits_.resize(size);
 2811|    461|    auto data = other.bigits_.data();
 2812|    461|    copy<bigit>(data, data + size, bigits_.data());
 2813|    461|    exp_ = other.exp_;
 2814|    461|  }
_ZNK3fmt3v126detail6bigint10num_bigitsEv:
 2821|   746k|  FMT_CONSTEXPR auto num_bigits() const -> int {
 2822|   746k|    return static_cast<int>(bigits_.size()) + exp_;
 2823|   746k|  }
_ZN3fmt3v126detail6bigintlSEi:
 2825|  3.16k|  FMT_CONSTEXPR auto operator<<=(int shift) -> bigint& {
 2826|  3.16k|    FMT_ASSERT(shift >= 0, "");
  ------------------
  |  |  402|  3.16k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 3.16k, False: 0]
  |  |  ------------------
  |  |  403|  3.16k|         ? (void)0                                                          \
  |  |  404|  3.16k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2827|  3.16k|    exp_ += shift / bigit_bits;
 2828|  3.16k|    shift %= bigit_bits;
 2829|  3.16k|    if (shift == 0) return *this;
  ------------------
  |  Branch (2829:9): [True: 72, False: 3.08k]
  ------------------
 2830|  3.08k|    bigit carry = 0;
 2831|  22.3k|    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
  ------------------
  |  Branch (2831:44): [True: 19.2k, False: 3.08k]
  ------------------
 2832|  19.2k|      bigit c = bigits_[i] >> (bigit_bits - shift);
 2833|  19.2k|      bigits_[i] = (bigits_[i] << shift) + carry;
 2834|  19.2k|      carry = c;
 2835|  19.2k|    }
 2836|  3.08k|    if (carry != 0) bigits_.push_back(carry);
  ------------------
  |  Branch (2836:9): [True: 503, False: 2.58k]
  ------------------
 2837|  3.08k|    return *this;
 2838|  3.16k|  }
_ZN3fmt3v126detail7compareERKNS1_6bigintES4_:
 2846|   370k|  friend FMT_CONSTEXPR auto compare(const bigint& b1, const bigint& b2) -> int {
 2847|   370k|    int num_bigits1 = b1.num_bigits(), num_bigits2 = b2.num_bigits();
 2848|   370k|    if (num_bigits1 != num_bigits2) return num_bigits1 > num_bigits2 ? 1 : -1;
  ------------------
  |  Branch (2848:9): [True: 30.6k, False: 340k]
  |  Branch (2848:44): [True: 15.5k, False: 15.1k]
  ------------------
 2849|   340k|    int i = static_cast<int>(b1.bigits_.size()) - 1;
 2850|   340k|    int j = static_cast<int>(b2.bigits_.size()) - 1;
 2851|   340k|    int end = i - j;
 2852|   340k|    if (end < 0) end = 0;
  ------------------
  |  Branch (2852:9): [True: 159, False: 339k]
  ------------------
 2853|   345k|    for (; i >= end; --i, --j) {
  ------------------
  |  Branch (2853:12): [True: 342k, False: 3.45k]
  ------------------
 2854|   342k|      bigit b1_bigit = b1.bigits_[i], b2_bigit = b2.bigits_[j];
 2855|   342k|      if (b1_bigit != b2_bigit) return b1_bigit > b2_bigit ? 1 : -1;
  ------------------
  |  Branch (2855:11): [True: 336k, False: 5.52k]
  |  Branch (2855:40): [True: 304k, False: 32.2k]
  ------------------
 2856|   342k|    }
 2857|  3.45k|    if (i != j) return i > j ? 1 : -1;
  ------------------
  |  Branch (2857:9): [True: 2.95k, False: 498]
  |  Branch (2857:24): [True: 2.95k, False: 0]
  ------------------
 2858|    498|    return 0;
 2859|  3.45k|  }
_ZN3fmt3v126detail11add_compareERKNS1_6bigintES4_S4_:
 2863|    948|                                        const bigint& rhs) -> int {
 2864|    948|    int max_lhs_bigits = max_of(lhs1.num_bigits(), lhs2.num_bigits());
 2865|    948|    int num_rhs_bigits = rhs.num_bigits();
 2866|    948|    if (max_lhs_bigits + 1 < num_rhs_bigits) return -1;
  ------------------
  |  Branch (2866:9): [True: 42, False: 906]
  ------------------
 2867|    906|    if (max_lhs_bigits > num_rhs_bigits) return 1;
  ------------------
  |  Branch (2867:9): [True: 0, False: 906]
  ------------------
 2868|    906|    double_bigit borrow = 0;
 2869|    906|    int min_exp = min_of(min_of(lhs1.exp_, lhs2.exp_), rhs.exp_);
 2870|    992|    for (int i = num_rhs_bigits - 1; i >= min_exp; --i) {
  ------------------
  |  Branch (2870:38): [True: 978, False: 14]
  ------------------
 2871|    978|      double_bigit sum = double_bigit(lhs1.get_bigit(i)) + lhs2.get_bigit(i);
 2872|    978|      bigit rhs_bigit = rhs.get_bigit(i);
 2873|    978|      if (sum > rhs_bigit + borrow) return 1;
  ------------------
  |  Branch (2873:11): [True: 261, False: 717]
  ------------------
 2874|    717|      borrow = rhs_bigit + borrow - sum;
 2875|    717|      if (borrow > 1) return -1;
  ------------------
  |  Branch (2875:11): [True: 631, False: 86]
  ------------------
 2876|     86|      borrow <<= bigit_bits;
 2877|     86|    }
 2878|     14|    return borrow != 0 ? -1 : 0;
  ------------------
  |  Branch (2878:12): [True: 0, False: 14]
  ------------------
 2879|    906|  }
_ZN3fmt3v126detail6bigintaSIiEEvT_:
 2816|  1.95k|  template <typename Int> FMT_CONSTEXPR void operator=(Int n) {
 2817|  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)))
  ------------------
 2818|  1.95k|    assign(uint64_or_128_t<Int>(n));
 2819|  1.95k|  }
_ZN3fmt3v126detail6bigintmLIiEERS2_T_:
 2840|  48.5k|  template <typename Int> FMT_CONSTEXPR auto operator*=(Int value) -> bigint& {
 2841|  48.5k|    FMT_ASSERT(value > 0, "");
  ------------------
  |  |  402|  48.5k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 48.5k, False: 0]
  |  |  ------------------
  |  |  403|  48.5k|         ? (void)0                                                          \
  |  |  404|  48.5k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2842|  48.5k|    multiply(uint32_or_64_or_128_t<Int>(value));
 2843|  48.5k|    return *this;
 2844|  48.5k|  }
_ZN3fmt3v126detail6bigint12assign_pow10Ei:
 2882|    948|  FMT_CONSTEXPR20 void assign_pow10(int exp) {
 2883|    948|    FMT_ASSERT(exp >= 0, "");
  ------------------
  |  |  402|    948|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 948, False: 0]
  |  |  ------------------
  |  |  403|    948|         ? (void)0                                                          \
  |  |  404|    948|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2884|    948|    if (exp == 0) return *this = 1;
  ------------------
  |  Branch (2884:9): [True: 26, False: 922]
  ------------------
 2885|    922|    int bitmask = 1 << (num_bits<unsigned>() -
 2886|    922|                        countl_zero(static_cast<uint32_t>(exp)) - 1);
 2887|       |    // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by
 2888|       |    // repeated squaring and multiplication.
 2889|    922|    *this = 5;
 2890|    922|    bitmask >>= 1;
 2891|  5.16k|    while (bitmask != 0) {
  ------------------
  |  Branch (2891:12): [True: 4.24k, False: 922]
  ------------------
 2892|  4.24k|      square();
 2893|  4.24k|      if ((exp & bitmask) != 0) *this *= 5;
  ------------------
  |  Branch (2893:11): [True: 2.05k, False: 2.19k]
  ------------------
 2894|  4.24k|      bitmask >>= 1;
 2895|  4.24k|    }
 2896|    922|    *this <<= exp;  // Multiply by pow(2, exp) by shifting.
 2897|    922|  }
_ZN3fmt3v126detail6bigint6squareEv:
 2899|  4.24k|  FMT_CONSTEXPR20 void square() {
 2900|  4.24k|    int num_bigits = static_cast<int>(bigits_.size());
 2901|  4.24k|    int num_result_bigits = 2 * num_bigits;
 2902|  4.24k|    basic_memory_buffer<bigit, bigits_capacity> n(std::move(bigits_));
 2903|  4.24k|    bigits_.resize(to_unsigned(num_result_bigits));
 2904|  4.24k|    auto sum = uint128_t();
 2905|  14.5k|    for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) {
  ------------------
  |  Branch (2905:31): [True: 10.2k, False: 4.24k]
  ------------------
 2906|       |      // Compute bigit at position bigit_index of the result by adding
 2907|       |      // cross-product terms n[i] * n[j] such that i + j == bigit_index.
 2908|  44.4k|      for (int i = 0, j = bigit_index; j >= 0; ++i, --j) {
  ------------------
  |  Branch (2908:40): [True: 34.1k, False: 10.2k]
  ------------------
 2909|       |        // Most terms are multiplied twice which can be optimized in the future.
 2910|  34.1k|        sum += double_bigit(n[i]) * n[j];
 2911|  34.1k|      }
 2912|  10.2k|      bigits_[bigit_index] = static_cast<bigit>(sum);
 2913|  10.2k|      sum >>= num_bits<bigit>();  // Compute the carry.
 2914|  10.2k|    }
 2915|       |    // Do the same for the top half.
 2916|  14.5k|    for (int bigit_index = num_bigits; bigit_index < num_result_bigits;
  ------------------
  |  Branch (2916:40): [True: 10.2k, False: 4.24k]
  ------------------
 2917|  10.2k|         ++bigit_index) {
 2918|  34.1k|      for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;)
  ------------------
  |  Branch (2918:57): [True: 23.9k, False: 10.2k]
  ------------------
 2919|  23.9k|        sum += double_bigit(n[i++]) * n[j--];
 2920|  10.2k|      bigits_[bigit_index] = static_cast<bigit>(sum);
 2921|  10.2k|      sum >>= num_bits<bigit>();
 2922|  10.2k|    }
 2923|  4.24k|    remove_leading_zeros();
 2924|  4.24k|    exp_ *= 2;
 2925|  4.24k|  }
_ZN3fmt3v126detail6fill_nIPjjjEET_S4_T0_RKT1_:
  541|    179|    -> OutputIt {
  542|  2.59k|  for (Size i = 0; i < count; ++i) *out++ = value;
  ------------------
  |  Branch (542:20): [True: 2.41k, False: 179]
  ------------------
  543|    179|  return out;
  544|    179|}
_ZN3fmt3v126detail6bigint5alignERKS2_:
 2929|  31.6k|  FMT_CONSTEXPR void align(const bigint& other) {
 2930|  31.6k|    int exp_difference = exp_ - other.exp_;
 2931|  31.6k|    if (exp_difference <= 0) return;
  ------------------
  |  Branch (2931:9): [True: 31.5k, False: 179]
  ------------------
 2932|    179|    int num_bigits = static_cast<int>(bigits_.size());
 2933|    179|    bigits_.resize(to_unsigned(num_bigits + exp_difference));
 2934|    669|    for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
  ------------------
  |  Branch (2934:58): [True: 490, False: 179]
  ------------------
 2935|    490|      bigits_[j] = bigits_[i];
 2936|    179|    fill_n(bigits_.data(), to_unsigned(exp_difference), 0U);
 2937|    179|    exp_ -= exp_difference;
 2938|    179|  }
_ZN3fmt3v126detail6bigint13divmod_assignERKS2_:
 2942|  47.4k|  FMT_CONSTEXPR auto divmod_assign(const bigint& divisor) -> int {
 2943|  47.4k|    FMT_ASSERT(this != &divisor, "");
  ------------------
  |  |  402|  47.4k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 47.4k, False: 0]
  |  |  ------------------
  |  |  403|  47.4k|         ? (void)0                                                          \
  |  |  404|  47.4k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2944|  47.4k|    if (compare(*this, divisor) < 0) return 0;
  ------------------
  |  Branch (2944:9): [True: 15.7k, False: 31.6k]
  ------------------
 2945|  31.6k|    FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, "");
  ------------------
  |  |  402|  31.6k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 31.6k, False: 0]
  |  |  ------------------
  |  |  403|  31.6k|         ? (void)0                                                          \
  |  |  404|  31.6k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2946|  31.6k|    align(divisor);
 2947|  31.6k|    int quotient = 0;
 2948|   161k|    do {
 2949|   161k|      subtract_aligned(divisor);
 2950|   161k|      ++quotient;
 2951|   161k|    } while (compare(*this, divisor) >= 0);
  ------------------
  |  Branch (2951:14): [True: 129k, False: 31.6k]
  ------------------
 2952|  31.6k|    return quotient;
 2953|  47.4k|  }
_ZN3fmt3v126detail6bigint6assignIoTnNSt3__19enable_ifIXoosr3std7is_sameIT_mEE5valuesr3std7is_sameIS6_oEE5valueEiE4typeELi0EEEvS6_:
 2791|    546|  FMT_CONSTEXPR void assign(UInt n) {
 2792|    546|    size_t num_bigits = 0;
 2793|  1.09k|    do {
 2794|  1.09k|      bigits_[num_bigits++] = static_cast<bigit>(n);
 2795|  1.09k|      n >>= bigit_bits;
 2796|  1.09k|    } while (n != 0);
  ------------------
  |  Branch (2796:14): [True: 546, False: 546]
  ------------------
 2797|    546|    bigits_.resize(num_bigits);
 2798|    546|    exp_ = 0;
 2799|    546|  }
_ZN3fmt3v126detail6bigintaSIoEEvT_:
 2816|    546|  template <typename Int> FMT_CONSTEXPR void operator=(Int n) {
 2817|    546|    FMT_ASSERT(n > 0, "");
  ------------------
  |  |  402|    546|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 546, False: 0]
  |  |  ------------------
  |  |  403|    546|         ? (void)0                                                          \
  |  |  404|    546|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2818|    546|    assign(uint64_or_128_t<Int>(n));
 2819|    546|  }
_ZN3fmt3v126detail8num_bitsImEEiv:
  413|    658|template <typename T> constexpr auto num_bits() -> int {
  414|    658|  return std::numeric_limits<T>::digits;
  415|    658|}
_ZN3fmt3v126detail6bigint8multiplyIoTnNSt3__19enable_ifIXoosr3std7is_sameIT_mEE5valuesr3std7is_sameIS6_oEE5valueEiE4typeELi0EEEvS6_:
 2770|    402|  FMT_CONSTEXPR void multiply(UInt value) {
 2771|    402|    using half_uint =
 2772|    402|        conditional_t<std::is_same<UInt, uint128_t>::value, uint64_t, uint32_t>;
 2773|    402|    const int shift = num_bits<half_uint>() - bigit_bits;
 2774|    402|    const UInt lower = static_cast<half_uint>(value);
 2775|    402|    const UInt upper = value >> num_bits<half_uint>();
 2776|    402|    UInt carry = 0;
 2777|  5.56k|    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
  ------------------
  |  Branch (2777:44): [True: 5.15k, False: 402]
  ------------------
 2778|  5.15k|      UInt result = lower * bigits_[i] + static_cast<bigit>(carry);
 2779|  5.15k|      carry = (upper * bigits_[i] << shift) + (result >> bigit_bits) +
 2780|  5.15k|              (carry >> bigit_bits);
 2781|  5.15k|      bigits_[i] = static_cast<bigit>(result);
 2782|  5.15k|    }
 2783|    922|    while (carry != 0) {
  ------------------
  |  Branch (2783:12): [True: 520, False: 402]
  ------------------
 2784|    520|      bigits_.push_back(static_cast<bigit>(carry));
 2785|    520|      carry >>= bigit_bits;
 2786|    520|    }
 2787|    402|  }
_ZN3fmt3v126detail6bigintmLIoEERS2_T_:
 2840|    402|  template <typename Int> FMT_CONSTEXPR auto operator*=(Int value) -> bigint& {
 2841|    402|    FMT_ASSERT(value > 0, "");
  ------------------
  |  |  402|    402|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 402, False: 0]
  |  |  ------------------
  |  |  403|    402|         ? (void)0                                                          \
  |  |  404|    402|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2842|    402|    multiply(uint32_or_64_or_128_t<Int>(value));
 2843|    402|    return *this;
 2844|    402|  }
_ZN3fmt3v126detail6bigintaSIyEEvT_:
 2816|     30|  template <typename Int> FMT_CONSTEXPR void operator=(Int n) {
 2817|     30|    FMT_ASSERT(n > 0, "");
  ------------------
  |  |  402|     30|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 30, False: 0]
  |  |  ------------------
  |  |  403|     30|         ? (void)0                                                          \
  |  |  404|     30|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2818|     30|    assign(uint64_or_128_t<Int>(n));
 2819|     30|  }
_ZN3fmt3v126detail13copy_noinlineIcPcNS0_14basic_appenderIcEEEET1_T0_S7_S6_:
  561|    178|                                              OutputIt out) -> OutputIt {
  562|    178|  return copy<OutChar>(begin, end, out);
  563|    178|}
_ZN3fmt3v126detail13exponent_maskIdEENS1_9dragonbox10float_infoIT_vE12carrier_uintEv:
 1574|  3.89k|    typename dragonbox::float_info<Float>::carrier_uint {
 1575|  3.89k|  using float_uint = typename dragonbox::float_info<Float>::carrier_uint;
 1576|  3.89k|  return ((float_uint(1) << dragonbox::float_info<Float>::exponent_bits) - 1)
 1577|  3.89k|         << num_significand_bits<Float>();
 1578|  3.89k|}
_ZN3fmt3v126detail13exponent_biasIdEEiv:
 1579|  2.58k|template <typename Float> constexpr auto exponent_bias() -> int {
 1580|       |  // std::numeric_limits may not support __float128.
 1581|  2.58k|  return is_float128<Float>() ? 16383
  ------------------
  |  Branch (1581:10): [Folded, False: 2.58k]
  ------------------
 1582|  2.58k|                              : std::numeric_limits<Float>::max_exponent - 1;
 1583|  2.58k|}
_ZN3fmt3v126detail7getsignIcEET_NS0_4signE:
 1048|    747|template <typename Char> constexpr auto getsign(sign s) -> Char {
 1049|    747|  return static_cast<Char>(static_cast<char>(
 1050|    747|      ((' ' << 24) | ('+' << 16) | ('-' << 8)) >> (static_cast<int>(s) * 8)));
 1051|    747|}
_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|    128|FMT_CONSTEXPR20 inline auto countl_zero(uint64_t n) -> int {
  456|    128|#ifdef FMT_BUILTIN_CLZLL
  457|    128|  if (!is_constant_evaluated()) return FMT_BUILTIN_CLZLL(n);
  ------------------
  |  |  199|    128|#    define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
  ------------------
  |  Branch (457:7): [True: 128, Folded]
  ------------------
  458|      0|#endif
  459|      0|  return countl_zero_fallback(n);
  460|    128|}
_ZN3fmt3v126detail7digits2Em:
 1020|  7.79k|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.79k|  alignas(2) static constexpr char data[] =
 1024|  7.79k|      "0001020304050607080910111213141516171819"
 1025|  7.79k|      "2021222324252627282930313233343536373839"
 1026|  7.79k|      "4041424344454647484950515253545556575859"
 1027|  7.79k|      "6061626364656667686970717273747576777879"
 1028|  7.79k|      "8081828384858687888990919293949596979899";
 1029|  7.79k|  return &data[value * 2];
 1030|  7.79k|}
_ZN3fmt3v126detail15do_count_digitsEm:
 1070|  1.89k|inline auto do_count_digits(uint64_t n) -> int {
 1071|       |  // This has comparable performance to the version by Kendall Willets
 1072|       |  // (https://github.com/fmtlib/format-benchmark/blob/master/digits10)
 1073|       |  // but uses smaller tables.
 1074|       |  // Maps bsr(n) to ceil(log10(pow(2, bsr(n) + 1) - 1)).
 1075|  1.89k|  static constexpr uint8_t bsr2log10[] = {
 1076|  1.89k|      1,  1,  1,  2,  2,  2,  3,  3,  3,  4,  4,  4,  4,  5,  5,  5,
 1077|  1.89k|      6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  9,  9,  9,  10, 10, 10,
 1078|  1.89k|      10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15,
 1079|  1.89k|      15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19, 20};
 1080|  1.89k|  auto t = bsr2log10[FMT_BUILTIN_CLZLL(n | 1) ^ 63];
  ------------------
  |  |  199|  1.89k|#    define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
  ------------------
 1081|  1.89k|  static constexpr uint64_t zero_or_powers_of_10[] = {
 1082|  1.89k|      0, 0, FMT_POWERS_OF_10(1U), FMT_POWERS_OF_10(1000000000ULL),
  ------------------
  |  | 1014|  1.89k|  factor * 10, (factor) * 100, (factor) * 1000, (factor) * 10000, \
  |  | 1015|  1.89k|      (factor) * 100000, (factor) * 1000000, (factor) * 10000000, \
  |  | 1016|  1.89k|      (factor) * 100000000, (factor) * 1000000000
  ------------------
                    0, 0, FMT_POWERS_OF_10(1U), FMT_POWERS_OF_10(1000000000ULL),
  ------------------
  |  | 1014|  1.89k|  factor * 10, (factor) * 100, (factor) * 1000, (factor) * 10000, \
  |  | 1015|  1.89k|      (factor) * 100000, (factor) * 1000000, (factor) * 10000000, \
  |  | 1016|  1.89k|      (factor) * 100000000, (factor) * 1000000000
  ------------------
 1083|  1.89k|      10000000000000000000ULL};
 1084|  1.89k|  return t - (n < zero_or_powers_of_10[t]);
 1085|  1.89k|}
_ZN3fmt3v126detail12count_digitsEm:
 1090|  1.89k|FMT_CONSTEXPR20 inline auto count_digits(uint64_t n) -> int {
 1091|  1.89k|#ifdef FMT_BUILTIN_CLZLL
 1092|  1.89k|  if (!is_constant_evaluated() && !FMT_OPTIMIZE_SIZE) return do_count_digits(n);
  ------------------
  |  |  303|      0|#  define FMT_OPTIMIZE_SIZE 0
  ------------------
  |  Branch (1092:7): [True: 0, Folded]
  |  Branch (1092:35): [True: 0, Folded]
  ------------------
 1093|      0|#endif
 1094|      0|  return count_digits_fallback(n);
 1095|  1.89k|}
_ZN3fmt3v126detail6equal2EPKcS3_:
 1210|  1.04k|inline auto equal2(const char* lhs, const char* rhs) -> bool {
 1211|  1.04k|  return memcmp(lhs, rhs, 2) == 0;
 1212|  1.04k|}
_ZN3fmt3v126detail7umul128Emm:
 1442|  1.91k|FMT_INLINE auto umul128(uint64_t x, uint64_t y) noexcept -> uint128 {
 1443|  1.91k|#if FMT_USE_INT128
 1444|  1.91k|  auto p = static_cast<native_uint128>(x) * static_cast<native_uint128>(y);
 1445|  1.91k|  return {static_cast<uint64_t>(p >> 64), static_cast<uint64_t>(p)};
 1446|       |#elif defined(_MSC_VER) && defined(_M_AMD64)
 1447|       |  auto hi = uint64_t();
 1448|       |  auto lo = _umul128(x, y, &hi);
 1449|       |  return {hi, lo};
 1450|       |#else
 1451|       |  const uint64_t mask = static_cast<uint64_t>(max_value<uint32_t>());
 1452|       |
 1453|       |  uint64_t a = x >> 32;
 1454|       |  uint64_t b = x & mask;
 1455|       |  uint64_t c = y >> 32;
 1456|       |  uint64_t d = y & mask;
 1457|       |
 1458|       |  uint64_t ac = a * c;
 1459|       |  uint64_t bc = b * c;
 1460|       |  uint64_t ad = a * d;
 1461|       |  uint64_t bd = b * d;
 1462|       |
 1463|       |  uint64_t intermediate = (bd >> 32) + (ad & mask) + (bc & mask);
 1464|       |
 1465|       |  return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32),
 1466|       |          (intermediate << 32) + (bd & mask)};
 1467|       |#endif
 1468|  1.91k|}
_ZN3fmt3v126detail9dragonbox16floor_log10_pow2Ei:
 1473|  1.75k|inline auto floor_log10_pow2(int e) noexcept -> int {
 1474|  1.75k|  FMT_ASSERT(e <= 2620 && e >= -2620, "too large exponent");
  ------------------
  |  |  402|  3.50k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:7): [True: 1.75k, False: 0]
  |  |  |  Branch (402:7): [True: 1.75k, False: 0]
  |  |  ------------------
  |  |  403|  1.75k|         ? (void)0                                                          \
  |  |  404|  1.75k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1475|  1.75k|  static_assert((-1 >> 1) == -1, "right shift is not arithmetic");
 1476|  1.75k|  return (e * 315653) >> 20;
 1477|  1.75k|}
_ZN3fmt3v126detail9dragonbox16floor_log2_pow10Ei:
 1479|  1.89k|inline auto floor_log2_pow10(int e) noexcept -> int {
 1480|  1.89k|  FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent");
  ------------------
  |  |  402|  3.79k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:7): [True: 1.89k, False: 0]
  |  |  |  Branch (402:7): [True: 1.89k, False: 0]
  |  |  ------------------
  |  |  403|  1.89k|         ? (void)0                                                          \
  |  |  404|  1.89k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1481|  1.89k|  return (e * 1741647) >> 19;
 1482|  1.89k|}
_ZN3fmt3v126detail9dragonbox15umul128_upper64Emm:
 1485|  2.55k|inline auto umul128_upper64(uint64_t x, uint64_t y) noexcept -> uint64_t {
 1486|  2.55k|#if FMT_USE_INT128
 1487|  2.55k|  auto p = static_cast<native_uint128>(x) * static_cast<native_uint128>(y);
 1488|  2.55k|  return static_cast<uint64_t>(p >> 64);
 1489|       |#elif defined(_MSC_VER) && defined(_M_AMD64)
 1490|       |  return __umulh(x, y);
 1491|       |#else
 1492|       |  return umul128(x, y).high();
 1493|       |#endif
 1494|  2.55k|}
_ZN3fmt3v126detail9dragonbox16umul192_upper128EmNS1_7uint128E:
 1498|  1.75k|inline auto umul192_upper128(uint64_t x, uint128 y) noexcept -> uint128 {
 1499|  1.75k|  uint128 r = umul128(x, y.high());
 1500|  1.75k|  r += umul128_upper64(x, y.low());
 1501|  1.75k|  return r;
 1502|  1.75k|}
_ZN3fmt3v126detail16compute_exp_sizeEi:
 1585|    503|FMT_CONSTEXPR inline auto compute_exp_size(int exp) -> int {
 1586|    503|  auto prefix_size = 2;  // sign + 'e'
 1587|    503|  auto abs_exp = exp >= 0 ? exp : -exp;
  ------------------
  |  Branch (1587:18): [True: 167, False: 336]
  ------------------
 1588|    503|  if (abs_exp < 100) return prefix_size + 2;
  ------------------
  |  Branch (1588:7): [True: 134, False: 369]
  ------------------
 1589|    369|  return prefix_size + (abs_exp >= 1000 ? 4 : 3);
  ------------------
  |  Branch (1589:25): [True: 0, False: 369]
  ------------------
 1590|    503|}
_ZN3fmt3v126detail20get_significand_sizeERKNS1_14big_decimal_fpE:
 2426|    950|constexpr auto get_significand_size(const big_decimal_fp& f) -> int {
 2427|    950|  return f.significand_size;
 2428|    950|}
_ZN3fmt3v126detail9use_fixedEii:
 2532|  1.90k|constexpr auto use_fixed(int exp, int exp_upper) -> bool {
 2533|  1.90k|  return exp >= -4 && exp < exp_upper;
  ------------------
  |  Branch (2533:10): [True: 1.22k, False: 672]
  |  Branch (2533:23): [True: 847, False: 381]
  ------------------
 2534|  1.90k|}
_ZN3fmt3v126detail13format_dragonENS1_8basic_fpIoEEjiRNS1_6bufferIcEERi:
 2968|    948|                                          buffer<char>& buf, int& exp10) {
 2969|    948|  bigint numerator;    // 2 * R in (FPP)^2.
 2970|    948|  bigint denominator;  // 2 * S in (FPP)^2.
 2971|       |  // lower and upper are differences between value and corresponding boundaries.
 2972|    948|  bigint lower;             // (M^- in (FPP)^2).
 2973|    948|  bigint upper_store;       // upper's value if different from lower.
 2974|    948|  bigint* upper = nullptr;  // (M^+ in (FPP)^2).
 2975|       |  // Shift numerator and denominator by an extra bit or two (if lower boundary
 2976|       |  // is closer) to make lower and upper integers. This eliminates multiplication
 2977|       |  // by 2 during later computations.
 2978|    948|  bool is_predecessor_closer = (flags & dragon::predecessor_closer) != 0;
 2979|    948|  int shift = is_predecessor_closer ? 2 : 1;
  ------------------
  |  Branch (2979:15): [True: 144, False: 804]
  ------------------
 2980|    948|  if (value.e >= 0) {
  ------------------
  |  Branch (2980:7): [True: 228, False: 720]
  ------------------
 2981|    228|    numerator = value.f;
 2982|    228|    numerator <<= value.e + shift;
 2983|    228|    lower = 1;
 2984|    228|    lower <<= value.e;
 2985|    228|    if (is_predecessor_closer) {
  ------------------
  |  Branch (2985:9): [True: 55, False: 173]
  ------------------
 2986|     55|      upper_store = 1;
 2987|     55|      upper_store <<= value.e + 1;
 2988|     55|      upper = &upper_store;
 2989|     55|    }
 2990|    228|    denominator.assign_pow10(exp10);
 2991|    228|    denominator <<= shift;
 2992|    720|  } else if (exp10 < 0) {
  ------------------
  |  Branch (2992:14): [True: 402, False: 318]
  ------------------
 2993|    402|    numerator.assign_pow10(-exp10);
 2994|    402|    lower.assign(numerator);
 2995|    402|    if (is_predecessor_closer) {
  ------------------
  |  Branch (2995:9): [True: 59, False: 343]
  ------------------
 2996|     59|      upper_store.assign(numerator);
 2997|     59|      upper_store <<= 1;
 2998|     59|      upper = &upper_store;
 2999|     59|    }
 3000|    402|    numerator *= value.f;
 3001|    402|    numerator <<= shift;
 3002|    402|    denominator = 1;
 3003|    402|    denominator <<= shift - value.e;
 3004|    402|  } else {
 3005|    318|    numerator = value.f;
 3006|    318|    numerator <<= shift;
 3007|    318|    denominator.assign_pow10(exp10);
 3008|    318|    denominator <<= shift - value.e;
 3009|    318|    lower = 1;
 3010|    318|    if (is_predecessor_closer) {
  ------------------
  |  Branch (3010:9): [True: 30, False: 288]
  ------------------
 3011|     30|      upper_store = 1ULL << 1;
 3012|     30|      upper = &upper_store;
 3013|     30|    }
 3014|    318|  }
 3015|    948|  int even = static_cast<int>((value.f & 1) == 0);
 3016|    948|  if (!upper) upper = &lower;
  ------------------
  |  Branch (3016:7): [True: 804, False: 144]
  ------------------
 3017|    948|  bool shortest = num_digits < 0;
 3018|    948|  if ((flags & dragon::fixup) != 0) {
  ------------------
  |  Branch (3018:7): [True: 0, False: 948]
  ------------------
 3019|      0|    if (add_compare(numerator, *upper, denominator) + even <= 0) {
  ------------------
  |  Branch (3019:9): [True: 0, False: 0]
  ------------------
 3020|      0|      --exp10;
 3021|      0|      numerator *= 10;
 3022|      0|      if (num_digits < 0) {
  ------------------
  |  Branch (3022:11): [True: 0, False: 0]
  ------------------
 3023|      0|        lower *= 10;
 3024|      0|        if (upper != &lower) *upper *= 10;
  ------------------
  |  Branch (3024:13): [True: 0, False: 0]
  ------------------
 3025|      0|      }
 3026|      0|    }
 3027|      0|    if ((flags & dragon::fixed) != 0) adjust_precision(num_digits, exp10 + 1);
  ------------------
  |  Branch (3027:9): [True: 0, False: 0]
  ------------------
 3028|      0|  }
 3029|       |  // Invariant: value == (numerator / denominator) * pow(10, exp10).
 3030|    948|  if (shortest) {
  ------------------
  |  Branch (3030:7): [True: 0, False: 948]
  ------------------
 3031|       |    // Generate the shortest representation.
 3032|      0|    num_digits = 0;
 3033|      0|    char* data = buf.data();
 3034|      0|    for (;;) {
 3035|      0|      int digit = numerator.divmod_assign(denominator);
 3036|      0|      bool low = compare(numerator, lower) - even < 0;  // numerator <[=] lower.
 3037|       |      // numerator + upper >[=] pow10:
 3038|      0|      bool high = add_compare(numerator, *upper, denominator) + even > 0;
 3039|      0|      data[num_digits++] = static_cast<char>('0' + digit);
 3040|      0|      if (low || high) {
  ------------------
  |  Branch (3040:11): [True: 0, False: 0]
  |  Branch (3040:18): [True: 0, False: 0]
  ------------------
 3041|      0|        if (!low) {
  ------------------
  |  Branch (3041:13): [True: 0, False: 0]
  ------------------
 3042|      0|          ++data[num_digits - 1];
 3043|      0|        } else if (high) {
  ------------------
  |  Branch (3043:20): [True: 0, False: 0]
  ------------------
 3044|      0|          int result = add_compare(numerator, numerator, denominator);
 3045|       |          // Round half to even.
 3046|      0|          if (result > 0 || (result == 0 && (digit % 2) != 0))
  ------------------
  |  Branch (3046:15): [True: 0, False: 0]
  |  Branch (3046:30): [True: 0, False: 0]
  |  Branch (3046:45): [True: 0, False: 0]
  ------------------
 3047|      0|            ++data[num_digits - 1];
 3048|      0|        }
 3049|      0|        buf.try_resize(to_unsigned(num_digits));
 3050|      0|        exp10 -= num_digits - 1;
 3051|      0|        return;
 3052|      0|      }
 3053|      0|      numerator *= 10;
 3054|      0|      lower *= 10;
 3055|      0|      if (upper != &lower) *upper *= 10;
  ------------------
  |  Branch (3055:11): [True: 0, False: 0]
  ------------------
 3056|      0|    }
 3057|      0|  }
 3058|       |  // Generate the given number of digits.
 3059|    948|  exp10 -= num_digits - 1;
 3060|    948|  if (num_digits <= 0) {
  ------------------
  |  Branch (3060:7): [True: 0, False: 948]
  ------------------
 3061|      0|    auto digit = '0';
 3062|      0|    if (num_digits == 0) {
  ------------------
  |  Branch (3062:9): [True: 0, False: 0]
  ------------------
 3063|      0|      denominator *= 10;
 3064|      0|      digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0';
  ------------------
  |  Branch (3064:15): [True: 0, False: 0]
  ------------------
 3065|      0|    }
 3066|      0|    buf.push_back(digit);
 3067|      0|    return;
 3068|      0|  }
 3069|    948|  buf.try_resize(to_unsigned(num_digits));
 3070|  47.4k|  for (int i = 0; i < num_digits - 1; ++i) {
  ------------------
  |  Branch (3070:19): [True: 46.4k, False: 948]
  ------------------
 3071|  46.4k|    int digit = numerator.divmod_assign(denominator);
 3072|  46.4k|    buf[i] = static_cast<char>('0' + digit);
 3073|  46.4k|    numerator *= 10;
 3074|  46.4k|  }
 3075|    948|  int digit = numerator.divmod_assign(denominator);
 3076|    948|  auto result = add_compare(numerator, numerator, denominator);
 3077|    948|  if (result > 0 || (result == 0 && (digit % 2) != 0)) {
  ------------------
  |  Branch (3077:7): [True: 261, False: 687]
  |  Branch (3077:22): [True: 14, False: 673]
  |  Branch (3077:37): [True: 10, False: 4]
  ------------------
 3078|    271|    if (digit == 9) {
  ------------------
  |  Branch (3078:9): [True: 34, False: 237]
  ------------------
 3079|     34|      const auto overflow = '0' + 10;
 3080|     34|      buf[num_digits - 1] = overflow;
 3081|       |      // Propagate the carry.
 3082|    106|      for (int i = num_digits - 1; i > 0 && buf[i] == overflow; --i) {
  ------------------
  |  Branch (3082:36): [True: 106, False: 0]
  |  Branch (3082:45): [True: 72, False: 34]
  ------------------
 3083|     72|        buf[i] = '0';
 3084|     72|        ++buf[i - 1];
 3085|     72|      }
 3086|     34|      if (buf[0] == overflow) {
  ------------------
  |  Branch (3086:11): [True: 0, False: 34]
  ------------------
 3087|      0|        buf[0] = '1';
 3088|      0|        if ((flags & dragon::fixed) != 0)
  ------------------
  |  Branch (3088:13): [True: 0, False: 0]
  ------------------
 3089|      0|          buf.push_back('0');
 3090|      0|        else
 3091|      0|          ++exp10;
 3092|      0|      }
 3093|     34|      return;
 3094|     34|    }
 3095|    237|    ++digit;
 3096|    237|  }
 3097|    914|  buf[num_digits - 1] = static_cast<char>('0' + digit);
 3098|    914|}
_ZN3fmt3v1219basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEE10deallocateEv:
  789|  8.03k|  FMT_CONSTEXPR20 void deallocate() {
  790|  8.03k|    T* data = this->data();
  791|  8.03k|    if (data != store_) alloc_.deallocate(data, this->capacity());
  ------------------
  |  Branch (791:9): [True: 0, False: 8.03k]
  ------------------
  792|  8.03k|  }
_ZN3fmt3v1219basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEE4moveERS5_:
  853|  4.24k|  FMT_CONSTEXPR20 void move(basic_memory_buffer& other) {
  854|  4.24k|    T* data = other.data();
  855|  4.24k|    size_t size = other.size(), capacity = other.capacity();
  856|  4.24k|    if (!move_alloc(other)) return;
  ------------------
  |  Branch (856:9): [True: 0, False: 4.24k]
  ------------------
  857|  4.24k|    if (data == other.store_) {
  ------------------
  |  Branch (857:9): [True: 4.24k, False: 0]
  ------------------
  858|  4.24k|      this->set(store_, capacity);
  859|  4.24k|      detail::copy<T>(other.store_, other.store_ + size, store_);
  860|  4.24k|    } 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.24k|    this->resize(size);
  868|  4.24k|  }
_ZN3fmt3v126detaileqENS1_9allocatorIjEES3_:
  742|  4.24k|  constexpr friend auto operator==(allocator, allocator) noexcept -> bool {
  743|  4.24k|    return true;  // All instances of this allocator are equivalent.
  744|  4.24k|  }
_ZN3fmt3v1219basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEE10move_allocIS4_TnNSt3__19enable_ifIXntsr3std16allocator_traitsIT_E38propagate_on_container_move_assignmentE5valueEiE4typeELi0EEEbRS5_:
  842|  4.24k|  FMT_CONSTEXPR20 auto move_alloc(basic_memory_buffer& other) -> bool {
  843|  4.24k|    T* data = other.data();
  844|  4.24k|    if (alloc_ == other.alloc_ || data == other.store_) return true;
  ------------------
  |  Branch (844:9): [True: 4.24k, 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.24k|  }
_ZN3fmt3v126detail10to_pointerIcEEPT_NS0_14basic_appenderIS3_EEm:
  514|    772|FMT_CONSTEXPR20 auto to_pointer(basic_appender<T> it, size_t n) -> T* {
  515|    772|  buffer<T>& buf = get_container(it);
  516|    772|  buf.try_reserve(buf.size() + n);
  517|    772|  auto size = buf.size();
  518|    772|  if (buf.capacity() < size + n) return nullptr;
  ------------------
  |  Branch (518:7): [True: 0, False: 772]
  ------------------
  519|    772|  buf.try_resize(size + n);
  520|    772|  return buf.data() + size;
  521|    772|}
_ZN3fmt3v126detail17do_format_decimalIcmEEPT_S4_T0_i:
 1240|    944|    -> Char* {
 1241|    944|  FMT_ASSERT(size >= count_digits(value), "invalid digit count");
  ------------------
  |  |  402|    944|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 944, False: 0]
  |  |  ------------------
  |  |  403|    944|         ? (void)0                                                          \
  |  |  404|    944|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1242|    944|#if FMT_USE_INT128
 1243|       |  // Avoid slow 128-bit division by formatting 64-bit chunks of 19 digits each.
 1244|    944|  if (!is_constant_evaluated() && num_bits<UInt>() == 128) {
  ------------------
  |  Branch (1244:7): [True: 0, Folded]
  |  Branch (1244:35): [Folded, False: 0]
  ------------------
 1245|      0|    const uint64_t pow10_19 = 10000000000000000000ULL;
 1246|      0|    auto v = static_cast<native_uint128>(value);
 1247|      0|    unsigned pos = to_unsigned(size);
 1248|      0|    while ((v >> 64) != 0) {
  ------------------
  |  Branch (1248:12): [True: 0, False: 0]
  ------------------
 1249|      0|      auto chunk = static_cast<uint64_t>(v % pow10_19);
 1250|      0|      v /= pow10_19;
 1251|      0|      pos -= 19;
 1252|      0|      fill_n(out + pos, 19, Char('0'));
 1253|      0|      do_format_decimal(out + pos, chunk, 19);
 1254|      0|    }
 1255|      0|    auto top = static_cast<uint64_t>(v);
 1256|      0|    int top_digits = count_digits(top);
 1257|      0|    pos -= to_unsigned(top_digits);
 1258|      0|    do_format_decimal(out + pos, top, top_digits);
 1259|      0|    return out + pos;
 1260|      0|  }
 1261|    944|#endif  // FMT_USE_INT128
 1262|    944|  unsigned n = to_unsigned(size);
 1263|  6.20k|  while (value >= 100) {
  ------------------
  |  Branch (1263:10): [True: 5.25k, False: 944]
  ------------------
 1264|  5.25k|    n -= 2;
 1265|  5.25k|    if (!is_constant_evaluated() && num_bits<UInt>() == 32) {
  ------------------
  |  Branch (1265:9): [True: 0, Folded]
  |  Branch (1265:37): [Folded, False: 0]
  ------------------
 1266|      0|      auto p = value * static_cast<uint64_t>((1ull << 39) / 100 + 1);
 1267|      0|      write2digits_i(out + n, p >> (39 - 7) & ((1 << 7) - 1));
 1268|      0|      value = static_cast<UInt>(p >> 39) +
 1269|      0|              (static_cast<UInt>(value >= (100u << 25)) << 25);
 1270|  5.25k|    } else {
 1271|       |      // Integer division is slow so do it for a group of two digits instead
 1272|       |      // of for every digit. The idea comes from the talk by Alexandrescu
 1273|       |      // "Three Optimization Tips for C++". See speed-test for a comparison.
 1274|  5.25k|      write2digits(out + n, static_cast<unsigned>(value % 100));
 1275|  5.25k|      value /= 100;
 1276|  5.25k|    }
 1277|  5.25k|  }
 1278|    944|  if (value >= 10) {
  ------------------
  |  Branch (1278:7): [True: 535, False: 409]
  ------------------
 1279|    535|    n -= 2;
 1280|    535|    write2digits(out + n, static_cast<unsigned>(value));
 1281|    535|  } else {
 1282|    409|    out[--n] = static_cast<Char>('0' + value);
 1283|    409|  }
 1284|    944|  return out + n;
 1285|    944|}
_ZN3fmt3v126detail12write2digitsIcEEvPT_m:
 1216|  6.92k|FMT_CONSTEXPR20 FMT_INLINE void write2digits(Char* out, size_t value) {
 1217|  6.92k|  if (!is_constant_evaluated() && std::is_same<Char, char>::value &&
  ------------------
  |  Branch (1217:7): [True: 0, Folded]
  |  Branch (1217:35): [True: 0, Folded]
  ------------------
 1218|  6.92k|      !FMT_OPTIMIZE_SIZE) {
  ------------------
  |  |  303|      0|#  define FMT_OPTIMIZE_SIZE 0
  ------------------
  |  Branch (1218:7): [True: 0, Folded]
  ------------------
 1219|  6.92k|    memcpy(out, digits2(value), 2);
 1220|  6.92k|    return;
 1221|  6.92k|  }
 1222|      0|  *out++ = static_cast<Char>('0' + value / 10);
 1223|      0|  *out = static_cast<Char>('0' + value % 10);
 1224|      0|}
_ZN3fmt3v126detail14format_decimalIcmEEPT_S4_T0_i:
 1289|    722|                                             int num_digits) -> Char* {
 1290|    722|  do_format_decimal(out, value, num_digits);
 1291|    722|  return out + num_digits;
 1292|    722|}
_ZN3fmt3v126detail14format_decimalIcmNS0_14basic_appenderIcEETnNSt3__19enable_ifIXntsr3std10is_pointerINS5_9remove_cvINS5_16remove_referenceIT1_E4typeEE4typeEEE5valueEiE4typeELi0EEES9_S9_T0_i:
 1297|    222|    -> OutputIt {
 1298|    222|  if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
  ------------------
  |  Branch (1298:12): [True: 222, False: 0]
  ------------------
 1299|    222|    do_format_decimal(ptr, value, num_digits);
 1300|    222|    return out;
 1301|    222|  }
 1302|       |  // Buffer is large enough to hold all digits (digits10 + 1).
 1303|      0|  char buffer[digits10<UInt>() + 1];
 1304|      0|  if (is_constant_evaluated()) fill_n(buffer, sizeof(buffer), '\0');
  ------------------
  |  Branch (1304:7): [Folded, False: 0]
  ------------------
 1305|      0|  do_format_decimal(buffer, value, num_digits);
 1306|      0|  return copy_noinline<Char>(buffer, buffer + num_digits, out);
 1307|    222|}
_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:
 2402|    190|                                     format_specs specs, sign s) -> OutputIt {
 2403|    190|  auto str =
 2404|    190|      isnan ? (specs.upper() ? "NAN" : "nan") : (specs.upper() ? "INF" : "inf");
  ------------------
  |  Branch (2404:7): [True: 186, False: 4]
  |  Branch (2404:16): [True: 0, False: 186]
  |  Branch (2404:50): [True: 0, False: 4]
  ------------------
 2405|    190|  constexpr size_t str_size = 3;
 2406|    190|  auto size = str_size + (s != sign::none ? 1 : 0);
  ------------------
  |  Branch (2406:27): [True: 176, False: 14]
  ------------------
 2407|       |  // Replace '0'-padding with space for non-finite values.
 2408|    190|  const bool is_zero_fill =
 2409|    190|      specs.fill_size() == 1 && specs.fill_unit<Char>() == '0';
  ------------------
  |  Branch (2409:7): [True: 190, False: 0]
  |  Branch (2409:33): [True: 0, False: 190]
  ------------------
 2410|    190|  if (is_zero_fill) specs.set_fill(' ');
  ------------------
  |  Branch (2410:7): [True: 0, False: 190]
  ------------------
 2411|    190|  return write_padded<Char>(out, specs, size,
 2412|    190|                            [=](reserve_iterator<OutputIt> it) {
 2413|    190|                              if (s != sign::none)
 2414|    190|                                *it++ = detail::getsign<Char>(s);
 2415|    190|                              return copy<Char>(str, str + str_size, it);
 2416|    190|                            });
 2417|    190|}
_ZN3fmt3v126detail12write_paddedIcLNS0_5alignE1ENS0_14basic_appenderIcEEZNS1_15write_nonfiniteIcS5_EET0_S7_bNS0_12format_specsENS0_4signEEUlS5_E_EET1_SB_RKS8_mOT2_:
 1764|    190|                            size_t size, F&& f) -> OutputIt {
 1765|    190|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1766|    190|}
_ZN3fmt3v126detail12write_paddedIcLNS0_5alignE1ENS0_14basic_appenderIcEERZNS1_15write_nonfiniteIcS5_EET0_S7_bNS0_12format_specsENS0_4signEEUlS5_E_EET1_SC_RKS8_mmOT2_:
 1743|    190|                                size_t size, size_t width, F&& f) -> OutputIt {
 1744|    190|  static_assert(default_align == align::left || default_align == align::right,
 1745|    190|                "");
 1746|    190|  unsigned spec_width = to_unsigned(specs.width);
 1747|    190|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1747:20): [True: 0, False: 190]
  ------------------
 1748|       |  // Shifts are encoded as string literals because static constexpr is not
 1749|       |  // supported in constexpr functions.
 1750|    190|  auto* shifts =
 1751|    190|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1751:7): [True: 190, Folded]
  ------------------
 1752|    190|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1753|    190|  size_t right_padding = padding - left_padding;
 1754|    190|  auto it = reserve(out, size + padding * specs.fill_size());
 1755|    190|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1755:7): [True: 0, False: 190]
  ------------------
 1756|    190|  it = f(it);
 1757|    190|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1757:7): [True: 0, False: 190]
  ------------------
 1758|    190|  return base_iterator(out, it);
 1759|    190|}
_ZZN3fmt3v126detail15write_nonfiniteIcNS0_14basic_appenderIcEEEET0_S5_bNS0_12format_specsENS0_4signEENKUlS4_E_clES4_:
 2412|    190|                            [=](reserve_iterator<OutputIt> it) {
 2413|    190|                              if (s != sign::none)
  ------------------
  |  Branch (2413:35): [True: 176, False: 14]
  ------------------
 2414|    176|                                *it++ = detail::getsign<Char>(s);
 2415|    190|                              return copy<Char>(str, str + str_size, it);
 2416|    190|                            });
_ZN3fmt3v126detail23fallback_digit_groupingIcEC2ENS0_10locale_refEb:
 2538|    334|  constexpr fallback_digit_grouping(locale_ref, bool) {}
_ZNK3fmt3v126detail23fallback_digit_groupingIcE16count_separatorsEi:
 2542|    334|  constexpr auto count_separators(int) const -> int { return 0; }
_ZNK3fmt3v126detail23fallback_digit_groupingIcE13has_separatorEv:
 2540|    334|  constexpr auto has_separator() const -> bool { return false; }
_ZN3fmt3v126detail6selectILb0EPcNS0_14basic_appenderIcEETnNSt3__19enable_ifIXntT_EiE4typeELi0EEET1_T0_SA_:
 1722|    550|auto select(T, F false_value) -> F {
 1723|    550|  return false_value;
 1724|    550|}
_ZN3fmt3v126detail14write_exponentIcNS0_14basic_appenderIcEEEET0_iS5_:
 1594|    503|FMT_CONSTEXPR auto write_exponent(int exp, OutputIt out) -> OutputIt {
 1595|    503|  FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range");
  ------------------
  |  |  402|  1.00k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:7): [True: 503, False: 0]
  |  |  |  Branch (402:7): [True: 503, False: 0]
  |  |  ------------------
  |  |  403|    503|         ? (void)0                                                          \
  |  |  404|    503|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1596|    503|  if (exp < 0) {
  ------------------
  |  Branch (1596:7): [True: 336, False: 167]
  ------------------
 1597|    336|    *out++ = static_cast<Char>('-');
 1598|    336|    exp = -exp;
 1599|    336|  } else {
 1600|    167|    *out++ = static_cast<Char>('+');
 1601|    167|  }
 1602|    503|  auto uexp = static_cast<uint32_t>(exp);
 1603|    503|  if (is_constant_evaluated()) {
  ------------------
  |  Branch (1603:7): [Folded, False: 503]
  ------------------
 1604|      0|    if (uexp < 10) *out++ = '0';
  ------------------
  |  Branch (1604:9): [True: 0, False: 0]
  ------------------
 1605|      0|    return format_decimal<Char>(out, uexp, count_digits(uexp));
 1606|      0|  }
 1607|    503|  if (uexp >= 100u) {
  ------------------
  |  Branch (1607:7): [True: 369, False: 134]
  ------------------
 1608|    369|    const char* top = digits2(uexp / 100);
 1609|    369|    if (uexp >= 1000u) *out++ = static_cast<Char>(top[0]);
  ------------------
  |  Branch (1609:9): [True: 0, False: 369]
  ------------------
 1610|    369|    *out++ = static_cast<Char>(top[1]);
 1611|    369|    uexp %= 100;
 1612|    369|  }
 1613|    503|  const char* d = digits2(uexp);
 1614|    503|  *out++ = static_cast<Char>(d[0]);
 1615|    503|  *out++ = static_cast<Char>(d[1]);
 1616|    503|  return out;
 1617|    503|}
_ZN3fmt3v126detail21default_arg_formatterIcEclIdTnNSt3__19enable_ifIXsr10is_builtinIT_EE5valueEiE4typeELi0EEEvS7_:
 3714|  1.04k|  void operator()(T value) {
 3715|  1.04k|    write<Char>(out, value);
 3716|  1.04k|  }
_ZN3fmt3v126detail5writeIcNS0_14basic_appenderIcEEdTnNSt3__19enable_ifIXsr13is_fast_floatIT1_EE5valueEiE4typeELi0EEET0_SA_S7_:
 3557|  1.04k|FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt {
 3558|  1.04k|  if (is_constant_evaluated()) return write<Char>(out, value, format_specs());
  ------------------
  |  Branch (3558:7): [Folded, False: 1.04k]
  ------------------
 3559|       |
 3560|  1.04k|  auto s = detail::signbit(value) ? sign::minus : sign::none;
  ------------------
  |  Branch (3560:12): [True: 476, False: 569]
  ------------------
 3561|  1.04k|  auto mask = exponent_mask<fast_float_t<T>>();
 3562|  1.04k|  if ((bit_cast<decltype(mask)>(value) & mask) == mask)
  ------------------
  |  Branch (3562:7): [True: 95, False: 950]
  ------------------
 3563|     95|    return write_nonfinite<Char>(out, std::isnan(value), {}, s);
 3564|       |
 3565|    950|  auto dec = dragonbox::to_decimal(static_cast<fast_float_t<T>>(value));
 3566|    950|  auto significand = dec.significand;
 3567|    950|  int significand_size = count_digits(significand);
 3568|    950|  int exponent = dec.exponent + significand_size - 1;
 3569|    950|  if (use_fixed(exponent, detail::exp_upper<T>())) {
  ------------------
  |  Branch (3569:7): [True: 400, False: 550]
  ------------------
 3570|    400|    return write_fixed<Char, fallback_digit_grouping<Char>>(
 3571|    400|        out, dec, significand_size, Char('.'), {}, s);
 3572|    400|  }
 3573|       |
 3574|       |  // Write value in the exponential format.
 3575|    550|  const char* prefix = "e+";
 3576|    550|  int abs_exponent = exponent;
 3577|    550|  if (exponent < 0) {
  ------------------
  |  Branch (3577:7): [True: 336, False: 214]
  ------------------
 3578|    336|    abs_exponent = -exponent;
 3579|    336|    prefix = "e-";
 3580|    336|  }
 3581|    550|  auto has_decimal_point = significand_size != 1;
 3582|    550|  size_t size = std::is_pointer<OutputIt>::value
  ------------------
  |  Branch (3582:17): [Folded, False: 550]
  ------------------
 3583|    550|                    ? 0u
 3584|    550|                    : to_unsigned((s != sign::none ? 1 : 0) + significand_size +
  ------------------
  |  Branch (3584:36): [True: 205, False: 345]
  ------------------
 3585|    550|                                  (has_decimal_point ? 1 : 0) +
  ------------------
  |  Branch (3585:36): [True: 544, False: 6]
  ------------------
 3586|    550|                                  (abs_exponent >= 100 ? 5 : 4));
  ------------------
  |  Branch (3586:36): [True: 369, False: 181]
  ------------------
 3587|    550|  if (auto ptr = to_pointer<Char>(out, size)) {
  ------------------
  |  Branch (3587:12): [True: 550, False: 0]
  ------------------
 3588|    550|    if (s != sign::none) *ptr++ = Char('-');
  ------------------
  |  Branch (3588:9): [True: 205, False: 345]
  ------------------
 3589|    550|    if (has_decimal_point) {
  ------------------
  |  Branch (3589:9): [True: 544, False: 6]
  ------------------
 3590|    544|      auto begin = ptr;
 3591|    544|      ptr = format_decimal<Char>(ptr, significand, significand_size + 1);
 3592|    544|      *begin = begin[1];
 3593|    544|      begin[1] = '.';
 3594|    544|    } else {
 3595|      6|      *ptr++ = static_cast<Char>('0' + significand);
 3596|      6|    }
 3597|    550|    if (std::is_same<Char, char>::value) {
  ------------------
  |  Branch (3597:9): [True: 550, Folded]
  ------------------
 3598|    550|      memcpy(ptr, prefix, 2);
 3599|    550|      ptr += 2;
 3600|    550|    } else {
 3601|      0|      *ptr++ = static_cast<Char>(prefix[0]);
 3602|      0|      *ptr++ = static_cast<Char>(prefix[1]);
 3603|      0|    }
 3604|    550|    if (abs_exponent >= 100) {
  ------------------
  |  Branch (3604:9): [True: 369, False: 181]
  ------------------
 3605|    369|      *ptr++ = static_cast<Char>('0' + abs_exponent / 100);
 3606|    369|      abs_exponent %= 100;
 3607|    369|    }
 3608|    550|    write2digits(ptr, static_cast<unsigned>(abs_exponent));
 3609|    550|    return select<std::is_pointer<OutputIt>::value>(ptr + 2, out);
 3610|    550|  }
 3611|      0|  auto it = reserve(out, size);
 3612|      0|  if (s != sign::none) *it++ = Char('-');
  ------------------
  |  Branch (3612:7): [True: 0, False: 0]
  ------------------
 3613|       |  // Insert a decimal point after the first digit and add an exponent.
 3614|      0|  it = write_significand(it, significand, significand_size, 1,
 3615|      0|                         has_decimal_point ? Char('.') : Char());
  ------------------
  |  Branch (3615:26): [True: 0, False: 0]
  ------------------
 3616|      0|  *it++ = Char('e');
 3617|      0|  it = write_exponent<Char>(exponent, it);
 3618|      0|  return base_iterator(out, it);
 3619|    550|}
_ZN3fmt3v126detail7signbitIdTnNSt3__19enable_ifIXsr17is_floating_pointIT_EE5valueEiE4typeELi0EEEbS5_:
 2696|  2.09k|FMT_INLINE FMT_CONSTEXPR auto signbit(T value) -> bool {
 2697|  2.09k|  if (is_constant_evaluated()) {
  ------------------
  |  Branch (2697:7): [Folded, False: 2.09k]
  ------------------
 2698|       |#ifdef __cpp_if_constexpr
 2699|       |    if constexpr (std::numeric_limits<double>::is_iec559) {
 2700|       |      auto bits = detail::bit_cast<uint64_t>(static_cast<double>(value));
 2701|       |      return (bits >> (num_bits<uint64_t>() - 1)) != 0;
 2702|       |    }
 2703|       |#endif
 2704|      0|  }
 2705|  2.09k|  return std::signbit(static_cast<double>(value));
 2706|  2.09k|}
_ZN3fmt3v126detail9exp_upperIdEEiv:
 2524|  1.90k|template <typename T> FMT_CONSTEVAL auto exp_upper() -> int {
 2525|  1.90k|  return std::numeric_limits<T>::digits10 != 0
  ------------------
  |  Branch (2525:10): [True: 1.90k, Folded]
  ------------------
 2526|  1.90k|             ? min_of(16, std::numeric_limits<T>::digits10 + 1)
 2527|  1.90k|             : 16;
 2528|  1.90k|}
_ZN3fmt3v126detail11write_fixedIcNS1_23fallback_digit_groupingIcEENS0_14basic_appenderIcEENS1_9dragonbox10decimal_fpIdEEEET1_SA_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refE:
 2555|    400|                                 locale_ref loc = {}) -> OutputIt {
 2556|    400|  using iterator = reserve_iterator<OutputIt>;
 2557|       |
 2558|    400|  int exp = f.exponent + significand_size;
 2559|    400|  long long size = significand_size + (s != sign::none ? 1 : 0);
  ------------------
  |  Branch (2559:40): [True: 183, False: 217]
  ------------------
 2560|    400|  if (f.exponent >= 0) {
  ------------------
  |  Branch (2560:7): [True: 156, False: 244]
  ------------------
 2561|       |    // 1234e5 -> 123400000[.0+]
 2562|    156|    size += f.exponent;
 2563|    156|    int num_zeros = specs.precision - exp;
 2564|    156|    abort_fuzzing_if(num_zeros > 5000);
 2565|    156|    if (specs.alt()) {
  ------------------
  |  Branch (2565:9): [True: 0, False: 156]
  ------------------
 2566|      0|      ++size;
 2567|      0|      if (num_zeros <= 0 && specs.type() != presentation_type::fixed)
  ------------------
  |  Branch (2567:11): [True: 0, False: 0]
  |  Branch (2567:29): [True: 0, False: 0]
  ------------------
 2568|      0|        num_zeros = 0;
 2569|      0|      if (num_zeros > 0) size += num_zeros;
  ------------------
  |  Branch (2569:11): [True: 0, False: 0]
  ------------------
 2570|      0|    }
 2571|    156|    auto grouping = Grouping(loc, specs.localized());
 2572|    156|    size += grouping.count_separators(exp);
 2573|    156|    return write_padded<Char, align::right>(
 2574|    156|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2575|    156|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2576|    156|          it = write_significand<Char>(it, f.significand, significand_size,
 2577|    156|                                       f.exponent, grouping);
 2578|    156|          if (!specs.alt()) return it;
 2579|    156|          *it++ = decimal_point;
 2580|    156|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
 2581|    156|        });
 2582|    156|  }
 2583|    244|  if (exp > 0) {
  ------------------
  |  Branch (2583:7): [True: 178, False: 66]
  ------------------
 2584|       |    // 1234e-2 -> 12.34[0+]
 2585|    178|    int num_zeros = specs.alt() ? specs.precision - significand_size : 0;
  ------------------
  |  Branch (2585:21): [True: 0, False: 178]
  ------------------
 2586|    178|    size += 1 + max_of(num_zeros, 0);
 2587|    178|    auto grouping = Grouping(loc, specs.localized());
 2588|    178|    size += grouping.count_separators(exp);
 2589|    178|    return write_padded<Char, align::right>(
 2590|    178|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2591|    178|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2592|    178|          it = write_significand(it, f.significand, significand_size, exp,
 2593|    178|                                 decimal_point, grouping);
 2594|    178|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
 2595|    178|        });
 2596|    178|  }
 2597|       |  // 1234e-6 -> 0.001234
 2598|     66|  int num_zeros = -exp;
 2599|     66|  if (significand_size == 0 && specs.precision >= 0 &&
  ------------------
  |  Branch (2599:7): [True: 0, False: 66]
  |  Branch (2599:32): [True: 0, False: 0]
  ------------------
 2600|      0|      specs.precision < num_zeros) {
  ------------------
  |  Branch (2600:7): [True: 0, False: 0]
  ------------------
 2601|      0|    num_zeros = specs.precision;
 2602|      0|  }
 2603|     66|  bool pointy = num_zeros != 0 || significand_size != 0 || specs.alt();
  ------------------
  |  Branch (2603:17): [True: 25, False: 41]
  |  Branch (2603:35): [True: 41, False: 0]
  |  Branch (2603:60): [True: 0, False: 0]
  ------------------
 2604|     66|  size += 1 + (pointy ? 1 : 0) + num_zeros;
  ------------------
  |  Branch (2604:16): [True: 66, False: 0]
  ------------------
 2605|     66|  return write_padded<Char, align::right>(
 2606|     66|      out, specs, static_cast<size_t>(size), [&](iterator it) {
 2607|     66|        if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2608|     66|        *it++ = Char('0');
 2609|     66|        if (!pointy) return it;
 2610|     66|        *it++ = decimal_point;
 2611|     66|        it = detail::fill_n(it, num_zeros, Char('0'));
 2612|     66|        return write_significand<Char>(it, f.significand, significand_size);
 2613|     66|      });
 2614|    244|}
_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_:
 1764|    156|                            size_t size, F&& f) -> OutputIt {
 1765|    156|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1766|    156|}
_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_:
 1743|    156|                                size_t size, size_t width, F&& f) -> OutputIt {
 1744|    156|  static_assert(default_align == align::left || default_align == align::right,
 1745|    156|                "");
 1746|    156|  unsigned spec_width = to_unsigned(specs.width);
 1747|    156|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1747:20): [True: 0, False: 156]
  ------------------
 1748|       |  // Shifts are encoded as string literals because static constexpr is not
 1749|       |  // supported in constexpr functions.
 1750|    156|  auto* shifts =
 1751|    156|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1751:7): [Folded, False: 156]
  ------------------
 1752|    156|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1753|    156|  size_t right_padding = padding - left_padding;
 1754|    156|  auto it = reserve(out, size + padding * specs.fill_size());
 1755|    156|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1755:7): [True: 0, False: 156]
  ------------------
 1756|    156|  it = f(it);
 1757|    156|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1757:7): [True: 0, False: 156]
  ------------------
 1758|    156|  return base_iterator(out, it);
 1759|    156|}
_ZZN3fmt3v126detail11write_fixedIcNS1_23fallback_digit_groupingIcEENS0_14basic_appenderIcEENS1_9dragonbox10decimal_fpIdEEEET1_SA_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEENKUlS6_E_clES6_:
 2574|    156|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2575|    156|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2575:15): [True: 74, False: 82]
  ------------------
 2576|    156|          it = write_significand<Char>(it, f.significand, significand_size,
 2577|    156|                                       f.exponent, grouping);
 2578|    156|          if (!specs.alt()) return it;
  ------------------
  |  Branch (2578:15): [True: 156, False: 0]
  ------------------
 2579|      0|          *it++ = decimal_point;
 2580|      0|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
  ------------------
  |  Branch (2580:18): [True: 0, False: 0]
  ------------------
 2581|    156|        });
_ZN3fmt3v126detail17write_significandIcNS0_14basic_appenderIcEEmNS1_23fallback_digit_groupingIcEEEET0_S7_T1_iiRKT2_:
 2447|    156|                                       const Grouping& grouping) -> OutputIt {
 2448|    156|  if (!grouping.has_separator()) {
  ------------------
  |  Branch (2448:7): [True: 156, False: 0]
  ------------------
 2449|    156|    out = write_significand<Char>(out, significand, significand_size);
 2450|    156|    return detail::fill_n(out, exponent, static_cast<Char>('0'));
 2451|    156|  }
 2452|      0|  auto buffer = memory_buffer();
 2453|      0|  write_significand<char>(appender(buffer), significand, significand_size);
 2454|      0|  detail::fill_n(appender(buffer), exponent, '0');
 2455|      0|  return grouping.apply(out, string_view(buffer.data(), buffer.size()));
 2456|    156|}
_ZN3fmt3v126detail17write_significandIcNS0_14basic_appenderIcEEmEET0_S5_T1_i:
 2441|    222|                              int significand_size) -> OutputIt {
 2442|    222|  return format_decimal<Char>(out, significand, significand_size);
 2443|    222|}
_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_:
 1764|    178|                            size_t size, F&& f) -> OutputIt {
 1765|    178|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1766|    178|}
_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_:
 1743|    178|                                size_t size, size_t width, F&& f) -> OutputIt {
 1744|    178|  static_assert(default_align == align::left || default_align == align::right,
 1745|    178|                "");
 1746|    178|  unsigned spec_width = to_unsigned(specs.width);
 1747|    178|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1747:20): [True: 0, False: 178]
  ------------------
 1748|       |  // Shifts are encoded as string literals because static constexpr is not
 1749|       |  // supported in constexpr functions.
 1750|    178|  auto* shifts =
 1751|    178|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1751:7): [Folded, False: 178]
  ------------------
 1752|    178|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1753|    178|  size_t right_padding = padding - left_padding;
 1754|    178|  auto it = reserve(out, size + padding * specs.fill_size());
 1755|    178|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1755:7): [True: 0, False: 178]
  ------------------
 1756|    178|  it = f(it);
 1757|    178|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1757:7): [True: 0, False: 178]
  ------------------
 1758|    178|  return base_iterator(out, it);
 1759|    178|}
_ZZN3fmt3v126detail11write_fixedIcNS1_23fallback_digit_groupingIcEENS0_14basic_appenderIcEENS1_9dragonbox10decimal_fpIdEEEET1_SA_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEENKUlS6_E0_clES6_:
 2590|    178|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2591|    178|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2591:15): [True: 75, False: 103]
  ------------------
 2592|    178|          it = write_significand(it, f.significand, significand_size, exp,
 2593|    178|                                 decimal_point, grouping);
 2594|    178|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
  ------------------
  |  Branch (2594:18): [True: 0, False: 178]
  ------------------
 2595|    178|        });
_ZN3fmt3v126detail17write_significandINS0_14basic_appenderIcEEcmNS1_23fallback_digit_groupingIcEEEET_S7_T1_iiT0_RKT2_:
 2508|    178|                                       const Grouping& grouping) -> OutputIt {
 2509|    178|  if (!grouping.has_separator()) {
  ------------------
  |  Branch (2509:7): [True: 178, False: 0]
  ------------------
 2510|    178|    return write_significand(out, significand, significand_size, integral_size,
 2511|    178|                             decimal_point);
 2512|    178|  }
 2513|      0|  auto buffer = basic_memory_buffer<Char>();
 2514|      0|  write_significand(basic_appender<Char>(buffer), significand, significand_size,
 2515|      0|                    integral_size, decimal_point);
 2516|      0|  grouping.apply(
 2517|      0|      out, basic_string_view<Char>(buffer.data(), to_unsigned(integral_size)));
 2518|      0|  return detail::copy_noinline<Char>(buffer.data() + integral_size,
 2519|      0|                                     buffer.end(), out);
 2520|    178|}
_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_:
 1764|     66|                            size_t size, F&& f) -> OutputIt {
 1765|     66|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1766|     66|}
_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_:
 1743|     66|                                size_t size, size_t width, F&& f) -> OutputIt {
 1744|     66|  static_assert(default_align == align::left || default_align == align::right,
 1745|     66|                "");
 1746|     66|  unsigned spec_width = to_unsigned(specs.width);
 1747|     66|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1747:20): [True: 0, False: 66]
  ------------------
 1748|       |  // Shifts are encoded as string literals because static constexpr is not
 1749|       |  // supported in constexpr functions.
 1750|     66|  auto* shifts =
 1751|     66|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1751:7): [Folded, False: 66]
  ------------------
 1752|     66|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1753|     66|  size_t right_padding = padding - left_padding;
 1754|     66|  auto it = reserve(out, size + padding * specs.fill_size());
 1755|     66|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1755:7): [True: 0, False: 66]
  ------------------
 1756|     66|  it = f(it);
 1757|     66|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1757:7): [True: 0, False: 66]
  ------------------
 1758|     66|  return base_iterator(out, it);
 1759|     66|}
_ZZN3fmt3v126detail11write_fixedIcNS1_23fallback_digit_groupingIcEENS0_14basic_appenderIcEENS1_9dragonbox10decimal_fpIdEEEET1_SA_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEENKUlS6_E1_clES6_:
 2606|     66|      out, specs, static_cast<size_t>(size), [&](iterator it) {
 2607|     66|        if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2607:13): [True: 34, False: 32]
  ------------------
 2608|     66|        *it++ = Char('0');
 2609|     66|        if (!pointy) return it;
  ------------------
  |  Branch (2609:13): [True: 0, False: 66]
  ------------------
 2610|     66|        *it++ = decimal_point;
 2611|     66|        it = detail::fill_n(it, num_zeros, Char('0'));
 2612|     66|        return write_significand<Char>(it, f.significand, significand_size);
 2613|     66|      });
_ZN3fmt3v126detail17write_significandINS0_14basic_appenderIcEEmcTnNSt3__19enable_ifIXntsr3std10is_pointerINS5_9remove_cvINS5_16remove_referenceIT_E4typeEE4typeEEE5valueEiE4typeELi0EEES9_S9_T0_iiT1_:
 2484|    178|                              Char decimal_point) -> OutputIt {
 2485|       |  // Buffer is large enough to hold digits (digits10 + 1) and a decimal point.
 2486|    178|  Char buffer[digits10<UInt>() + 2];
 2487|    178|  auto end = write_significand(buffer, significand, significand_size,
 2488|    178|                               integral_size, decimal_point);
 2489|    178|  return detail::copy_noinline<Char>(buffer, end, out);
 2490|    178|}
_ZN3fmt3v126detail17write_significandIcmTnNSt3__19enable_ifIXsr3std11is_integralIT0_EE5valueEiE4typeELi0EEEPT_S9_S5_iiS8_:
 2461|    178|                              int integral_size, Char decimal_point) -> Char* {
 2462|    178|  if (!decimal_point) return format_decimal(out, significand, significand_size);
  ------------------
  |  Branch (2462:7): [True: 0, False: 178]
  ------------------
 2463|    178|  out += significand_size + 1;
 2464|    178|  Char* end = out;
 2465|    178|  int floating_size = significand_size - integral_size;
 2466|    759|  for (int i = floating_size / 2; i > 0; --i) {
  ------------------
  |  Branch (2466:35): [True: 581, False: 178]
  ------------------
 2467|    581|    out -= 2;
 2468|    581|    write2digits(out, static_cast<size_t>(significand % 100));
 2469|    581|    significand /= 100;
 2470|    581|  }
 2471|    178|  if (floating_size % 2 != 0) {
  ------------------
  |  Branch (2471:7): [True: 104, False: 74]
  ------------------
 2472|    104|    *--out = static_cast<Char>('0' + significand % 10);
 2473|    104|    significand /= 10;
 2474|    104|  }
 2475|    178|  *--out = decimal_point;
 2476|    178|  format_decimal(out - integral_size, significand, integral_size);
 2477|    178|  return end;
 2478|    178|}
_ZN3fmt3v126detail8basic_fpIoEC2Ev:
 1627|    948|  constexpr basic_fp() : f(0), e(0) {}
_ZN3fmt3v1219basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEEC2ERKS4_:
  824|  3.79k|      : detail::buffer<T>(grow), alloc_(alloc) {
  825|  3.79k|    this->set(store_, SIZE);
  826|  3.79k|    if (detail::is_constant_evaluated()) detail::fill_n(store_, SIZE, T());
  ------------------
  |  Branch (826:9): [Folded, False: 3.79k]
  ------------------
  827|  3.79k|  }
_ZN3fmt3v1219basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEEC2EOS5_:
  874|  4.24k|      : detail::buffer<T>(grow) {
  875|  4.24k|    move(other);
  876|  4.24k|  }
_ZN3fmt3v1219basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEED2Ev:
  828|  8.03k|  FMT_CONSTEXPR20 ~basic_memory_buffer() { deallocate(); }
_ZN3fmt3v126detail11write_floatIcNS0_14basic_appenderIcEENS1_14big_decimal_fpEEET0_S6_RKT1_RKNS0_12format_specsENS0_4signEiNS0_10locale_refE:
 2659|    950|                                 int exp_upper, locale_ref loc) -> OutputIt {
 2660|    950|  if (is_constant_evaluated()) {
  ------------------
  |  Branch (2660:7): [Folded, False: 950]
  ------------------
 2661|      0|    return do_write_float<Char, fallback_digit_grouping<Char>>(out, f, specs, s,
 2662|      0|                                                               exp_upper, loc);
 2663|    950|  } else {
 2664|    950|    return do_write_float<Char, digit_grouping<Char>>(out, f, specs, s,
 2665|    950|                                                      exp_upper, loc);
 2666|    950|  }
 2667|    950|}
_ZN3fmt3v126detail14do_write_floatIcNS1_14digit_groupingIcEENS0_14basic_appenderIcEENS1_14big_decimal_fpEEET1_S8_RKT2_RKNS0_12format_specsENS0_4signEiNS0_10locale_refE:
 2620|    950|                                    int exp_upper, locale_ref loc) -> OutputIt {
 2621|    950|  Char point = specs.localized() ? detail::decimal_point<Char>(loc) : Char('.');
  ------------------
  |  Branch (2621:16): [True: 0, False: 950]
  ------------------
 2622|    950|  int significand_size = get_significand_size(f);
 2623|    950|  int exp = f.exponent + significand_size - 1;
 2624|    950|  if (specs.type() == presentation_type::fixed ||
  ------------------
  |  Branch (2624:7): [True: 0, False: 950]
  ------------------
 2625|    950|      (specs.type() != presentation_type::exp &&
  ------------------
  |  Branch (2625:8): [True: 950, False: 0]
  ------------------
 2626|    950|       use_fixed(exp, specs.precision > 0 ? specs.precision : exp_upper))) {
  ------------------
  |  Branch (2626:8): [True: 447, False: 503]
  |  Branch (2626:23): [True: 950, False: 0]
  ------------------
 2627|    447|    return write_fixed<Char, Grouping>(out, f, significand_size, point, specs,
 2628|    447|                                       s, loc);
 2629|    447|  }
 2630|       |
 2631|       |  // Write value in the exponential format.
 2632|    503|  int num_zeros = 0;
 2633|    503|  long long size = significand_size + (s != sign::none ? 1 : 0);
  ------------------
  |  Branch (2633:40): [True: 179, False: 324]
  ------------------
 2634|    503|  if (specs.alt()) {
  ------------------
  |  Branch (2634:7): [True: 0, False: 503]
  ------------------
 2635|      0|    num_zeros = max_of(specs.precision - significand_size, 0);
 2636|      0|    size += num_zeros;
 2637|    503|  } else if (significand_size == 1) {
  ------------------
  |  Branch (2637:14): [True: 0, False: 503]
  ------------------
 2638|      0|    point = Char();
 2639|      0|  }
 2640|    503|  size += (point ? 1 : 0) + compute_exp_size(exp);
  ------------------
  |  Branch (2640:12): [True: 503, False: 0]
  ------------------
 2641|    503|  char exp_char = specs.upper() ? 'E' : 'e';
  ------------------
  |  Branch (2641:19): [True: 0, False: 503]
  ------------------
 2642|    503|  auto write = [=](reserve_iterator<OutputIt> it) {
 2643|    503|    if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2644|       |    // Insert a decimal point after the first digit and add an exponent.
 2645|    503|    it = write_significand(it, f.significand, significand_size, 1, point);
 2646|    503|    if (num_zeros > 0) it = detail::fill_n(it, num_zeros, Char('0'));
 2647|    503|    *it++ = Char(exp_char);
 2648|    503|    return write_exponent<Char>(exp, it);
 2649|    503|  };
 2650|    503|  size_t usize = static_cast<size_t>(size);
 2651|    503|  return specs.width > 0
  ------------------
  |  Branch (2651:10): [True: 0, False: 503]
  ------------------
 2652|    503|             ? write_padded<Char, align::right>(out, specs, usize, write)
 2653|    503|             : base_iterator(out, write(reserve(out, usize)));
 2654|    950|}
_ZN3fmt3v126detail11write_fixedIcNS1_14digit_groupingIcEENS0_14basic_appenderIcEENS1_14big_decimal_fpEEET1_S8_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refE:
 2555|    447|                                 locale_ref loc = {}) -> OutputIt {
 2556|    447|  using iterator = reserve_iterator<OutputIt>;
 2557|       |
 2558|    447|  int exp = f.exponent + significand_size;
 2559|    447|  long long size = significand_size + (s != sign::none ? 1 : 0);
  ------------------
  |  Branch (2559:40): [True: 209, False: 238]
  ------------------
 2560|    447|  if (f.exponent >= 0) {
  ------------------
  |  Branch (2560:7): [True: 203, False: 244]
  ------------------
 2561|       |    // 1234e5 -> 123400000[.0+]
 2562|    203|    size += f.exponent;
 2563|    203|    int num_zeros = specs.precision - exp;
 2564|    203|    abort_fuzzing_if(num_zeros > 5000);
 2565|    203|    if (specs.alt()) {
  ------------------
  |  Branch (2565:9): [True: 0, False: 203]
  ------------------
 2566|      0|      ++size;
 2567|      0|      if (num_zeros <= 0 && specs.type() != presentation_type::fixed)
  ------------------
  |  Branch (2567:11): [True: 0, False: 0]
  |  Branch (2567:29): [True: 0, False: 0]
  ------------------
 2568|      0|        num_zeros = 0;
 2569|      0|      if (num_zeros > 0) size += num_zeros;
  ------------------
  |  Branch (2569:11): [True: 0, False: 0]
  ------------------
 2570|      0|    }
 2571|    203|    auto grouping = Grouping(loc, specs.localized());
 2572|    203|    size += grouping.count_separators(exp);
 2573|    203|    return write_padded<Char, align::right>(
 2574|    203|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2575|    203|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2576|    203|          it = write_significand<Char>(it, f.significand, significand_size,
 2577|    203|                                       f.exponent, grouping);
 2578|    203|          if (!specs.alt()) return it;
 2579|    203|          *it++ = decimal_point;
 2580|    203|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
 2581|    203|        });
 2582|    203|  }
 2583|    244|  if (exp > 0) {
  ------------------
  |  Branch (2583:7): [True: 178, False: 66]
  ------------------
 2584|       |    // 1234e-2 -> 12.34[0+]
 2585|    178|    int num_zeros = specs.alt() ? specs.precision - significand_size : 0;
  ------------------
  |  Branch (2585:21): [True: 0, False: 178]
  ------------------
 2586|    178|    size += 1 + max_of(num_zeros, 0);
 2587|    178|    auto grouping = Grouping(loc, specs.localized());
 2588|    178|    size += grouping.count_separators(exp);
 2589|    178|    return write_padded<Char, align::right>(
 2590|    178|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2591|    178|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2592|    178|          it = write_significand(it, f.significand, significand_size, exp,
 2593|    178|                                 decimal_point, grouping);
 2594|    178|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
 2595|    178|        });
 2596|    178|  }
 2597|       |  // 1234e-6 -> 0.001234
 2598|     66|  int num_zeros = -exp;
 2599|     66|  if (significand_size == 0 && specs.precision >= 0 &&
  ------------------
  |  Branch (2599:7): [True: 0, False: 66]
  |  Branch (2599:32): [True: 0, False: 0]
  ------------------
 2600|      0|      specs.precision < num_zeros) {
  ------------------
  |  Branch (2600:7): [True: 0, False: 0]
  ------------------
 2601|      0|    num_zeros = specs.precision;
 2602|      0|  }
 2603|     66|  bool pointy = num_zeros != 0 || significand_size != 0 || specs.alt();
  ------------------
  |  Branch (2603:17): [True: 25, False: 41]
  |  Branch (2603:35): [True: 41, False: 0]
  |  Branch (2603:60): [True: 0, False: 0]
  ------------------
 2604|     66|  size += 1 + (pointy ? 1 : 0) + num_zeros;
  ------------------
  |  Branch (2604:16): [True: 66, False: 0]
  ------------------
 2605|     66|  return write_padded<Char, align::right>(
 2606|     66|      out, specs, static_cast<size_t>(size), [&](iterator it) {
 2607|     66|        if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2608|     66|        *it++ = Char('0');
 2609|     66|        if (!pointy) return it;
 2610|     66|        *it++ = decimal_point;
 2611|     66|        it = detail::fill_n(it, num_zeros, Char('0'));
 2612|     66|        return write_significand<Char>(it, f.significand, significand_size);
 2613|     66|      });
 2614|    244|}
_ZN3fmt3v126detail14digit_groupingIcEC2ENS0_10locale_refEb:
 1945|    381|  explicit digit_grouping(locale_ref loc, bool localized = true) {
 1946|    381|    if (!localized) return;
  ------------------
  |  Branch (1946:9): [True: 381, False: 0]
  ------------------
 1947|      0|    auto sep = thousands_sep<Char>(loc);
 1948|      0|    grouping_ = std::move(sep.grouping);
 1949|      0|    if (sep.thousands_sep) thousands_sep_.assign(1, sep.thousands_sep);
  ------------------
  |  Branch (1949:9): [True: 0, False: 0]
  ------------------
 1950|      0|  }
_ZNK3fmt3v126detail14digit_groupingIcE16count_separatorsEi:
 1956|    381|  auto count_separators(int num_digits) const -> int {
 1957|    381|    int count = 0;
 1958|    381|    auto state = initial_state();
 1959|    381|    while (num_digits > next(state)) ++count;
  ------------------
  |  Branch (1959:12): [True: 0, False: 381]
  ------------------
 1960|    381|    return count;
 1961|    381|  }
_ZNK3fmt3v126detail14digit_groupingIcE13initial_stateEv:
 1932|    381|  auto initial_state() const -> next_state { return {grouping_.begin(), 0}; }
_ZNK3fmt3v126detail14digit_groupingIcE4nextERNS3_10next_stateE:
 1935|    381|  auto next(next_state& state) const -> int {
 1936|    381|    if (thousands_sep_.empty()) return max_value<int>();
  ------------------
  |  Branch (1936:9): [True: 381, False: 0]
  ------------------
 1937|      0|    if (state.group == grouping_.end()) return state.pos += grouping_.back();
  ------------------
  |  Branch (1937:9): [True: 0, False: 0]
  ------------------
 1938|      0|    if (*state.group <= 0 || *state.group == max_value<char>())
  ------------------
  |  Branch (1938:9): [True: 0, False: 0]
  |  Branch (1938:30): [True: 0, False: 0]
  ------------------
 1939|      0|      return max_value<int>();
 1940|      0|    state.pos += *state.group++;
 1941|      0|    return state.pos;
 1942|      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_:
 1764|    203|                            size_t size, F&& f) -> OutputIt {
 1765|    203|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1766|    203|}
_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_:
 1743|    203|                                size_t size, size_t width, F&& f) -> OutputIt {
 1744|    203|  static_assert(default_align == align::left || default_align == align::right,
 1745|    203|                "");
 1746|    203|  unsigned spec_width = to_unsigned(specs.width);
 1747|    203|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1747:20): [True: 0, False: 203]
  ------------------
 1748|       |  // Shifts are encoded as string literals because static constexpr is not
 1749|       |  // supported in constexpr functions.
 1750|    203|  auto* shifts =
 1751|    203|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1751:7): [Folded, False: 203]
  ------------------
 1752|    203|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1753|    203|  size_t right_padding = padding - left_padding;
 1754|    203|  auto it = reserve(out, size + padding * specs.fill_size());
 1755|    203|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1755:7): [True: 0, False: 203]
  ------------------
 1756|    203|  it = f(it);
 1757|    203|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1757:7): [True: 0, False: 203]
  ------------------
 1758|    203|  return base_iterator(out, it);
 1759|    203|}
_ZZN3fmt3v126detail11write_fixedIcNS1_14digit_groupingIcEENS0_14basic_appenderIcEENS1_14big_decimal_fpEEET1_S8_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEENKUlS6_E_clES6_:
 2574|    203|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2575|    203|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2575:15): [True: 100, False: 103]
  ------------------
 2576|    203|          it = write_significand<Char>(it, f.significand, significand_size,
 2577|    203|                                       f.exponent, grouping);
 2578|    203|          if (!specs.alt()) return it;
  ------------------
  |  Branch (2578:15): [True: 203, False: 0]
  ------------------
 2579|      0|          *it++ = decimal_point;
 2580|      0|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
  ------------------
  |  Branch (2580:18): [True: 0, False: 0]
  ------------------
 2581|    203|        });
_ZN3fmt3v126detail17write_significandIcNS0_14basic_appenderIcEEPKcNS1_14digit_groupingIcEEEET0_S9_T1_iiRKT2_:
 2447|    203|                                       const Grouping& grouping) -> OutputIt {
 2448|    203|  if (!grouping.has_separator()) {
  ------------------
  |  Branch (2448:7): [True: 203, False: 0]
  ------------------
 2449|    203|    out = write_significand<Char>(out, significand, significand_size);
 2450|    203|    return detail::fill_n(out, exponent, static_cast<Char>('0'));
 2451|    203|  }
 2452|      0|  auto buffer = memory_buffer();
 2453|      0|  write_significand<char>(appender(buffer), significand, significand_size);
 2454|      0|  detail::fill_n(appender(buffer), exponent, '0');
 2455|      0|  return grouping.apply(out, string_view(buffer.data(), buffer.size()));
 2456|    203|}
_ZNK3fmt3v126detail14digit_groupingIcE13has_separatorEv:
 1954|    381|  auto has_separator() const -> bool { return !thousands_sep_.empty(); }
_ZN3fmt3v126detail17write_significandIcNS0_14basic_appenderIcEEEET0_S5_PKci:
 2436|    269|                                 int significand_size) -> OutputIt {
 2437|    269|  return copy<Char>(significand, significand + significand_size, out);
 2438|    269|}
_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_:
 1764|    178|                            size_t size, F&& f) -> OutputIt {
 1765|    178|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1766|    178|}
_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_:
 1743|    178|                                size_t size, size_t width, F&& f) -> OutputIt {
 1744|    178|  static_assert(default_align == align::left || default_align == align::right,
 1745|    178|                "");
 1746|    178|  unsigned spec_width = to_unsigned(specs.width);
 1747|    178|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1747:20): [True: 0, False: 178]
  ------------------
 1748|       |  // Shifts are encoded as string literals because static constexpr is not
 1749|       |  // supported in constexpr functions.
 1750|    178|  auto* shifts =
 1751|    178|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1751:7): [Folded, False: 178]
  ------------------
 1752|    178|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1753|    178|  size_t right_padding = padding - left_padding;
 1754|    178|  auto it = reserve(out, size + padding * specs.fill_size());
 1755|    178|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1755:7): [True: 0, False: 178]
  ------------------
 1756|    178|  it = f(it);
 1757|    178|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1757:7): [True: 0, False: 178]
  ------------------
 1758|    178|  return base_iterator(out, it);
 1759|    178|}
_ZZN3fmt3v126detail11write_fixedIcNS1_14digit_groupingIcEENS0_14basic_appenderIcEENS1_14big_decimal_fpEEET1_S8_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEENKUlS6_E0_clES6_:
 2590|    178|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2591|    178|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2591:15): [True: 75, False: 103]
  ------------------
 2592|    178|          it = write_significand(it, f.significand, significand_size, exp,
 2593|    178|                                 decimal_point, grouping);
 2594|    178|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
  ------------------
  |  Branch (2594:18): [True: 0, False: 178]
  ------------------
 2595|    178|        });
_ZN3fmt3v126detail17write_significandINS0_14basic_appenderIcEEcPKcNS1_14digit_groupingIcEEEET_S9_T1_iiT0_RKT2_:
 2508|    178|                                       const Grouping& grouping) -> OutputIt {
 2509|    178|  if (!grouping.has_separator()) {
  ------------------
  |  Branch (2509:7): [True: 178, False: 0]
  ------------------
 2510|    178|    return write_significand(out, significand, significand_size, integral_size,
 2511|    178|                             decimal_point);
 2512|    178|  }
 2513|      0|  auto buffer = basic_memory_buffer<Char>();
 2514|      0|  write_significand(basic_appender<Char>(buffer), significand, significand_size,
 2515|      0|                    integral_size, decimal_point);
 2516|      0|  grouping.apply(
 2517|      0|      out, basic_string_view<Char>(buffer.data(), to_unsigned(integral_size)));
 2518|      0|  return detail::copy_noinline<Char>(buffer.data() + integral_size,
 2519|      0|                                     buffer.end(), out);
 2520|    178|}
_ZN3fmt3v126detail17write_significandINS0_14basic_appenderIcEEcEET_S5_PKciiT0_:
 2495|    681|                                     Char decimal_point) -> OutputIt {
 2496|    681|  out = detail::copy_noinline<Char>(significand, significand + integral_size,
 2497|    681|                                    out);
 2498|    681|  if (!decimal_point) return out;
  ------------------
  |  Branch (2498:7): [True: 0, False: 681]
  ------------------
 2499|    681|  *out++ = decimal_point;
 2500|    681|  return detail::copy_noinline<Char>(significand + integral_size,
 2501|    681|                                     significand + significand_size, out);
 2502|    681|}
_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_:
 1764|     66|                            size_t size, F&& f) -> OutputIt {
 1765|     66|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1766|     66|}
_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_:
 1743|     66|                                size_t size, size_t width, F&& f) -> OutputIt {
 1744|     66|  static_assert(default_align == align::left || default_align == align::right,
 1745|     66|                "");
 1746|     66|  unsigned spec_width = to_unsigned(specs.width);
 1747|     66|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1747:20): [True: 0, False: 66]
  ------------------
 1748|       |  // Shifts are encoded as string literals because static constexpr is not
 1749|       |  // supported in constexpr functions.
 1750|     66|  auto* shifts =
 1751|     66|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1751:7): [Folded, False: 66]
  ------------------
 1752|     66|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1753|     66|  size_t right_padding = padding - left_padding;
 1754|     66|  auto it = reserve(out, size + padding * specs.fill_size());
 1755|     66|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1755:7): [True: 0, False: 66]
  ------------------
 1756|     66|  it = f(it);
 1757|     66|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1757:7): [True: 0, False: 66]
  ------------------
 1758|     66|  return base_iterator(out, it);
 1759|     66|}
_ZZN3fmt3v126detail11write_fixedIcNS1_14digit_groupingIcEENS0_14basic_appenderIcEENS1_14big_decimal_fpEEET1_S8_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEENKUlS6_E1_clES6_:
 2606|     66|      out, specs, static_cast<size_t>(size), [&](iterator it) {
 2607|     66|        if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2607:13): [True: 34, False: 32]
  ------------------
 2608|     66|        *it++ = Char('0');
 2609|     66|        if (!pointy) return it;
  ------------------
  |  Branch (2609:13): [True: 0, False: 66]
  ------------------
 2610|     66|        *it++ = decimal_point;
 2611|     66|        it = detail::fill_n(it, num_zeros, Char('0'));
 2612|     66|        return write_significand<Char>(it, f.significand, significand_size);
 2613|     66|      });
_ZZN3fmt3v126detail14do_write_floatIcNS1_14digit_groupingIcEENS0_14basic_appenderIcEENS1_14big_decimal_fpEEET1_S8_RKT2_RKNS0_12format_specsENS0_4signEiNS0_10locale_refEENKUlS6_E_clES6_:
 2642|    503|  auto write = [=](reserve_iterator<OutputIt> it) {
 2643|    503|    if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2643:9): [True: 179, False: 324]
  ------------------
 2644|       |    // Insert a decimal point after the first digit and add an exponent.
 2645|    503|    it = write_significand(it, f.significand, significand_size, 1, point);
 2646|    503|    if (num_zeros > 0) it = detail::fill_n(it, num_zeros, Char('0'));
  ------------------
  |  Branch (2646:9): [True: 0, False: 503]
  ------------------
 2647|    503|    *it++ = Char(exp_char);
 2648|    503|    return write_exponent<Char>(exp, it);
 2649|    503|  };
_ZN3fmt3v126detail14format_handlerIcE7on_textEPKcS5_:
 3818|  2.09k|  void on_text(const Char* begin, const Char* end) {
 3819|  2.09k|    copy_noinline<Char>(begin, end, ctx.out());
 3820|  2.09k|  }
_ZN3fmt3v126detail14format_handlerIcE9on_arg_idEv:
 3822|  1.04k|  FMT_CONSTEXPR auto on_arg_id() -> int { return parse_ctx.next_arg_id(); }
_ZN3fmt3v126detail14format_handlerIcE15on_format_specsEiPKcS5_:
 3839|  1.04k|      -> const Char* {
 3840|  1.04k|    auto arg = ctx.arg(id);
 3841|  1.04k|    if (!arg) report_error("argument not found");
  ------------------
  |  Branch (3841:9): [True: 0, False: 1.04k]
  ------------------
 3842|       |    // Not using a visitor for custom types gives better codegen.
 3843|  1.04k|    if (arg.format_custom(begin, parse_ctx, ctx)) return parse_ctx.begin();
  ------------------
  |  Branch (3843:9): [True: 0, False: 1.04k]
  ------------------
 3844|       |
 3845|  1.04k|    auto specs = dynamic_format_specs<Char>();
 3846|  1.04k|    begin = parse_format_specs(begin, end, specs, parse_ctx, arg.type());
 3847|  1.04k|    if (specs.dynamic()) {
  ------------------
  |  Branch (3847:9): [True: 0, False: 1.04k]
  ------------------
 3848|      0|      handle_dynamic_spec(specs.dynamic_width(), specs.width, specs.width_ref,
 3849|      0|                          ctx);
 3850|      0|      handle_dynamic_spec(specs.dynamic_precision(), specs.precision,
 3851|      0|                          specs.precision_ref, ctx);
 3852|      0|    }
 3853|       |
 3854|  1.04k|    arg.visit(arg_formatter<Char>{ctx.out(), specs, ctx.locale()});
 3855|  1.04k|    return begin;
 3856|  1.04k|  }
_ZN3fmt3v126detail12format_floatIdEEiT_iRKNS0_12format_specsEbRNS1_6bufferIcEE:
 3202|    950|                                  buffer<char>& buf) -> int {
 3203|       |  // float is passed as double to reduce the number of instantiations.
 3204|    950|  static_assert(!std::is_same<Float, float>::value, "");
 3205|    950|  auto converted_value = convert_float(value);
 3206|       |
 3207|    950|  const bool fixed = specs.type() == presentation_type::fixed;
 3208|    950|  if (value == 0) {
  ------------------
  |  Branch (3208:7): [True: 2, False: 948]
  ------------------
 3209|      2|    if (precision <= 0 || !fixed) {
  ------------------
  |  Branch (3209:9): [True: 0, False: 2]
  |  Branch (3209:27): [True: 2, False: 0]
  ------------------
 3210|      2|      buf.push_back('0');
 3211|      2|      return 0;
 3212|      2|    }
 3213|      0|    buf.try_resize(to_unsigned(precision));
 3214|      0|    fill_n(buf.data(), precision, '0');
 3215|      0|    return -precision;
 3216|      2|  }
 3217|       |
 3218|    948|  int exp = 0;
 3219|    948|  bool use_dragon = true;
 3220|    948|  unsigned dragon_flags = 0;
 3221|    948|  if (!is_fast_float<Float>() || is_constant_evaluated()) {
  ------------------
  |  Branch (3221:7): [Folded, False: 0]
  |  Branch (3221:7): [Folded, False: 948]
  |  Branch (3221:34): [Folded, False: 0]
  ------------------
 3222|      0|    const auto inv_log2_10 = 0.3010299956639812;  // 1 / log2(10)
 3223|      0|    using info = dragonbox::float_info<decltype(converted_value)>;
 3224|      0|    const auto f = basic_fp<typename info::carrier_uint>(converted_value);
 3225|       |    // Compute exp, an approximate power of 10, such that
 3226|       |    //   10^(exp - 1) <= value < 10^exp or 10^exp <= value < 10^(exp + 1).
 3227|       |    // This is based on log10(value) == log2(value) / log2(10) and approximation
 3228|       |    // of log2(value) by e + num_fraction_bits idea from double-conversion.
 3229|      0|    auto e = (f.e + count_digits<1>(f.f) - 1) * inv_log2_10 - 1e-10;
 3230|      0|    exp = static_cast<int>(e);
 3231|      0|    if (e > exp) ++exp;  // Compute ceil.
  ------------------
  |  Branch (3231:9): [True: 0, False: 0]
  ------------------
 3232|      0|    dragon_flags = dragon::fixup;
 3233|    948|  } else {
 3234|       |    // Extract significand bits and exponent bits.
 3235|    948|    using info = dragonbox::float_info<double>;
 3236|    948|    auto br = bit_cast<uint64_t>(static_cast<double>(value));
 3237|       |
 3238|    948|    const uint64_t significand_mask =
 3239|    948|        (static_cast<uint64_t>(1) << num_significand_bits<double>()) - 1;
 3240|    948|    uint64_t significand = (br & significand_mask);
 3241|    948|    int exponent = static_cast<int>((br & exponent_mask<double>()) >>
 3242|    948|                                    num_significand_bits<double>());
 3243|       |
 3244|    948|    if (exponent != 0) {  // Check if normal.
  ------------------
  |  Branch (3244:9): [True: 820, False: 128]
  ------------------
 3245|    820|      exponent -= exponent_bias<double>() + num_significand_bits<double>();
 3246|    820|      significand |=
 3247|    820|          (static_cast<uint64_t>(1) << num_significand_bits<double>());
 3248|    820|      significand <<= 1;
 3249|    820|    } else {
 3250|       |      // Normalize subnormal inputs.
 3251|    128|      FMT_ASSERT(significand != 0, "zeros should not appear here");
  ------------------
  |  |  402|    128|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 128, False: 0]
  |  |  ------------------
  |  |  403|    128|         ? (void)0                                                          \
  |  |  404|    128|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 3252|    128|      int shift = countl_zero(significand);
 3253|    128|      FMT_ASSERT(shift >= num_bits<uint64_t>() - num_significand_bits<double>(),
  ------------------
  |  |  402|    128|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (402:6): [True: 128, False: 0]
  |  |  ------------------
  |  |  403|    128|         ? (void)0                                                          \
  |  |  404|    128|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 3254|    128|                 "");
 3255|    128|      shift -= (num_bits<uint64_t>() - num_significand_bits<double>() - 2);
 3256|    128|      exponent = (std::numeric_limits<double>::min_exponent -
 3257|    128|                  num_significand_bits<double>()) -
 3258|    128|                 shift;
 3259|    128|      significand <<= shift;
 3260|    128|    }
 3261|       |
 3262|       |    // Compute the first several nonzero decimal significand digits.
 3263|       |    // We call the number we get the first segment.
 3264|    948|    const int k = info::kappa - dragonbox::floor_log10_pow2(exponent);
 3265|    948|    exp = -k;
 3266|    948|    const int beta = exponent + dragonbox::floor_log2_pow10(k);
 3267|    948|    uint64_t first_segment;
 3268|    948|    bool has_more_segments;
 3269|    948|    int digits_in_the_first_segment;
 3270|    948|    {
 3271|    948|      const auto r = dragonbox::umul192_upper128(
 3272|    948|          significand << beta, dragonbox::get_cached_power(k));
 3273|    948|      first_segment = r.high();
 3274|    948|      has_more_segments = r.low() != 0;
 3275|       |
 3276|       |      // The first segment can have 18 ~ 19 digits.
 3277|    948|      if (first_segment >= 1000000000000000000ULL) {
  ------------------
  |  Branch (3277:11): [True: 695, False: 253]
  ------------------
 3278|    695|        digits_in_the_first_segment = 19;
 3279|    695|      } else {
 3280|       |        // When it is of 18-digits, we align it to 19-digits by adding a bogus
 3281|       |        // zero at the end.
 3282|    253|        digits_in_the_first_segment = 18;
 3283|    253|        first_segment *= 10;
 3284|    253|      }
 3285|    948|    }
 3286|       |
 3287|       |    // Compute the actual number of decimal digits to print.
 3288|    948|    if (fixed) adjust_precision(precision, exp + digits_in_the_first_segment);
  ------------------
  |  Branch (3288:9): [True: 0, False: 948]
  ------------------
 3289|       |
 3290|       |    // Use Dragon4 only when there might be not enough digits in the first
 3291|       |    // segment.
 3292|    948|    if (digits_in_the_first_segment > precision) {
  ------------------
  |  Branch (3292:9): [True: 0, False: 948]
  ------------------
 3293|      0|      use_dragon = false;
 3294|       |
 3295|      0|      if (precision <= 0) {
  ------------------
  |  Branch (3295:11): [True: 0, False: 0]
  ------------------
 3296|      0|        exp += digits_in_the_first_segment;
 3297|       |
 3298|      0|        if (precision < 0) {
  ------------------
  |  Branch (3298:13): [True: 0, False: 0]
  ------------------
 3299|       |          // Nothing to do, since all we have are just leading zeros.
 3300|      0|          buf.try_resize(0);
 3301|      0|        } else {
 3302|       |          // We may need to round-up.
 3303|      0|          buf.try_resize(1);
 3304|      0|          if ((first_segment | static_cast<uint64_t>(has_more_segments)) >
  ------------------
  |  Branch (3304:15): [True: 0, False: 0]
  ------------------
 3305|      0|              5000000000000000000ULL) {
 3306|      0|            buf[0] = '1';
 3307|      0|          } else {
 3308|      0|            buf[0] = '0';
 3309|      0|          }
 3310|      0|        }
 3311|      0|      }  // precision <= 0
 3312|      0|      else {
 3313|      0|        exp += digits_in_the_first_segment - precision;
 3314|       |
 3315|       |        // When precision > 0, we divide the first segment into three
 3316|       |        // subsegments, each with 9, 9, and 0 ~ 1 digits so that each fits
 3317|       |        // in 32-bits which usually allows faster calculation than in
 3318|       |        // 64-bits. Since some compiler (e.g. MSVC) doesn't know how to optimize
 3319|       |        // division-by-constant for large 64-bit divisors, we do it here
 3320|       |        // manually. The magic number 7922816251426433760 below is equal to
 3321|       |        // ceil(2^(64+32) / 10^10).
 3322|      0|        const uint32_t first_subsegment = static_cast<uint32_t>(
 3323|      0|            dragonbox::umul128_upper64(first_segment, 7922816251426433760ULL) >>
 3324|      0|            32);
 3325|      0|        const uint64_t second_third_subsegments =
 3326|      0|            first_segment - first_subsegment * 10000000000ULL;
 3327|       |
 3328|      0|        uint64_t prod;
 3329|      0|        uint32_t digits;
 3330|      0|        bool should_round_up;
 3331|      0|        int number_of_digits_to_print = min_of(precision, 9);
 3332|       |
 3333|       |        // Print a 9-digits subsegment, either the first or the second.
 3334|      0|        auto print_subsegment = [&](uint32_t subsegment, char* buffer) {
 3335|      0|          int number_of_digits_printed = 0;
 3336|       |
 3337|       |          // If we want to print an odd number of digits from the subsegment,
 3338|      0|          if ((number_of_digits_to_print & 1) != 0) {
 3339|       |            // Convert to 64-bit fixed-point fractional form with 1-digit
 3340|       |            // integer part. The magic number 720575941 is a good enough
 3341|       |            // approximation of 2^(32 + 24) / 10^8; see
 3342|       |            // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case
 3343|       |            // for details.
 3344|      0|            prod = ((subsegment * static_cast<uint64_t>(720575941)) >> 24) + 1;
 3345|      0|            digits = static_cast<uint32_t>(prod >> 32);
 3346|      0|            *buffer = static_cast<char>('0' + digits);
 3347|      0|            number_of_digits_printed++;
 3348|      0|          }
 3349|       |          // If we want to print an even number of digits from the
 3350|       |          // first_subsegment,
 3351|      0|          else {
 3352|       |            // Convert to 64-bit fixed-point fractional form with 2-digits
 3353|       |            // integer part. The magic number 450359963 is a good enough
 3354|       |            // approximation of 2^(32 + 20) / 10^7; see
 3355|       |            // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case
 3356|       |            // for details.
 3357|      0|            prod = ((subsegment * static_cast<uint64_t>(450359963)) >> 20) + 1;
 3358|      0|            digits = static_cast<uint32_t>(prod >> 32);
 3359|      0|            write2digits(buffer, digits);
 3360|      0|            number_of_digits_printed += 2;
 3361|      0|          }
 3362|       |
 3363|       |          // Print all digit pairs.
 3364|      0|          while (number_of_digits_printed < number_of_digits_to_print) {
 3365|      0|            prod = static_cast<uint32_t>(prod) * static_cast<uint64_t>(100);
 3366|      0|            digits = static_cast<uint32_t>(prod >> 32);
 3367|      0|            write2digits(buffer + number_of_digits_printed, digits);
 3368|      0|            number_of_digits_printed += 2;
 3369|      0|          }
 3370|      0|        };
 3371|       |
 3372|       |        // Print first subsegment.
 3373|      0|        print_subsegment(first_subsegment, buf.data());
 3374|       |
 3375|       |        // Perform rounding if the first subsegment is the last subsegment to
 3376|       |        // print.
 3377|      0|        if (precision <= 9) {
  ------------------
  |  Branch (3377:13): [True: 0, False: 0]
  ------------------
 3378|       |          // Rounding inside the subsegment.
 3379|       |          // We round-up if:
 3380|       |          //  - either the fractional part is strictly larger than 1/2, or
 3381|       |          //  - the fractional part is exactly 1/2 and the last digit is odd.
 3382|       |          // We rely on the following observations:
 3383|       |          //  - If fractional_part >= threshold, then the fractional part is
 3384|       |          //    strictly larger than 1/2.
 3385|       |          //  - If the MSB of fractional_part is set, then the fractional part
 3386|       |          //    must be at least 1/2.
 3387|       |          //  - When the MSB of fractional_part is set, either
 3388|       |          //    second_third_subsegments being nonzero or has_more_segments
 3389|       |          //    being true means there are further digits not printed, so the
 3390|       |          //    fractional part is strictly larger than 1/2.
 3391|      0|          if (precision < 9) {
  ------------------
  |  Branch (3391:15): [True: 0, False: 0]
  ------------------
 3392|      0|            uint32_t fractional_part = static_cast<uint32_t>(prod);
 3393|      0|            should_round_up =
 3394|      0|                fractional_part >= fractional_part_rounding_thresholds(
  ------------------
  |  Branch (3394:17): [True: 0, False: 0]
  ------------------
 3395|      0|                                       8 - number_of_digits_to_print) ||
 3396|      0|                ((fractional_part >> 31) &
  ------------------
  |  Branch (3396:17): [True: 0, False: 0]
  ------------------
 3397|      0|                 ((digits & 1) | (second_third_subsegments != 0) |
 3398|      0|                  has_more_segments)) != 0;
 3399|      0|          }
 3400|       |          // Rounding at the subsegment boundary.
 3401|       |          // In this case, the fractional part is at least 1/2 if and only if
 3402|       |          // second_third_subsegments >= 5000000000ULL, and is strictly larger
 3403|       |          // than 1/2 if we further have either second_third_subsegments >
 3404|       |          // 5000000000ULL or has_more_segments == true.
 3405|      0|          else {
 3406|      0|            should_round_up = second_third_subsegments > 5000000000ULL ||
  ------------------
  |  Branch (3406:31): [True: 0, False: 0]
  ------------------
 3407|      0|                              (second_third_subsegments == 5000000000ULL &&
  ------------------
  |  Branch (3407:32): [True: 0, False: 0]
  ------------------
 3408|      0|                               ((digits & 1) != 0 || has_more_segments));
  ------------------
  |  Branch (3408:33): [True: 0, False: 0]
  |  Branch (3408:54): [True: 0, False: 0]
  ------------------
 3409|      0|          }
 3410|      0|        }
 3411|       |        // Otherwise, print the second subsegment.
 3412|      0|        else {
 3413|       |          // Compilers are not aware of how to leverage the maximum value of
 3414|       |          // second_third_subsegments to find out a better magic number which
 3415|       |          // allows us to eliminate an additional shift. 1844674407370955162 =
 3416|       |          // ceil(2^64/10) < ceil(2^64*(10^9/(10^10 - 1))).
 3417|      0|          const uint32_t second_subsegment =
 3418|      0|              static_cast<uint32_t>(dragonbox::umul128_upper64(
 3419|      0|                  second_third_subsegments, 1844674407370955162ULL));
 3420|      0|          const uint32_t third_subsegment =
 3421|      0|              static_cast<uint32_t>(second_third_subsegments) -
 3422|      0|              second_subsegment * 10;
 3423|       |
 3424|      0|          number_of_digits_to_print = precision - 9;
 3425|      0|          print_subsegment(second_subsegment, buf.data() + 9);
 3426|       |
 3427|       |          // Rounding inside the subsegment.
 3428|      0|          if (precision < 18) {
  ------------------
  |  Branch (3428:15): [True: 0, False: 0]
  ------------------
 3429|       |            // The condition third_subsegment != 0 implies that the segment was
 3430|       |            // of 19 digits, so in this case the third segment should be
 3431|       |            // consisting of a genuine digit from the input.
 3432|      0|            uint32_t fractional_part = static_cast<uint32_t>(prod);
 3433|      0|            should_round_up =
 3434|      0|                fractional_part >= fractional_part_rounding_thresholds(
  ------------------
  |  Branch (3434:17): [True: 0, False: 0]
  ------------------
 3435|      0|                                       8 - number_of_digits_to_print) ||
 3436|      0|                ((fractional_part >> 31) &
  ------------------
  |  Branch (3436:17): [True: 0, False: 0]
  ------------------
 3437|      0|                 ((digits & 1) | (third_subsegment != 0) |
 3438|      0|                  has_more_segments)) != 0;
 3439|      0|          }
 3440|       |          // Rounding at the subsegment boundary.
 3441|      0|          else {
 3442|       |            // In this case, the segment must be of 19 digits, thus
 3443|       |            // the third subsegment should be consisting of a genuine digit from
 3444|       |            // the input.
 3445|      0|            should_round_up = third_subsegment > 5 ||
  ------------------
  |  Branch (3445:31): [True: 0, False: 0]
  ------------------
 3446|      0|                              (third_subsegment == 5 &&
  ------------------
  |  Branch (3446:32): [True: 0, False: 0]
  ------------------
 3447|      0|                               ((digits & 1) != 0 || has_more_segments));
  ------------------
  |  Branch (3447:33): [True: 0, False: 0]
  |  Branch (3447:54): [True: 0, False: 0]
  ------------------
 3448|      0|          }
 3449|      0|        }
 3450|       |
 3451|       |        // Round-up if necessary.
 3452|      0|        if (should_round_up) {
  ------------------
  |  Branch (3452:13): [True: 0, False: 0]
  ------------------
 3453|      0|          ++buf[precision - 1];
 3454|      0|          for (int i = precision - 1; i > 0 && buf[i] > '9'; --i) {
  ------------------
  |  Branch (3454:39): [True: 0, False: 0]
  |  Branch (3454:48): [True: 0, False: 0]
  ------------------
 3455|      0|            buf[i] = '0';
 3456|      0|            ++buf[i - 1];
 3457|      0|          }
 3458|      0|          if (buf[0] > '9') {
  ------------------
  |  Branch (3458:15): [True: 0, False: 0]
  ------------------
 3459|      0|            buf[0] = '1';
 3460|      0|            if (fixed)
  ------------------
  |  Branch (3460:17): [True: 0, False: 0]
  ------------------
 3461|      0|              buf[precision++] = '0';
 3462|      0|            else
 3463|      0|              ++exp;
 3464|      0|          }
 3465|      0|        }
 3466|      0|        buf.try_resize(to_unsigned(precision));
 3467|      0|      }
 3468|      0|    }  // if (digits_in_the_first_segment > precision)
 3469|    948|    else {
 3470|       |      // Adjust the exponent for its use in Dragon4.
 3471|    948|      exp += digits_in_the_first_segment - 1;
 3472|    948|    }
 3473|    948|  }
 3474|    948|  if (use_dragon) {
  ------------------
  |  Branch (3474:7): [True: 948, False: 0]
  ------------------
 3475|    948|    auto f = basic_fp<uint128_t>();
 3476|    948|    bool is_predecessor_closer = binary32 ? f.assign(static_cast<float>(value))
  ------------------
  |  Branch (3476:34): [True: 0, False: 948]
  ------------------
 3477|    948|                                          : f.assign(converted_value);
 3478|    948|    if (is_predecessor_closer) dragon_flags |= dragon::predecessor_closer;
  ------------------
  |  Branch (3478:9): [True: 144, False: 804]
  ------------------
 3479|    948|    if (fixed) dragon_flags |= dragon::fixed;
  ------------------
  |  Branch (3479:9): [True: 0, False: 948]
  ------------------
 3480|       |    // Limit precision to the maximum possible number of significant digits in
 3481|       |    // an IEEE754 double because we don't need to generate zeros.
 3482|    948|    const int max_double_digits = 767;
 3483|    948|    if (precision > max_double_digits) precision = max_double_digits;
  ------------------
  |  Branch (3483:9): [True: 0, False: 948]
  ------------------
 3484|    948|    format_dragon(f, dragon_flags, precision, buf, exp);
 3485|    948|  }
 3486|    948|  if (!fixed && !specs.alt()) {
  ------------------
  |  Branch (3486:7): [True: 948, False: 0]
  |  Branch (3486:17): [True: 948, False: 0]
  ------------------
 3487|       |    // Remove trailing zeros.
 3488|    948|    auto num_digits = buf.size();
 3489|  13.3k|    while (num_digits > 0 && buf[num_digits - 1] == '0') {
  ------------------
  |  Branch (3489:12): [True: 13.3k, False: 0]
  |  Branch (3489:30): [True: 12.3k, False: 948]
  ------------------
 3490|  12.3k|      --num_digits;
 3491|  12.3k|      ++exp;
 3492|  12.3k|    }
 3493|    948|    buf.try_resize(num_digits);
 3494|    948|  }
 3495|    948|  return exp;
 3496|    950|}
_ZN3fmt3v126detail13convert_floatIdEENSt3__111conditionalIXoosr3std7is_sameIT_fEE5valueeqcl8num_bitsIS5_EEclL_ZNS1_8num_bitsIdEEivEEEdS5_E4typeES5_:
 1713|  1.90k|constexpr auto convert_float(T value) -> convert_float_result<T> {
 1714|  1.90k|  return static_cast<convert_float_result<T>>(value);
 1715|  1.90k|}
_ZN3fmt3v126detail8basic_fpIoE6assignIdTnNSt3__19enable_ifIXntsr16is_double_doubleIT_EE5valueEiE4typeELi0EEEbS7_:
 1635|    948|  FMT_CONSTEXPR auto assign(Float n) -> bool {
 1636|    948|    static_assert(std::numeric_limits<Float>::digits <= 113, "unsupported FP");
 1637|       |    // Assume Float is in the format [sign][exponent][significand].
 1638|    948|    using carrier_uint = typename dragonbox::float_info<Float>::carrier_uint;
 1639|    948|    const auto num_float_significand_bits =
 1640|    948|        detail::num_significand_bits<Float>();
 1641|    948|    const auto implicit_bit = carrier_uint(1) << num_float_significand_bits;
 1642|    948|    const auto significand_mask = implicit_bit - 1;
 1643|    948|    auto u = bit_cast<carrier_uint>(n);
 1644|    948|    f = static_cast<F>(u & significand_mask);
 1645|    948|    auto biased_e = static_cast<int>((u & exponent_mask<Float>()) >>
 1646|    948|                                     num_float_significand_bits);
 1647|       |    // The predecessor is closer if n is a normalized power of 2 (f == 0)
 1648|       |    // other than the smallest normalized number (biased_e > 1).
 1649|    948|    auto is_predecessor_closer = f == 0 && biased_e > 1;
  ------------------
  |  Branch (1649:34): [True: 145, False: 803]
  |  Branch (1649:44): [True: 144, False: 1]
  ------------------
 1650|    948|    if (biased_e == 0)
  ------------------
  |  Branch (1650:9): [True: 128, False: 820]
  ------------------
 1651|    128|      biased_e = 1;  // Subnormals use biased exponent 1 (min exponent).
 1652|    820|    else if (has_implicit_bit<Float>())
  ------------------
  |  Branch (1652:14): [True: 820, Folded]
  ------------------
 1653|    820|      f += static_cast<F>(implicit_bit);
 1654|    948|    e = biased_e - exponent_bias<Float>() - num_float_significand_bits;
 1655|    948|    if (!has_implicit_bit<Float>()) ++e;
  ------------------
  |  Branch (1655:9): [Folded, False: 948]
  ------------------
 1656|    948|    return is_predecessor_closer;
 1657|    948|  }
_ZN3fmt3v126detail13arg_formatterIcEclIdTnNSt3__19enable_ifIXsr10is_builtinIT_EE5valueEiE4typeELi0EEEvS7_:
 3737|  1.04k|  FMT_CONSTEXPR FMT_INLINE void operator()(T value) {
 3738|  1.04k|    detail::write<Char>(out, value, specs, locale);
 3739|  1.04k|  }
_ZN3fmt3v126detail5writeIcNS0_14basic_appenderIcEEdTnNSt3__19enable_ifIXsr17is_floating_pointIT1_EE5valueEiE4typeELi0EEET0_SA_S7_NS0_12format_specsENS0_10locale_refE:
 3501|  1.04k|                           locale_ref loc = {}) -> OutputIt {
 3502|  1.04k|  if (specs.localized() && write_loc(out, value, specs, loc)) return out;
  ------------------
  |  Branch (3502:7): [True: 0, False: 1.04k]
  |  Branch (3502:7): [True: 0, False: 1.04k]
  |  Branch (3502:28): [True: 0, False: 0]
  ------------------
 3503|       |
 3504|       |  // Use signbit because value < 0 is false for NaN.
 3505|  1.04k|  sign s = detail::signbit(value) ? sign::minus : specs.sign();
  ------------------
  |  Branch (3505:12): [True: 476, False: 569]
  ------------------
 3506|       |
 3507|  1.04k|  if (!detail::isfinite(value))
  ------------------
  |  Branch (3507:7): [True: 95, False: 950]
  ------------------
 3508|     95|    return write_nonfinite<Char>(out, detail::isnan(value), specs, s);
 3509|       |
 3510|    950|  if (specs.align() == align::numeric && s != sign::none) {
  ------------------
  |  Branch (3510:7): [True: 0, False: 950]
  |  Branch (3510:42): [True: 0, False: 0]
  ------------------
 3511|      0|    *out++ = detail::getsign<Char>(s);
 3512|      0|    s = sign::none;
 3513|      0|    if (specs.width != 0) --specs.width;
  ------------------
  |  Branch (3513:9): [True: 0, False: 0]
  ------------------
 3514|      0|  }
 3515|       |
 3516|    950|  const int exp_upper = detail::exp_upper<T>();
 3517|    950|  int precision = specs.precision;
 3518|    950|  if (precision < 0) {
  ------------------
  |  Branch (3518:7): [True: 0, False: 950]
  ------------------
 3519|      0|    if (specs.type() != presentation_type::none) {
  ------------------
  |  Branch (3519:9): [True: 0, False: 0]
  ------------------
 3520|      0|      precision = 6;
 3521|      0|    } else if (is_fast_float<T>::value && !is_constant_evaluated()) {
  ------------------
  |  Branch (3521:16): [True: 0, Folded]
  |  Branch (3521:43): [True: 0, Folded]
  ------------------
 3522|       |      // Use Dragonbox for the shortest format.
 3523|      0|      auto dec = dragonbox::to_decimal(static_cast<fast_float_t<T>>(value));
 3524|      0|      return write_float<Char>(out, dec, specs, s, exp_upper, loc);
 3525|      0|    }
 3526|      0|  }
 3527|       |
 3528|    950|  memory_buffer buffer;
 3529|    950|  if (specs.type() == presentation_type::hexfloat) {
  ------------------
  |  Branch (3529:7): [True: 0, False: 950]
  ------------------
 3530|      0|    if (s != sign::none) buffer.push_back(detail::getsign<char>(s));
  ------------------
  |  Branch (3530:9): [True: 0, False: 0]
  ------------------
 3531|      0|    format_hexfloat(convert_float(value), specs, buffer);
 3532|      0|    return write_bytes<Char, align::right>(out, {buffer.data(), buffer.size()},
 3533|      0|                                           specs);
 3534|      0|  }
 3535|       |
 3536|    950|  if (specs.type() == presentation_type::exp) {
  ------------------
  |  Branch (3536:7): [True: 0, False: 950]
  ------------------
 3537|      0|    if (precision == max_value<int>())
  ------------------
  |  Branch (3537:9): [True: 0, False: 0]
  ------------------
 3538|      0|      report_error("number is too big");
 3539|      0|    else
 3540|      0|      ++precision;
 3541|      0|    if (specs.precision != 0) specs.set_alt();
  ------------------
  |  Branch (3541:9): [True: 0, False: 0]
  ------------------
 3542|    950|  } else if (specs.type() == presentation_type::fixed) {
  ------------------
  |  Branch (3542:14): [True: 0, False: 950]
  ------------------
 3543|      0|    if (specs.precision != 0) specs.set_alt();
  ------------------
  |  Branch (3543:9): [True: 0, False: 0]
  ------------------
 3544|    950|  } else if (precision == 0) {
  ------------------
  |  Branch (3544:14): [True: 0, False: 950]
  ------------------
 3545|      0|    precision = 1;
 3546|      0|  }
 3547|    950|  int exp = format_float(convert_float(value), precision, specs,
 3548|    950|                         std::is_same<T, float>(), buffer);
 3549|       |
 3550|    950|  specs.precision = precision;
 3551|    950|  auto f = big_decimal_fp{buffer.data(), static_cast<int>(buffer.size()), exp};
 3552|    950|  return write_float<Char>(out, f, specs, s, exp_upper, loc);
 3553|    950|}
_ZN3fmt3v126detail8isfiniteIdTnNSt3__19enable_ifIXaasr17is_floating_pointIT_EE5valuesr12has_isfiniteIS5_EE5valueEiE4typeELi0EEEbS5_:
 2682|  1.04k|FMT_CONSTEXPR20 auto isfinite(T value) -> bool {
 2683|  1.04k|  constexpr T inf = T(std::numeric_limits<double>::infinity());
 2684|  1.04k|  if (is_constant_evaluated())
  ------------------
  |  Branch (2684:7): [Folded, False: 1.04k]
  ------------------
 2685|      0|    return !detail::isnan(value) && value < inf && value > -inf;
  ------------------
  |  Branch (2685:12): [True: 0, False: 0]
  |  Branch (2685:37): [True: 0, False: 0]
  |  Branch (2685:52): [True: 0, False: 0]
  ------------------
 2686|  1.04k|  return std::isfinite(value);
 2687|  1.04k|}
_ZN3fmt3v126detail5isnanIdEEbT_:
 2669|     95|template <typename T> constexpr auto isnan(T value) -> bool {
 2670|     95|  return value != value;  // std::isnan doesn't support __float128.
 2671|     95|}
_ZN3fmt3v126detail9max_valueIjEET_v:
  410|    300|template <typename T> constexpr auto max_value() -> T {
  411|    300|  return (std::numeric_limits<T>::max)();
  412|    300|}
_ZN3fmt3v126detail8bit_castImdTnNSt3__19enable_ifIXeqstT_stT0_EiE4typeELi0EEES5_RKS6_:
  268|  3.89k|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.89k|  auto to = To();
  273|       |  // The cast suppresses a bogus -Wclass-memaccess on GCC.
  274|  3.89k|  memcpy(static_cast<void*>(&to), &from, sizeof(to));
  275|  3.89k|  return to;
  276|  3.89k|}

_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: 186, False: 1.90k]
  ------------------
   18|    186|    auto nan = std::signbit(value) ? "-nan" : "nan";
  ------------------
  |  Branch (18:16): [True: 174, False: 12]
  ------------------
   19|    186|    if (fmt::string_view(buffer.data(), buffer.size()) != nan)
  ------------------
  |  Branch (19:9): [True: 0, False: 186]
  ------------------
   20|      0|      throw std::runtime_error("round trip failure");
   21|    186|    return;
   22|    186|  }
   23|       |
   24|  1.90k|  buffer.push_back('\0');
   25|  1.90k|  char* ptr = nullptr;
   26|  1.90k|  if (std::strtod(buffer.data(), &ptr) != value)
  ------------------
  |  Branch (26:7): [True: 0, False: 1.90k]
  ------------------
   27|      0|    throw std::runtime_error("round trip failure");
   28|  1.90k|  if (ptr + 1 != buffer.end()) throw std::runtime_error("unparsed output");
  ------------------
  |  Branch (28:7): [True: 0, False: 1.90k]
  ------------------
   29|  1.90k|}
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|}