_ZN3fmt3v126detail13ignore_unusedIJbEEEvDpRKT_:
  368|    389|template <typename... T> FMT_CONSTEXPR void ignore_unused(const T&...) {}
_ZNK3fmt3v126detail6bufferIcE8capacityEv:
 1785|    807|  constexpr auto capacity() const noexcept -> size_t { return capacity_; }
_ZN3fmt3v126detail6bufferIcEC2EPFvRS3_mEPcmm:
 1757|  3.14k|      : ptr_(p), size_(sz), capacity_(cap), grow_(grow) {}
_ZN3fmt3v126detail6bufferIcE3setEPcm:
 1763|  3.14k|  FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept {
 1764|  3.14k|    ptr_ = buf_data;
 1765|  3.14k|    capacity_ = buf_capacity;
 1766|  3.14k|  }
_ZN3fmt3v126detail6bufferIcE4dataEv:
 1788|  7.09k|  FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; }
_ZNK3fmt3v126detail6bufferIcE4sizeEv:
 1782|  5.36k|  constexpr auto size() const noexcept -> size_t { return size_; }
_ZN3fmt3v1217basic_string_viewIcEC2EPKcm:
  515|    188|      : data_(s), size_(count) {}
_ZN3fmt3v1217basic_string_viewIcEC2EPKc:
  520|  2.34k|  FMT_CONSTEXPR basic_string_view(const Char* s) : data_(s) {
  521|  2.34k|#if FMT_HAS_BUILTIN(__builtin_strlen) || FMT_GCC_VERSION || FMT_CLANG_VERSION
  522|  2.34k|    if (std::is_same<Char, char>::value && !detail::is_constant_evaluated()) {
  ------------------
  |  Branch (522:9): [True: 0, Folded]
  |  Branch (522:44): [True: 0, Folded]
  ------------------
  523|  2.34k|      size_ = __builtin_strlen(detail::narrow(s));  // strlen is not constexpr.
  524|  2.34k|      return;
  525|  2.34k|    }
  526|      0|#endif
  527|      0|    size_t len = 0;
  528|      0|    while (*s++) ++len;
  ------------------
  |  Branch (528:12): [True: 0, False: 0]
  ------------------
  529|      0|    size_ = len;
  530|      0|  }
_ZN3fmt3v126detail6narrowEPKc:
  451|  2.34k|constexpr FMT_ALWAYS_INLINE auto narrow(const char* s) -> const char* {
  452|  2.34k|  return s;
  453|  2.34k|}
_ZN3fmt3v126detail6bufferIcE9push_backERKc:
 1809|  6.54k|  FMT_CONSTEXPR void push_back(const T& value) {
 1810|  6.54k|    try_reserve(size_ + 1);
 1811|  6.54k|    ptr_[size_++] = value;
 1812|  6.54k|  }
_ZN3fmt3v126detail6bufferIcE11try_reserveEm:
 1805|  11.7k|  FMT_CONSTEXPR void try_reserve(size_t new_capacity) {
 1806|  11.7k|    if (new_capacity > capacity_) grow_(*this, new_capacity);
  ------------------
  |  Branch (1806:9): [True: 0, False: 11.7k]
  ------------------
 1807|  11.7k|  }
_ZN3fmt3v129format_toINSt3__120back_insert_iteratorINS0_19basic_memory_bufferIcLm500ENS0_6detail9allocatorIcEEEEEEJRdETnNS2_9enable_ifIXsr6detail18is_output_iteratorINS2_9remove_cvINS2_16remove_referenceIT_E4typeEE4typeEcEE5valueEiE4typeELi0EEESI_OSE_NS0_7fstringIJDpT0_EE1tEDpOSN_:
 2809|  2.16k|    -> remove_cvref_t<OutputIt> {
 2810|  2.16k|  return vformat_to(out, fmt.str, vargs<T...>{{args...}});
 2811|  2.16k|}
_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:
 2789|  2.16k|    -> remove_cvref_t<OutputIt> {
 2790|  2.16k|  auto&& buf = detail::get_buffer<char>(out);
 2791|  2.16k|  detail::vformat_to(buf, fmt, args, {});
 2792|  2.16k|  return detail::get_iterator(buf, out);
 2793|  2.16k|}
_ZN3fmt3v126detail10get_bufferIcNSt3__120back_insert_iteratorINS0_19basic_memory_bufferIcLm500ENS1_9allocatorIcEEEEEETnNS3_9enable_ifIXsr18is_buffer_appenderIT0_EE5valueEiE4typeELi0EEERNS1_6bufferIT_EESB_:
 2086|  2.16k|auto get_buffer(OutputIt out) -> buffer<T>& {
 2087|  2.16k|  return get_container(out);
 2088|  2.16k|}
_ZN3fmt3v126detail13get_containerINSt3__120back_insert_iteratorINS0_19basic_memory_bufferIcLm500ENS1_9allocatorIcEEEEEEEERNT_14container_typeESA_:
  485|  2.16k|    typename OutputIt::container_type& {
  486|  2.16k|  struct accessor : OutputIt {
  487|  2.16k|    constexpr accessor(OutputIt base) : OutputIt(base) {}
  488|  2.16k|    using OutputIt::container;
  489|  2.16k|  };
  490|  2.16k|  return *accessor(it).container;
  491|  2.16k|}
_ZZN3fmt3v126detail13get_containerINSt3__120back_insert_iteratorINS0_19basic_memory_bufferIcLm500ENS1_9allocatorIcEEEEEEEERNT_14container_typeESA_EN8accessorC2ES9_:
  487|  2.16k|    constexpr accessor(OutputIt base) : OutputIt(base) {}
_ZN3fmt3v1210locale_refC2Ev:
  894|  2.58k|  constexpr locale_ref() : locale_(nullptr) {}
_ZN3fmt3v126detail12get_iteratorIcNSt3__120back_insert_iteratorINS0_19basic_memory_bufferIcLm500ENS1_9allocatorIcEEEEEEEET0_RNS1_6bufferIT_EESA_:
 2095|  2.16k|auto get_iterator(buffer<T>&, OutputIt out) -> OutputIt {
 2096|  2.16k|  return out;
 2097|  2.16k|}
_ZN3fmt3v126detail5valueINS0_7contextEEC2Ed:
 2175|  2.16k|  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:
 2569|  2.16k|      : desc_(DESC | (NUM_NAMED_ARGS != 0 ? +detail::has_named_args_bit : 0)),
  ------------------
  |  Branch (2569:23): [Folded, False: 2.16k]
  ------------------
 2570|  2.16k|        values_(s.args) {}
_ZN3fmt3v127fstringIJRdEEC2INS0_17basic_string_viewIcEETnNSt3__19enable_ifIXsr3std14is_convertibleIRKT_S6_EE5valueEiE4typeELi0EEESB_:
 2705|  2.16k|  FMT_CONSTEVAL FMT_ALWAYS_INLINE fstring(const S& s) : str(s) {
 2706|  2.16k|    if (FMT_USE_CONSTEVAL)
  ------------------
  |  |  120|  2.16k|#  define FMT_USE_CONSTEVAL 0
  |  |  ------------------
  |  |  |  Branch (120:29): [Folded, False: 2.16k]
  |  |  ------------------
  ------------------
 2707|      0|      detail::parse_format_string<char>(str, checker(str, arg_pack()));
 2708|  2.16k|    constexpr bool unused = detail::enforce_compile_checks<sizeof(s) != 0>();
 2709|  2.16k|    (void)unused;
 2710|  2.16k|  }
_ZN3fmt3v12neENS0_17basic_string_viewIcEES2_:
  574|    188|  friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool {
  575|    188|    return lhs.compare(rhs) != 0;
  576|    188|  }
_ZNK3fmt3v1217basic_string_viewIcE7compareES2_:
  564|    188|  FMT_CONSTEXPR auto compare(basic_string_view other) const -> int {
  565|    188|    int cmp = detail::compare(data_, other.data_, min_of(size_, other.size_));
  566|    188|    if (cmp != 0) return cmp;
  ------------------
  |  Branch (566:9): [True: 0, False: 188]
  ------------------
  567|    188|    return size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
  ------------------
  |  Branch (567:12): [True: 188, False: 0]
  |  Branch (567:40): [True: 0, False: 0]
  ------------------
  568|    188|  }
_ZN3fmt3v126detail7compareIcEEiPKT_S5_m:
  456|    188|FMT_CONSTEXPR auto compare(const Char* s1, const Char* s2, size_t n) -> int {
  457|    188|  if (!is_constant_evaluated() && sizeof(Char) == 1) return memcmp(s1, s2, n);
  ------------------
  |  Branch (457:7): [True: 0, Folded]
  |  Branch (457:35): [True: 0, Folded]
  ------------------
  458|      0|  for (; n != 0; ++s1, ++s2, --n) {
  ------------------
  |  Branch (458:10): [True: 0, False: 0]
  ------------------
  459|      0|    if (*s1 < *s2) return -1;
  ------------------
  |  Branch (459:9): [True: 0, False: 0]
  ------------------
  460|      0|    if (*s1 > *s2) return 1;
  ------------------
  |  Branch (460:9): [True: 0, False: 0]
  ------------------
  461|      0|  }
  462|      0|  return 0;
  463|      0|}
_ZN3fmt3v126min_ofImEET_S2_S2_:
  354|   185k|template <typename T> constexpr auto min_of(T a, T b) -> T {
  355|   185k|  return a < b ? a : b;
  ------------------
  |  Branch (355:10): [True: 185k, False: 188]
  ------------------
  356|   185k|}
_ZN3fmt3v126detail6bufferIcE3endEv:
 1776|  1.97k|  auto end() noexcept -> T* { return ptr_ + size_; }
_ZN3fmt3v129monostateC2Ev:
  342|  2.16k|  constexpr monostate() {}
_ZNK3fmt3v1211basic_specs4typeEv:
  716|  5.91k|  constexpr auto type() const -> presentation_type {
  717|  5.91k|    return static_cast<presentation_type>(data_ & type_mask);
  718|  5.91k|  }
_ZN3fmt3v1211basic_specs8set_typeENS0_17presentation_typeE:
  719|  1.08k|  FMT_CONSTEXPR void set_type(presentation_type t) {
  720|  1.08k|    data_ = (data_ & ~type_mask) | unsigned(t);
  721|  1.08k|  }
_ZNK3fmt3v1211basic_specs5alignEv:
  723|  2.06k|  constexpr auto align() const -> align {
  724|  2.06k|    return static_cast<fmt::align>((data_ & align_mask) >> align_shift);
  725|  2.06k|  }
_ZN3fmt3v1211basic_specs21set_dynamic_precisionENS0_11arg_id_kindE:
  741|  1.08k|  FMT_CONSTEXPR void set_dynamic_precision(arg_id_kind p) {
  742|  1.08k|    data_ = (data_ & ~precision_mask) | (unsigned(p) << precision_shift);
  743|  1.08k|  }
_ZNK3fmt3v1211basic_specs7dynamicEv:
  745|  1.08k|  constexpr auto dynamic() const -> bool {
  746|  1.08k|    return (data_ & (width_mask | precision_mask)) != 0;
  747|  1.08k|  }
_ZNK3fmt3v1211basic_specs4signEv:
  749|    615|  constexpr auto sign() const -> sign {
  750|    615|    return static_cast<fmt::sign>((data_ & sign_mask) >> sign_shift);
  751|    615|  }
_ZNK3fmt3v1211basic_specs5upperEv:
  756|    706|  constexpr auto upper() const -> bool { return (data_ & uppercase_mask) != 0; }
_ZNK3fmt3v1211basic_specs3altEv:
  759|  2.63k|  constexpr auto alt() const -> bool { return (data_ & alternate_mask) != 0; }
_ZNK3fmt3v1211basic_specs9localizedEv:
  763|  2.81k|  constexpr auto localized() const -> bool {
  764|  2.81k|    return (data_ & localized_mask) != 0;
  765|  2.81k|  }
_ZNK3fmt3v1211basic_specs9fill_sizeEv:
  768|  1.27k|  constexpr auto fill_size() const -> size_t {
  769|  1.27k|    return (data_ & fill_size_mask) >> fill_size_shift;
  770|  1.27k|  }
_ZN3fmt3v1212format_specsC2Ev:
  819|  1.59k|  constexpr format_specs() : width(0), precision(-1) {}
_ZN3fmt3v126detail11to_unsignedIiEENSt3__113make_unsignedIT_E4typeES5_:
  421|   179k|FMT_CONSTEXPR auto to_unsigned(Int value) -> make_unsigned_t<Int> {
  422|   179k|  FMT_ASSERT(std::is_unsigned<Int>::value || value >= 0, "negative value");
  ------------------
  |  |  394|   358k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (394:7): [Folded, False: 179k]
  |  |  |  Branch (394:7): [True: 179k, False: 0]
  |  |  ------------------
  |  |  395|   179k|         ? (void)0                                                          \
  |  |  396|   179k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
  423|   179k|  return static_cast<make_unsigned_t<Int>>(value);
  424|   179k|}
_ZN3fmt3v127contextC2ENS0_14basic_appenderIcEENS0_17basic_format_argsIS1_EENS0_10locale_refE:
 2637|  1.08k|      : out_(out), args_(args), loc_(loc) {}
_ZNK3fmt3v1217basic_format_argsINS0_7contextEE9is_packedEv:
 2542|  2.16k|  constexpr auto is_packed() const -> bool {
 2543|  2.16k|    return (desc_ & detail::is_unpacked_bit) == 0;
 2544|  2.16k|  }
_ZNK3fmt3v1217basic_format_argsINS0_7contextEE4typeEi:
 2549|  2.16k|  FMT_CONSTEXPR auto type(int index) const -> detail::type {
 2550|  2.16k|    int shift = index * detail::packed_arg_bits;
 2551|  2.16k|    unsigned mask = (1 << detail::packed_arg_bits) - 1;
 2552|  2.16k|    return static_cast<detail::type>((desc_ >> shift) & mask);
 2553|  2.16k|  }
_ZNK3fmt3v1217basic_format_argsINS0_7contextEE3getEi:
 2586|  2.16k|  FMT_CONSTEXPR auto get(int id) const -> format_arg {
 2587|  2.16k|    auto arg = format_arg();
 2588|  2.16k|    if (!is_packed()) {
  ------------------
  |  Branch (2588:9): [True: 0, False: 2.16k]
  ------------------
 2589|      0|      if (id < max_size()) arg = args_[id];
  ------------------
  |  Branch (2589:11): [True: 0, False: 0]
  ------------------
 2590|      0|      return arg;
 2591|      0|    }
 2592|  2.16k|    if (unsigned(id) >= detail::max_packed_args) return arg;
  ------------------
  |  Branch (2592:9): [True: 0, False: 2.16k]
  ------------------
 2593|  2.16k|    arg.type_ = type(id);
 2594|  2.16k|    if (arg.type_ != detail::type::none_type) arg.value_ = values_[id];
  ------------------
  |  Branch (2594:9): [True: 2.16k, False: 0]
  ------------------
 2595|  2.16k|    return arg;
 2596|  2.16k|  }
_ZNK3fmt3v127context3argEi:
 2642|  1.08k|  FMT_CONSTEXPR auto arg(int id) const -> format_arg { return args_.get(id); }
_ZNK3fmt3v127context3outEv:
 2652|  3.24k|  constexpr auto out() const -> iterator { return out_; }
_ZNK3fmt3v127context6localeEv:
 2657|  1.08k|  constexpr auto locale() const -> locale_ref { return loc_; }
_ZN3fmt3v126detail2inENS1_4typeEi:
 1012|  2.16k|constexpr auto in(type t, int set) -> bool {
 1013|  2.16k|  return ((set >> int(t)) & 1) != 0;
 1014|  2.16k|}
_ZN3fmt3v126detail11parse_alignEc:
 1310|  1.08k|FMT_CONSTEXPR inline auto parse_align(char c) -> align {
 1311|  1.08k|  switch (c) {
  ------------------
  |  Branch (1311:11): [True: 0, False: 1.08k]
  ------------------
 1312|      0|  case '<': return align::left;
  ------------------
  |  Branch (1312:3): [True: 0, False: 1.08k]
  ------------------
 1313|      0|  case '>': return align::right;
  ------------------
  |  Branch (1313:3): [True: 0, False: 1.08k]
  ------------------
 1314|      0|  case '^': return align::center;
  ------------------
  |  Branch (1314:3): [True: 0, False: 1.08k]
  ------------------
 1315|  1.08k|  }
 1316|  1.08k|  return align::none;
 1317|  1.08k|}
_ZN3fmt3v126detail11to_unsignedIlEENSt3__113make_unsignedIT_E4typeES5_:
  421|  2.04k|FMT_CONSTEXPR auto to_unsigned(Int value) -> make_unsigned_t<Int> {
  422|  2.04k|  FMT_ASSERT(std::is_unsigned<Int>::value || value >= 0, "negative value");
  ------------------
  |  |  394|  4.09k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (394:7): [Folded, False: 2.04k]
  |  |  |  Branch (394:7): [True: 2.04k, False: 0]
  |  |  ------------------
  |  |  395|  2.04k|         ? (void)0                                                          \
  |  |  396|  2.04k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
  423|  2.04k|  return static_cast<make_unsigned_t<Int>>(value);
  424|  2.04k|}
_ZNK3fmt3v1217basic_string_viewIcE4dataEv:
  539|  2.16k|  constexpr auto data() const noexcept -> const Char* { return data_; }
_ZNK3fmt3v1217basic_string_viewIcE4sizeEv:
  540|  3.24k|  constexpr auto size() const noexcept -> size_t { return size_; }
_ZN3fmt3v1214basic_appenderIcEppEi:
 2439|  4.57k|  FMT_CONSTEXPR auto operator++(int) -> basic_appender { return *this; }
_ZN3fmt3v1214basic_appenderIcEdeEv:
 2437|  4.57k|  FMT_CONSTEXPR auto operator*() -> basic_appender& { return *this; }
_ZN3fmt3v1214basic_appenderIcEaSEc:
 2433|  4.57k|  FMT_CONSTEXPR auto operator=(T c) -> basic_appender& {
 2434|  4.57k|    container->push_back(c);
 2435|  4.57k|    return *this;
 2436|  4.57k|  }
_ZN3fmt3v126max_ofIiEET_S2_S2_:
  357|  1.34k|template <typename T> constexpr auto max_of(T a, T b) -> T {
  358|  1.34k|  return a > b ? a : b;
  ------------------
  |  Branch (358:10): [True: 0, False: 1.34k]
  ------------------
  359|  1.34k|}
_ZNK3fmt3v126detail6bufferIjEixIiEERKjT_:
 1840|   710k|  constexpr auto operator[](Idx index) const -> const T& {
 1841|   710k|    return ptr_[index];
 1842|   710k|  }
_ZN3fmt3v126detail6bufferIjEixIiEERjT_:
 1836|  1.76M|  template <typename Idx> FMT_CONSTEXPR auto operator[](Idx index) -> T& {
 1837|  1.76M|    return ptr_[index];
 1838|  1.76M|  }
_ZNK3fmt3v126detail6bufferIjE4sizeEv:
 1782|  1.90M|  constexpr auto size() const noexcept -> size_t { return size_; }
_ZN3fmt3v126detail6bufferIjE11try_reserveEm:
 1805|   187k|  FMT_CONSTEXPR void try_reserve(size_t new_capacity) {
 1806|   187k|    if (new_capacity > capacity_) grow_(*this, new_capacity);
  ------------------
  |  Branch (1806:9): [True: 0, False: 187k]
  ------------------
 1807|   187k|  }
_ZN3fmt3v126detail6bufferIjE10try_resizeEm:
 1796|   182k|  FMT_CONSTEXPR void try_resize(size_t count) {
 1797|   182k|    try_reserve(count);
 1798|   182k|    size_ = min_of(count, capacity_);
 1799|   182k|  }
_ZNK3fmt3v126detail6bufferIjEixImEERKjT_:
 1840|   755k|  constexpr auto operator[](Idx index) const -> const T& {
 1841|   755k|    return ptr_[index];
 1842|   755k|  }
_ZN3fmt3v126detail6bufferIjEixImEERjT_:
 1836|  1.00M|  template <typename Idx> FMT_CONSTEXPR auto operator[](Idx index) -> T& {
 1837|  1.00M|    return ptr_[index];
 1838|  1.00M|  }
_ZN3fmt3v126detail6bufferIjE9push_backERKj:
 1809|  5.22k|  FMT_CONSTEXPR void push_back(const T& value) {
 1810|  5.22k|    try_reserve(size_ + 1);
 1811|  5.22k|    ptr_[size_++] = value;
 1812|  5.22k|  }
_ZN3fmt3v126detail6bufferIjE3setEPjm:
 1763|  8.32k|  FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept {
 1764|  8.32k|    ptr_ = buf_data;
 1765|  8.32k|    capacity_ = buf_capacity;
 1766|  8.32k|  }
_ZNK3fmt3v126detail6bufferIjE4dataEv:
 1789|    508|  FMT_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; }
_ZN3fmt3v126detail6bufferIjE4dataEv:
 1788|  17.7k|  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_:
 1909|    508|FMT_CONSTEXPR auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt {
 1910|  6.95k|  while (begin != end) *out++ = static_cast<T>(*begin++);
  ------------------
  |  Branch (1910:10): [True: 6.45k, False: 508]
  ------------------
 1911|    508|  return out;
 1912|    508|}
_ZN3fmt3v126min_ofIiEET_S2_S2_:
  354|  3.86k|template <typename T> constexpr auto min_of(T a, T b) -> T {
  355|  3.86k|  return a < b ? a : b;
  ------------------
  |  Branch (355:10): [True: 552, False: 3.31k]
  ------------------
  356|  3.86k|}
_ZN3fmt3v126detail6bufferIcE10try_resizeEm:
 1796|  2.77k|  FMT_CONSTEXPR void try_resize(size_t count) {
 1797|  2.77k|    try_reserve(count);
 1798|  2.77k|    size_ = min_of(count, capacity_);
 1799|  2.77k|  }
_ZN3fmt3v126detail6bufferIcEixIiEERcT_:
 1836|  49.5k|  template <typename Idx> FMT_CONSTEXPR auto operator[](Idx index) -> T& {
 1837|  49.5k|    return ptr_[index];
 1838|  49.5k|  }
_ZN3fmt3v126detail13get_containerINS0_14basic_appenderIcEEEERNT_14container_typeES5_:
  485|  6.61k|    typename OutputIt::container_type& {
  486|  6.61k|  struct accessor : OutputIt {
  487|  6.61k|    constexpr accessor(OutputIt base) : OutputIt(base) {}
  488|  6.61k|    using OutputIt::container;
  489|  6.61k|  };
  490|  6.61k|  return *accessor(it).container;
  491|  6.61k|}
_ZN3fmt3v126detail4copyIcPcNS0_14basic_appenderIcEETnNSt3__19enable_ifIXaacvNS1_23is_back_insert_iteratorIT1_NS6_17integral_constantIbLb1EEEEE_EcvNS1_10has_appendIS9_T0_vEE_EEiE4typeELi0EEES9_SE_SE_S9_:
 1890|    178|FMT_CONSTEXPR auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt {
 1891|    178|  get_container(out).append(begin, end);
 1892|    178|  return out;
 1893|    178|}
_ZN3fmt3v126detail6bufferIcEixImEERcT_:
 1836|  14.1k|  template <typename Idx> FMT_CONSTEXPR auto operator[](Idx index) -> T& {
 1837|  14.1k|    return ptr_[index];
 1838|  14.1k|  }
_ZN3fmt3v126detail8to_asciiIcTnNSt3__19enable_ifIXsr3std11is_integralIT_EE5valueEiE4typeELi0EEEcS5_:
 1273|  3.24k|constexpr auto to_ascii(Char c) -> char {
 1274|  3.24k|  return c <= 0xff ? char(c) : '\0';
  ------------------
  |  Branch (1274:10): [True: 3.24k, False: 0]
  ------------------
 1275|  3.24k|}
_ZZN3fmt3v126detail18parse_format_specsIcEEPKT_S5_S5_RNS1_20dynamic_format_specsIS3_EERNS0_13parse_contextIS3_EENS1_4typeEENUt_clENS1_5stateEb:
 1452|  1.08k|    FMT_CONSTEXPR void operator()(state s, bool valid = true) {
 1453|  1.08k|      if (current_state >= s || !valid)
  ------------------
  |  Branch (1453:11): [True: 0, False: 1.08k]
  |  Branch (1453:33): [True: 0, False: 1.08k]
  ------------------
 1454|      0|        report_error("invalid format specifier");
 1455|  1.08k|      current_state = s;
 1456|  1.08k|    }
_ZZN3fmt3v126detail18parse_format_specsIcEEPKT_S5_S5_RNS1_20dynamic_format_specsIS3_EERNS0_13parse_contextIS3_EENS1_4typeEENUt0_clENS0_17presentation_typeEi:
 1466|  1.08k|    FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* {
 1467|  1.08k|      if (!in(arg_type, set)) report_error("invalid format specifier");
  ------------------
  |  Branch (1467:11): [True: 0, False: 1.08k]
  ------------------
 1468|  1.08k|      specs.set_type(pres_type);
 1469|  1.08k|      return begin + 1;
 1470|  1.08k|    }
_ZN3fmt3v126detail21parse_nonnegative_intIcEEiRPKT_S5_i:
 1289|  1.08k|                                         int error_value) noexcept -> int {
 1290|  1.08k|  FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
  ------------------
  |  |  394|  4.32k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (394:7): [True: 1.08k, False: 0]
  |  |  |  Branch (394:7): [True: 1.08k, False: 0]
  |  |  |  Branch (394:7): [True: 1.08k, False: 0]
  |  |  ------------------
  |  |  395|  1.08k|         ? (void)0                                                          \
  |  |  396|  1.08k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1291|  1.08k|  unsigned value = 0, prev = 0;
 1292|  1.08k|  auto p = begin;
 1293|  2.16k|  do {
 1294|  2.16k|    prev = value;
 1295|  2.16k|    value = value * 10 + unsigned(*p - '0');
 1296|  2.16k|    ++p;
 1297|  2.16k|  } while (p != end && '0' <= *p && *p <= '9');
  ------------------
  |  Branch (1297:12): [True: 2.16k, False: 0]
  |  Branch (1297:24): [True: 2.16k, False: 0]
  |  Branch (1297:37): [True: 1.08k, False: 1.08k]
  ------------------
 1298|  1.08k|  auto num_digits = p - begin;
 1299|  1.08k|  begin = p;
 1300|  1.08k|  int digits10 = int(sizeof(int) * CHAR_BIT * 3 / 10);
 1301|  1.08k|  if (num_digits <= digits10) return int(value);
  ------------------
  |  Branch (1301:7): [True: 1.08k, False: 0]
  ------------------
 1302|       |  // Check for overflow.
 1303|      0|  unsigned max = INT_MAX;
 1304|      0|  return num_digits == digits10 + 1 &&
  ------------------
  |  Branch (1304:10): [True: 0, False: 0]
  ------------------
 1305|      0|                 prev * 10ull + unsigned(p[-1] - '0') <= max
  ------------------
  |  Branch (1305:18): [True: 0, False: 0]
  ------------------
 1306|      0|             ? int(value)
 1307|      0|             : error_value;
 1308|  1.08k|}
_ZN3fmt3v1213parse_contextIcE15do_check_arg_idEi:
 2404|  1.08k|FMT_CONSTEXPR void parse_context<Char>::do_check_arg_id(int arg_id) {
 2405|       |  // Argument id is only checked at compile time during parsing because
 2406|       |  // formatting has its own validation.
 2407|  1.08k|  if (detail::is_constant_evaluated() && use_constexpr_cast) {
  ------------------
  |  Branch (2407:7): [Folded, False: 1.08k]
  |  Branch (2407:42): [True: 0, Folded]
  ------------------
 2408|      0|    auto ctx = static_cast<detail::compile_parse_context<Char>*>(this);
 2409|      0|    if (arg_id >= ctx->num_args()) report_error("argument not found");
  ------------------
  |  Branch (2409:9): [True: 0, False: 0]
  ------------------
 2410|      0|  }
 2411|  1.08k|}
_ZN3fmt3v1213parse_contextIcE11next_arg_idEv:
  857|  1.08k|  FMT_CONSTEXPR auto next_arg_id() -> int {
  858|  1.08k|    if (next_arg_id_ < 0) {
  ------------------
  |  Branch (858:9): [True: 0, False: 1.08k]
  ------------------
  859|      0|      report_error("cannot switch from manual to automatic argument indexing");
  860|      0|      return 0;
  861|      0|    }
  862|  1.08k|    int id = next_arg_id_++;
  863|  1.08k|    do_check_arg_id(id);
  864|  1.08k|    return id;
  865|  1.08k|  }
_ZN3fmt3v126detail18parse_dynamic_specIcEENS1_25parse_dynamic_spec_resultIT_EEPKS4_S7_RiRNS1_7arg_refIS4_EERNS0_13parse_contextIS4_EE:
 1379|  1.08k|    -> parse_dynamic_spec_result<Char> {
 1380|  1.08k|  FMT_ASSERT(begin != end, "");
  ------------------
  |  |  394|  1.08k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (394:6): [True: 1.08k, False: 0]
  |  |  ------------------
  |  |  395|  1.08k|         ? (void)0                                                          \
  |  |  396|  1.08k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1381|  1.08k|  auto kind = arg_id_kind::none;
 1382|  1.08k|  if ('0' <= *begin && *begin <= '9') {
  ------------------
  |  Branch (1382:7): [True: 1.08k, False: 0]
  |  Branch (1382:24): [True: 1.08k, False: 0]
  ------------------
 1383|  1.08k|    int val = parse_nonnegative_int(begin, end, -1);
 1384|  1.08k|    if (val == -1) report_error("number is too big");
  ------------------
  |  Branch (1384:9): [True: 0, False: 1.08k]
  ------------------
 1385|  1.08k|    value = val;
 1386|  1.08k|  } else {
 1387|      0|    if (*begin == '{') {
  ------------------
  |  Branch (1387:9): [True: 0, False: 0]
  ------------------
 1388|      0|      ++begin;
 1389|      0|      if (begin != end) {
  ------------------
  |  Branch (1389:11): [True: 0, False: 0]
  ------------------
 1390|      0|        Char c = *begin;
 1391|      0|        if (c == '}' || c == ':') {
  ------------------
  |  Branch (1391:13): [True: 0, False: 0]
  |  Branch (1391:25): [True: 0, False: 0]
  ------------------
 1392|      0|          int id = ctx.next_arg_id();
 1393|      0|          ref = id;
 1394|      0|          kind = arg_id_kind::index;
 1395|      0|          ctx.check_dynamic_spec(id);
 1396|      0|        } else {
 1397|      0|          begin = parse_arg_id(begin, end,
 1398|      0|                               dynamic_spec_handler<Char>{ctx, ref, kind});
 1399|      0|        }
 1400|      0|      }
 1401|      0|      if (begin != end && *begin == '}') return {++begin, kind};
  ------------------
  |  Branch (1401:11): [True: 0, False: 0]
  |  Branch (1401:27): [True: 0, False: 0]
  ------------------
 1402|      0|    }
 1403|      0|    report_error("invalid format string");
 1404|      0|  }
 1405|  1.08k|  return {begin, kind};
 1406|  1.08k|}
_ZN3fmt3v126detail15parse_precisionIcEEPKT_S5_S5_RNS0_12format_specsERNS1_7arg_refIS3_EERNS0_13parse_contextIS3_EE:
 1421|  1.08k|                                   parse_context<Char>& ctx) -> const Char* {
 1422|  1.08k|  ++begin;
 1423|  1.08k|  if (begin == end) {
  ------------------
  |  Branch (1423:7): [True: 0, False: 1.08k]
  ------------------
 1424|      0|    report_error("invalid precision");
 1425|      0|    return begin;
 1426|      0|  }
 1427|  1.08k|  auto result =
 1428|  1.08k|      parse_dynamic_spec(begin, end, specs.precision, precision_ref, ctx);
 1429|  1.08k|  specs.set_dynamic_precision(result.kind);
 1430|  1.08k|  return result.end;
 1431|  1.08k|}
_ZN3fmt3v126detail18parse_format_specsIcEEPKT_S5_S5_RNS1_20dynamic_format_specsIS3_EERNS0_13parse_contextIS3_EENS1_4typeE:
 1440|  1.08k|    -> const Char* {
 1441|  1.08k|  auto c = '\0';
 1442|  1.08k|  if (end - begin > 1) {
  ------------------
  |  Branch (1442:7): [True: 1.08k, False: 0]
  ------------------
 1443|  1.08k|    auto next = to_ascii(begin[1]);
 1444|  1.08k|    c = parse_align(next) == align::none ? to_ascii(*begin) : '\0';
  ------------------
  |  Branch (1444:9): [True: 1.08k, False: 0]
  ------------------
 1445|  1.08k|  } else {
 1446|      0|    if (begin == end) return begin;
  ------------------
  |  Branch (1446:9): [True: 0, False: 0]
  ------------------
 1447|      0|    c = to_ascii(*begin);
 1448|      0|  }
 1449|       |
 1450|  1.08k|  struct {
 1451|  1.08k|    state current_state = state::start;
 1452|  1.08k|    FMT_CONSTEXPR void operator()(state s, bool valid = true) {
 1453|  1.08k|      if (current_state >= s || !valid)
 1454|  1.08k|        report_error("invalid format specifier");
 1455|  1.08k|      current_state = s;
 1456|  1.08k|    }
 1457|  1.08k|  } enter_state;
 1458|       |
 1459|  1.08k|  using pres = presentation_type;
 1460|  1.08k|  constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
 1461|  1.08k|  struct {
 1462|  1.08k|    const Char*& begin;
 1463|  1.08k|    format_specs& specs;
 1464|  1.08k|    type arg_type;
 1465|       |
 1466|  1.08k|    FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* {
 1467|  1.08k|      if (!in(arg_type, set)) report_error("invalid format specifier");
 1468|  1.08k|      specs.set_type(pres_type);
 1469|  1.08k|      return begin + 1;
 1470|  1.08k|    }
 1471|  1.08k|  } parse_presentation_type{begin, specs, arg_type};
 1472|       |
 1473|  2.16k|  for (;;) {
 1474|  2.16k|    switch (c) {
 1475|      0|    case '<':
  ------------------
  |  Branch (1475:5): [True: 0, False: 2.16k]
  ------------------
 1476|      0|    case '>':
  ------------------
  |  Branch (1476:5): [True: 0, False: 2.16k]
  ------------------
 1477|      0|    case '^':
  ------------------
  |  Branch (1477:5): [True: 0, False: 2.16k]
  ------------------
 1478|      0|      enter_state(state::align);
 1479|      0|      specs.set_align(parse_align(c));
 1480|      0|      ++begin;
 1481|      0|      break;
 1482|      0|    case '+':
  ------------------
  |  Branch (1482:5): [True: 0, False: 2.16k]
  ------------------
 1483|      0|    case ' ':
  ------------------
  |  Branch (1483:5): [True: 0, False: 2.16k]
  ------------------
 1484|      0|      specs.set_sign(c == ' ' ? sign::space : sign::plus);
  ------------------
  |  Branch (1484:22): [True: 0, False: 0]
  ------------------
 1485|      0|      FMT_FALLTHROUGH;
  ------------------
  |  |  183|      0|#  define FMT_FALLTHROUGH [[clang::fallthrough]]
  ------------------
 1486|      0|    case '-':
  ------------------
  |  Branch (1486:5): [True: 0, False: 2.16k]
  ------------------
 1487|      0|      enter_state(state::sign, in(arg_type, sint_set | float_set));
 1488|      0|      ++begin;
 1489|      0|      break;
 1490|      0|    case '#':
  ------------------
  |  Branch (1490:5): [True: 0, False: 2.16k]
  ------------------
 1491|      0|      enter_state(state::hash, is_arithmetic_type(arg_type));
 1492|      0|      specs.set_alt();
 1493|      0|      ++begin;
 1494|      0|      break;
 1495|      0|    case '0':
  ------------------
  |  Branch (1495:5): [True: 0, False: 2.16k]
  ------------------
 1496|      0|      enter_state(state::zero);
 1497|      0|      if (!is_arithmetic_type(arg_type))
  ------------------
  |  Branch (1497:11): [True: 0, False: 0]
  ------------------
 1498|      0|        report_error("format specifier requires numeric argument");
 1499|      0|      if (specs.align() == align::none) {
  ------------------
  |  Branch (1499:11): [True: 0, False: 0]
  ------------------
 1500|       |        // Ignore 0 if align is specified for compatibility with std::format.
 1501|      0|        specs.set_align(align::numeric);
 1502|      0|        specs.set_fill('0');
 1503|      0|      }
 1504|      0|      ++begin;
 1505|      0|      break;
 1506|       |      // clang-format off
 1507|      0|    case '1': case '2': case '3': case '4': case '5':
  ------------------
  |  Branch (1507:5): [True: 0, False: 2.16k]
  |  Branch (1507:15): [True: 0, False: 2.16k]
  |  Branch (1507:25): [True: 0, False: 2.16k]
  |  Branch (1507:35): [True: 0, False: 2.16k]
  |  Branch (1507:45): [True: 0, False: 2.16k]
  ------------------
 1508|      0|    case '6': case '7': case '8': case '9': case '{':
  ------------------
  |  Branch (1508:5): [True: 0, False: 2.16k]
  |  Branch (1508:15): [True: 0, False: 2.16k]
  |  Branch (1508:25): [True: 0, False: 2.16k]
  |  Branch (1508:35): [True: 0, False: 2.16k]
  |  Branch (1508:45): [True: 0, False: 2.16k]
  ------------------
 1509|       |      // clang-format on
 1510|      0|      enter_state(state::width);
 1511|      0|      begin = parse_width(begin, end, specs, specs.width_ref, ctx);
 1512|      0|      break;
 1513|  1.08k|    case '.':
  ------------------
  |  Branch (1513:5): [True: 1.08k, False: 1.08k]
  ------------------
 1514|  1.08k|      enter_state(state::precision,
 1515|  1.08k|                  in(arg_type, float_set | string_set | cstring_set));
 1516|  1.08k|      begin = parse_precision(begin, end, specs, specs.precision_ref, ctx);
 1517|  1.08k|      break;
 1518|      0|    case 'L':
  ------------------
  |  Branch (1518:5): [True: 0, False: 2.16k]
  ------------------
 1519|      0|      enter_state(state::locale, is_arithmetic_type(arg_type));
 1520|      0|      specs.set_localized();
 1521|      0|      ++begin;
 1522|      0|      break;
 1523|      0|    case 'd': return parse_presentation_type(pres::dec, integral_set);
  ------------------
  |  Branch (1523:5): [True: 0, False: 2.16k]
  ------------------
 1524|      0|    case 'X': specs.set_upper(); FMT_FALLTHROUGH;
  ------------------
  |  |  183|      0|#  define FMT_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  |  Branch (1524:5): [True: 0, False: 2.16k]
  ------------------
 1525|      0|    case 'x': return parse_presentation_type(pres::hex, integral_set);
  ------------------
  |  Branch (1525:5): [True: 0, False: 2.16k]
  ------------------
 1526|      0|    case 'o': return parse_presentation_type(pres::oct, integral_set);
  ------------------
  |  Branch (1526:5): [True: 0, False: 2.16k]
  ------------------
 1527|      0|    case 'B': specs.set_upper(); FMT_FALLTHROUGH;
  ------------------
  |  |  183|      0|#  define FMT_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  |  Branch (1527:5): [True: 0, False: 2.16k]
  ------------------
 1528|      0|    case 'b': return parse_presentation_type(pres::bin, integral_set);
  ------------------
  |  Branch (1528:5): [True: 0, False: 2.16k]
  ------------------
 1529|      0|    case 'E': specs.set_upper(); FMT_FALLTHROUGH;
  ------------------
  |  |  183|      0|#  define FMT_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  |  Branch (1529:5): [True: 0, False: 2.16k]
  ------------------
 1530|      0|    case 'e': return parse_presentation_type(pres::exp, float_set);
  ------------------
  |  Branch (1530:5): [True: 0, False: 2.16k]
  ------------------
 1531|      0|    case 'F': specs.set_upper(); FMT_FALLTHROUGH;
  ------------------
  |  |  183|      0|#  define FMT_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  |  Branch (1531:5): [True: 0, False: 2.16k]
  ------------------
 1532|      0|    case 'f': return parse_presentation_type(pres::fixed, float_set);
  ------------------
  |  Branch (1532:5): [True: 0, False: 2.16k]
  ------------------
 1533|      0|    case 'G': specs.set_upper(); FMT_FALLTHROUGH;
  ------------------
  |  |  183|      0|#  define FMT_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  |  Branch (1533:5): [True: 0, False: 2.16k]
  ------------------
 1534|  1.08k|    case 'g': return parse_presentation_type(pres::general, float_set);
  ------------------
  |  Branch (1534:5): [True: 1.08k, False: 1.08k]
  ------------------
 1535|      0|    case 'A': specs.set_upper(); FMT_FALLTHROUGH;
  ------------------
  |  |  183|      0|#  define FMT_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  |  Branch (1535:5): [True: 0, False: 2.16k]
  ------------------
 1536|      0|    case 'a': return parse_presentation_type(pres::hexfloat, float_set);
  ------------------
  |  Branch (1536:5): [True: 0, False: 2.16k]
  ------------------
 1537|      0|    case 'c':
  ------------------
  |  Branch (1537:5): [True: 0, False: 2.16k]
  ------------------
 1538|      0|      if (arg_type == type::bool_type) report_error("invalid format specifier");
  ------------------
  |  Branch (1538:11): [True: 0, False: 0]
  ------------------
 1539|      0|      return parse_presentation_type(pres::chr, integral_set);
 1540|      0|    case 's':
  ------------------
  |  Branch (1540:5): [True: 0, False: 2.16k]
  ------------------
 1541|      0|      return parse_presentation_type(pres::string,
 1542|      0|                                     bool_set | string_set | cstring_set);
 1543|      0|    case 'p':
  ------------------
  |  Branch (1543:5): [True: 0, False: 2.16k]
  ------------------
 1544|      0|      return parse_presentation_type(pres::pointer, pointer_set | cstring_set);
 1545|      0|    case '?':
  ------------------
  |  Branch (1545:5): [True: 0, False: 2.16k]
  ------------------
 1546|      0|      return parse_presentation_type(pres::debug,
 1547|      0|                                     char_set | string_set | cstring_set);
 1548|      0|    case '}': return begin;
  ------------------
  |  Branch (1548:5): [True: 0, False: 2.16k]
  ------------------
 1549|      0|    default:  {
  ------------------
  |  Branch (1549:5): [True: 0, False: 2.16k]
  ------------------
 1550|      0|      if (*begin == '}') return begin;
  ------------------
  |  Branch (1550:11): [True: 0, False: 0]
  ------------------
 1551|       |      // Parse fill and alignment.
 1552|      0|      auto fill_end = begin + code_point_length(begin);
 1553|      0|      if (end - fill_end <= 0) {
  ------------------
  |  Branch (1553:11): [True: 0, False: 0]
  ------------------
 1554|      0|        report_error("invalid format specifier");
 1555|      0|        return begin;
 1556|      0|      }
 1557|      0|      if (*begin == '{') {
  ------------------
  |  Branch (1557:11): [True: 0, False: 0]
  ------------------
 1558|      0|        report_error("invalid fill character '{'");
 1559|      0|        return begin;
 1560|      0|      }
 1561|      0|      auto alignment = parse_align(to_ascii(*fill_end));
 1562|      0|      enter_state(state::align, alignment != align::none);
 1563|      0|      specs.set_fill(
 1564|      0|          basic_string_view<Char>(begin, to_unsigned(fill_end - begin)));
 1565|      0|      specs.set_align(alignment);
 1566|      0|      begin = fill_end + 1;
 1567|      0|    }
 1568|  2.16k|    }
 1569|  1.08k|    if (begin == end) return begin;
  ------------------
  |  Branch (1569:9): [True: 0, False: 1.08k]
  ------------------
 1570|  1.08k|    c = to_ascii(*begin);
 1571|  1.08k|  }
 1572|  1.08k|}
_ZNK3fmt3v126detail6bufferIjE8capacityEv:
 1785|  4.39k|  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_:
 1909|  4.39k|FMT_CONSTEXPR auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt {
 1910|  14.9k|  while (begin != end) *out++ = static_cast<T>(*begin++);
  ------------------
  |  Branch (1910:10): [True: 10.5k, False: 4.39k]
  ------------------
 1911|  4.39k|  return out;
 1912|  4.39k|}
_ZN3fmt3v126detail6bufferIcE6appendIcEEvPKT_S7_:
 1816|  4.20k|  FMT_CONSTEXPR20 void append(const U* begin, const U* end) {
 1817|  4.20k|    static_assert(std::is_same<T, U>() || std::is_same<U, char>(), "");
 1818|  6.25k|    while (begin != end) {
  ------------------
  |  Branch (1818:12): [True: 2.04k, False: 4.20k]
  ------------------
 1819|  2.04k|      auto size = size_;
 1820|  2.04k|      auto free_cap = capacity_ - size;
 1821|  2.04k|      auto count = to_unsigned(end - begin);
 1822|  2.04k|      if (free_cap < count) {
  ------------------
  |  Branch (1822:11): [True: 0, False: 2.04k]
  ------------------
 1823|      0|        grow_(*this, size + count);
 1824|      0|        size = size_;
 1825|      0|        free_cap = capacity_ - size;
 1826|      0|        count = count < free_cap ? count : free_cap;
  ------------------
  |  Branch (1826:17): [True: 0, False: 0]
  ------------------
 1827|      0|      }
 1828|       |      // A loop is faster than memcpy on small sizes.
 1829|  2.04k|      T* out = ptr_ + size;
 1830|  41.5k|      for (size_t i = 0; i < count; ++i) out[i] = static_cast<T>(begin[i]);
  ------------------
  |  Branch (1830:26): [True: 39.5k, False: 2.04k]
  ------------------
 1831|  2.04k|      size_ += count;
 1832|  2.04k|      begin += count;
 1833|  2.04k|    }
 1834|  4.20k|  }
_ZN3fmt3v1214basic_appenderIcEC2ERNS0_6detail6bufferIcEE:
 2431|  2.16k|  constexpr basic_appender(detail::buffer<T>& buf) : container(&buf) {}
_ZN3fmt3v1216basic_format_argINS0_7contextEEC2Ev:
 2466|  2.16k|  constexpr basic_format_arg() : type_(detail::type::none_type) {}
_ZN3fmt3v126detail5valueINS0_7contextEEC2Ev:
 2151|  2.16k|  constexpr FMT_INLINE value() : no_value() {}
_ZNK3fmt3v1216basic_format_argINS0_7contextEE5visitINS0_6detail21default_arg_formatterIcEEEEDTclfp_Li0EEEOT_:
 2484|  1.08k|  FMT_CONSTEXPR FMT_INLINE auto visit(Visitor&& vis) const -> decltype(vis(0)) {
 2485|  1.08k|    using detail::map;
 2486|  1.08k|    switch (type_) {
  ------------------
  |  Branch (2486:13): [True: 1.08k, False: 0]
  ------------------
 2487|      0|    case detail::type::none_type:        break;
  ------------------
  |  Branch (2487:5): [True: 0, False: 1.08k]
  ------------------
 2488|      0|    case detail::type::int_type:         return vis(value_.int_value);
  ------------------
  |  Branch (2488:5): [True: 0, False: 1.08k]
  ------------------
 2489|      0|    case detail::type::uint_type:        return vis(value_.uint_value);
  ------------------
  |  Branch (2489:5): [True: 0, False: 1.08k]
  ------------------
 2490|      0|    case detail::type::long_long_type:   return vis(value_.long_long_value);
  ------------------
  |  Branch (2490:5): [True: 0, False: 1.08k]
  ------------------
 2491|      0|    case detail::type::ulong_long_type:  return vis(value_.ulong_long_value);
  ------------------
  |  Branch (2491:5): [True: 0, False: 1.08k]
  ------------------
 2492|      0|    case detail::type::int128_type:      return vis(map(value_.int128_value));
  ------------------
  |  Branch (2492:5): [True: 0, False: 1.08k]
  ------------------
 2493|      0|    case detail::type::uint128_type:     return vis(map(value_.uint128_value));
  ------------------
  |  Branch (2493:5): [True: 0, False: 1.08k]
  ------------------
 2494|      0|    case detail::type::bool_type:        return vis(value_.bool_value);
  ------------------
  |  Branch (2494:5): [True: 0, False: 1.08k]
  ------------------
 2495|      0|    case detail::type::char_type:        return vis(value_.char_value);
  ------------------
  |  Branch (2495:5): [True: 0, False: 1.08k]
  ------------------
 2496|      0|    case detail::type::float_type:       return vis(value_.float_value);
  ------------------
  |  Branch (2496:5): [True: 0, False: 1.08k]
  ------------------
 2497|  1.08k|    case detail::type::double_type:      return vis(value_.double_value);
  ------------------
  |  Branch (2497:5): [True: 1.08k, False: 0]
  ------------------
 2498|      0|    case detail::type::long_double_type: return vis(value_.long_double_value);
  ------------------
  |  Branch (2498:5): [True: 0, False: 1.08k]
  ------------------
 2499|      0|    case detail::type::cstring_type:     return vis(value_.string.data);
  ------------------
  |  Branch (2499:5): [True: 0, False: 1.08k]
  ------------------
 2500|      0|    case detail::type::string_type:      return vis(value_.string.str());
  ------------------
  |  Branch (2500:5): [True: 0, False: 1.08k]
  ------------------
 2501|      0|    case detail::type::pointer_type:     return vis(value_.pointer);
  ------------------
  |  Branch (2501:5): [True: 0, False: 1.08k]
  ------------------
 2502|      0|    case detail::type::custom_type:      return vis(handle(value_.custom));
  ------------------
  |  Branch (2502:5): [True: 0, False: 1.08k]
  ------------------
 2503|  1.08k|    }
 2504|      0|    return vis(monostate());
 2505|  1.08k|  }
_ZZN3fmt3v126detail13get_containerINS0_14basic_appenderIcEEEERNT_14container_typeES5_EN8accessorC2ES4_:
  487|  6.61k|    constexpr accessor(OutputIt base) : OutputIt(base) {}
_ZNK3fmt3v1211basic_specs9fill_unitIcEET_v:
  781|    190|  template <typename Char> constexpr auto fill_unit() const -> Char {
  782|    190|    using uchar = unsigned char;
  783|    190|    return Char(uchar(fill_data_[0]) | uchar(fill_data_[1]) << 8 |
  784|    190|                uchar(fill_data_[2]) << 16);
  785|    190|  }
_ZN3fmt3v126detail4copyIcPKcNS0_14basic_appenderIcEETnNSt3__19enable_ifIXaacvNS1_23is_back_insert_iteratorIT1_NS7_17integral_constantIbLb1EEEEE_EcvNS1_10has_appendISA_T0_vEE_EEiE4typeELi0EEESA_SF_SF_SA_:
 1890|  4.02k|FMT_CONSTEXPR auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt {
 1891|  4.02k|  get_container(out).append(begin, end);
 1892|  4.02k|  return out;
 1893|  4.02k|}
_ZN3fmt3v126detail6bufferIjEC2EPFvRS3_mEPjmm:
 1757|  8.32k|      : ptr_(p), size_(sz), capacity_(cap), grow_(grow) {}
_ZN3fmt3v126detail19parse_format_stringIcNS1_14format_handlerIcEEEEvNS0_17basic_string_viewIT_EEOT0_:
 1623|  1.08k|                                       Handler&& handler) {
 1624|  1.08k|  auto begin = fmt.data(), end = begin + fmt.size();
 1625|  1.08k|  auto p = begin;
 1626|  2.16k|  while (p != end) {
  ------------------
  |  Branch (1626:10): [True: 1.08k, False: 1.08k]
  ------------------
 1627|  1.08k|    auto c = *p++;
 1628|  1.08k|    if (c == '{') {
  ------------------
  |  Branch (1628:9): [True: 1.08k, False: 0]
  ------------------
 1629|  1.08k|      handler.on_text(begin, p - 1);
 1630|  1.08k|      begin = p = parse_replacement_field(p - 1, end, handler);
 1631|  1.08k|    } else if (c == '}') {
  ------------------
  |  Branch (1631:16): [True: 0, False: 0]
  ------------------
 1632|      0|      if (p == end || *p != '}')
  ------------------
  |  Branch (1632:11): [True: 0, False: 0]
  |  Branch (1632:23): [True: 0, False: 0]
  ------------------
 1633|      0|        return handler.on_error("unmatched '}' in format string");
 1634|      0|      handler.on_text(begin, p);
 1635|      0|      begin = ++p;
 1636|      0|    }
 1637|  1.08k|  }
 1638|  1.08k|  handler.on_text(begin, end);
 1639|  1.08k|}
_ZN3fmt3v126detail23parse_replacement_fieldIcRNS1_14format_handlerIcEEEEPKT_S8_S8_OT0_:
 1578|  1.08k|    -> const Char* {
 1579|  1.08k|  ++begin;
 1580|  1.08k|  if (begin == end) {
  ------------------
  |  Branch (1580:7): [True: 0, False: 1.08k]
  ------------------
 1581|      0|    handler.on_error("invalid format string");
 1582|      0|    return end;
 1583|      0|  }
 1584|  1.08k|  int arg_id = 0;
 1585|  1.08k|  switch (*begin) {
 1586|      0|  case '}':
  ------------------
  |  Branch (1586:3): [True: 0, False: 1.08k]
  ------------------
 1587|      0|    handler.on_replacement_field(handler.on_arg_id(), begin);
 1588|      0|    return begin + 1;
 1589|      0|  case '{': handler.on_text(begin, begin + 1); return begin + 1;
  ------------------
  |  Branch (1589:3): [True: 0, False: 1.08k]
  ------------------
 1590|  1.08k|  case ':': arg_id = handler.on_arg_id(); break;
  ------------------
  |  Branch (1590:3): [True: 1.08k, False: 0]
  ------------------
 1591|      0|  default:  {
  ------------------
  |  Branch (1591:3): [True: 0, False: 1.08k]
  ------------------
 1592|      0|    struct id_adapter {
 1593|      0|      Handler& handler;
 1594|      0|      int arg_id;
 1595|       |
 1596|      0|      FMT_CONSTEXPR void on_index(int id) { arg_id = handler.on_arg_id(id); }
 1597|      0|      FMT_CONSTEXPR void on_name(basic_string_view<Char> id) {
 1598|      0|        arg_id = handler.on_arg_id(id);
 1599|      0|      }
 1600|      0|    } adapter = {handler, 0};
 1601|      0|    begin = parse_arg_id(begin, end, adapter);
 1602|      0|    arg_id = adapter.arg_id;
 1603|      0|    Char c = begin != end ? *begin : Char();
  ------------------
  |  Branch (1603:14): [True: 0, False: 0]
  ------------------
 1604|      0|    if (c == '}') {
  ------------------
  |  Branch (1604:9): [True: 0, False: 0]
  ------------------
 1605|      0|      handler.on_replacement_field(arg_id, begin);
 1606|      0|      return begin + 1;
 1607|      0|    }
 1608|      0|    if (c != ':') {
  ------------------
  |  Branch (1608:9): [True: 0, False: 0]
  ------------------
 1609|      0|      handler.on_error("missing '}' in format string");
 1610|      0|      return end;
 1611|      0|    }
 1612|      0|    break;
 1613|      0|  }
 1614|  1.08k|  }
 1615|  1.08k|  begin = handler.on_format_specs(arg_id, begin + 1, end);
 1616|  1.08k|  if (begin == end || *begin != '}')
  ------------------
  |  Branch (1616:7): [True: 0, False: 1.08k]
  |  Branch (1616:23): [True: 0, False: 1.08k]
  ------------------
 1617|      0|    return handler.on_error("unknown format specifier"), end;
 1618|  1.08k|  return begin + 1;
 1619|  1.08k|}
_ZNK3fmt3v1216basic_format_argINS0_7contextEEcvbEv:
 2473|  1.08k|  constexpr explicit operator bool() const noexcept {
 2474|  1.08k|    return type_ != detail::type::none_type;
 2475|  1.08k|  }
_ZN3fmt3v1216basic_format_argINS0_7contextEE13format_customEPKcRNS0_13parse_contextIcEERS2_:
 2509|  1.08k|      -> bool {
 2510|  1.08k|    if (type_ != detail::type::custom_type) return false;
  ------------------
  |  Branch (2510:9): [True: 1.08k, False: 0]
  ------------------
 2511|      0|    parse_ctx.advance_to(parse_begin);
 2512|      0|    value_.custom.format(value_.custom.value, parse_ctx, ctx);
 2513|      0|    return true;
 2514|  1.08k|  }
_ZN3fmt3v126detail7arg_refIcEC2Ei:
 1256|  2.16k|  FMT_CONSTEXPR arg_ref(int idx = 0) : index(idx) {}
_ZNK3fmt3v1216basic_format_argINS0_7contextEE4typeEv:
 2476|  1.08k|  auto type() const -> detail::type { return type_; }
_ZNK3fmt3v1216basic_format_argINS0_7contextEE5visitINS0_6detail13arg_formatterIcEEEEDTclfp_Li0EEEOT_:
 2484|  1.08k|  FMT_CONSTEXPR FMT_INLINE auto visit(Visitor&& vis) const -> decltype(vis(0)) {
 2485|  1.08k|    using detail::map;
 2486|  1.08k|    switch (type_) {
  ------------------
  |  Branch (2486:13): [True: 1.08k, False: 0]
  ------------------
 2487|      0|    case detail::type::none_type:        break;
  ------------------
  |  Branch (2487:5): [True: 0, False: 1.08k]
  ------------------
 2488|      0|    case detail::type::int_type:         return vis(value_.int_value);
  ------------------
  |  Branch (2488:5): [True: 0, False: 1.08k]
  ------------------
 2489|      0|    case detail::type::uint_type:        return vis(value_.uint_value);
  ------------------
  |  Branch (2489:5): [True: 0, False: 1.08k]
  ------------------
 2490|      0|    case detail::type::long_long_type:   return vis(value_.long_long_value);
  ------------------
  |  Branch (2490:5): [True: 0, False: 1.08k]
  ------------------
 2491|      0|    case detail::type::ulong_long_type:  return vis(value_.ulong_long_value);
  ------------------
  |  Branch (2491:5): [True: 0, False: 1.08k]
  ------------------
 2492|      0|    case detail::type::int128_type:      return vis(map(value_.int128_value));
  ------------------
  |  Branch (2492:5): [True: 0, False: 1.08k]
  ------------------
 2493|      0|    case detail::type::uint128_type:     return vis(map(value_.uint128_value));
  ------------------
  |  Branch (2493:5): [True: 0, False: 1.08k]
  ------------------
 2494|      0|    case detail::type::bool_type:        return vis(value_.bool_value);
  ------------------
  |  Branch (2494:5): [True: 0, False: 1.08k]
  ------------------
 2495|      0|    case detail::type::char_type:        return vis(value_.char_value);
  ------------------
  |  Branch (2495:5): [True: 0, False: 1.08k]
  ------------------
 2496|      0|    case detail::type::float_type:       return vis(value_.float_value);
  ------------------
  |  Branch (2496:5): [True: 0, False: 1.08k]
  ------------------
 2497|  1.08k|    case detail::type::double_type:      return vis(value_.double_value);
  ------------------
  |  Branch (2497:5): [True: 1.08k, False: 0]
  ------------------
 2498|      0|    case detail::type::long_double_type: return vis(value_.long_double_value);
  ------------------
  |  Branch (2498:5): [True: 0, False: 1.08k]
  ------------------
 2499|      0|    case detail::type::cstring_type:     return vis(value_.string.data);
  ------------------
  |  Branch (2499:5): [True: 0, False: 1.08k]
  ------------------
 2500|      0|    case detail::type::string_type:      return vis(value_.string.str());
  ------------------
  |  Branch (2500:5): [True: 0, False: 1.08k]
  ------------------
 2501|      0|    case detail::type::pointer_type:     return vis(value_.pointer);
  ------------------
  |  Branch (2501:5): [True: 0, False: 1.08k]
  ------------------
 2502|      0|    case detail::type::custom_type:      return vis(handle(value_.custom));
  ------------------
  |  Branch (2502:5): [True: 0, False: 1.08k]
  ------------------
 2503|  1.08k|    }
 2504|      0|    return vis(monostate());
 2505|  1.08k|  }
_ZN3fmt3v1213parse_contextIcEC2ENS0_17basic_string_viewIcEEi:
  841|  1.08k|      : fmt_(fmt), next_arg_id_(next_arg_id) {}

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

_ZN3fmt3v1219basic_memory_bufferIcLm500ENS0_6detail9allocatorIcEEEC2ERKS4_:
  821|  3.14k|      : detail::buffer<T>(grow), alloc_(alloc) {
  822|  3.14k|    this->set(store_, SIZE);
  823|  3.14k|    if (detail::is_constant_evaluated()) detail::fill_n(store_, SIZE, T());
  ------------------
  |  Branch (823:9): [Folded, False: 3.14k]
  ------------------
  824|  3.14k|  }
_ZN3fmt3v126detail16abort_fuzzing_ifEb:
  240|    389|FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) {
  241|    389|  ignore_unused(condition);
  242|    389|#ifdef FMT_FUZZ
  243|    389|  if (condition) throw std::runtime_error("fuzzing limit reached");
  ------------------
  |  Branch (243:7): [True: 0, False: 389]
  ------------------
  244|    389|#endif
  245|    389|}
_ZN3fmt3v126detail9max_valueImEET_v:
  407|    966|template <typename T> constexpr auto max_value() -> T {
  408|    966|  return (std::numeric_limits<T>::max)();
  409|    966|}
_ZN3fmt3v1219basic_memory_bufferIcLm500ENS0_6detail9allocatorIcEEED2Ev:
  825|  3.14k|  FMT_CONSTEXPR20 ~basic_memory_buffer() { deallocate(); }
_ZN3fmt3v1219basic_memory_bufferIcLm500ENS0_6detail9allocatorIcEEE10deallocateEv:
  786|  3.14k|  FMT_CONSTEXPR20 void deallocate() {
  787|  3.14k|    T* data = this->data();
  788|  3.14k|    if (data != store_) alloc_.deallocate(data, this->capacity());
  ------------------
  |  Branch (788:9): [True: 0, False: 3.14k]
  ------------------
  789|  3.14k|  }
_ZN3fmt3v126detail7uint128C2Emm:
  298|  2.11k|  constexpr uint128(uint64_t hi, uint64_t lo) : lo_(lo), hi_(hi) {}
_ZNK3fmt3v126detail7uint1284highEv:
  301|  5.71k|  constexpr auto high() const noexcept -> uint64_t { return hi_; }
_ZNK3fmt3v126detail7uint1283lowEv:
  302|  4.08k|  constexpr auto low() const noexcept -> uint64_t { return lo_; }
_ZN3fmt3v126detail7uint128pLEm:
  371|  1.81k|  FMT_CONSTEXPR20 auto operator+=(uint64_t n) noexcept -> uint128& {
  372|  1.81k|    if (is_constant_evaluated()) {
  ------------------
  |  Branch (372:9): [Folded, False: 1.81k]
  ------------------
  373|      0|      lo_ += n;
  374|      0|      hi_ += (lo_ < n ? 1 : 0);
  ------------------
  |  Branch (374:15): [True: 0, False: 0]
  ------------------
  375|      0|      return *this;
  376|      0|    }
  377|  1.81k|#if FMT_HAS_BUILTIN(__builtin_addcll) && !defined(__ibmxl__)
  378|  1.81k|    ullong carry;
  379|  1.81k|    lo_ = __builtin_addcll(lo_, n, 0, &carry);
  380|  1.81k|    hi_ += carry;
  381|       |#elif FMT_HAS_BUILTIN(__builtin_ia32_addcarryx_u64) && !defined(__ibmxl__)
  382|       |    ullong result;
  383|       |    auto carry = __builtin_ia32_addcarryx_u64(0, lo_, n, &result);
  384|       |    lo_ = result;
  385|       |    hi_ += carry;
  386|       |#elif defined(_MSC_VER) && defined(_M_AMD64)
  387|       |    auto carry = _addcarry_u64(0, lo_, n, &lo_);
  388|       |    _addcarry_u64(carry, hi_, 0, &hi_);
  389|       |#else
  390|       |    lo_ += n;
  391|       |    hi_ += (lo_ < n ? 1 : 0);
  392|       |#endif
  393|  1.81k|    return *this;
  394|  1.81k|  }
_ZN3fmt3v126detail20num_significand_bitsIdEEiv:
 1534|  10.4k|template <typename Float> constexpr auto num_significand_bits() -> int {
 1535|       |  // std::numeric_limits may not support __float128.
 1536|  10.4k|  return is_float128<Float>() ? 112
  ------------------
  |  Branch (1536:10): [Folded, False: 10.4k]
  ------------------
 1537|  10.4k|                              : (std::numeric_limits<Float>::digits -
 1538|  10.4k|                                 (has_implicit_bit<Float>() ? 1 : 0));
  ------------------
  |  Branch (1538:35): [True: 10.4k, Folded]
  ------------------
 1539|  10.4k|}
_ZN3fmt3v126detail9max_valueIiEET_v:
  407|    396|template <typename T> constexpr auto max_value() -> T {
  408|    396|  return (std::numeric_limits<T>::max)();
  409|    396|}
_ZN3fmt3v126detail6fill_nINS0_14basic_appenderIcEEicEET_S5_T0_RKT1_:
  538|    535|    -> OutputIt {
  539|    951|  for (Size i = 0; i < count; ++i) *out++ = value;
  ------------------
  |  Branch (539:20): [True: 416, False: 535]
  ------------------
  540|    535|  return out;
  541|    535|}
_ZN3fmt3v126detail8num_bitsIjEEiv:
  410|  22.0k|template <typename T> constexpr auto num_bits() -> int {
  411|  22.0k|  return std::numeric_limits<T>::digits;
  412|  22.0k|}
_ZNK3fmt3v126detail6bigint9get_bigitEi:
 2698|  3.09k|  FMT_CONSTEXPR auto get_bigit(int i) const -> bigit {
 2699|  3.09k|    return i >= exp_ && i < num_bigits() ? bigits_[i - exp_] : 0;
  ------------------
  |  Branch (2699:12): [True: 3.03k, False: 63]
  |  Branch (2699:25): [True: 2.13k, False: 894]
  ------------------
 2700|  3.09k|  }
_ZN3fmt3v126detail6bigint15subtract_bigitsEijRj:
 2702|   726k|  FMT_CONSTEXPR void subtract_bigits(int index, bigit other, bigit& borrow) {
 2703|   726k|    auto result = double_bigit(bigits_[index]) - other - borrow;
 2704|   726k|    bigits_[index] = static_cast<bigit>(result);
 2705|   726k|    borrow = static_cast<bigit>(result >> (bigit_bits * 2 - 1));
 2706|   726k|  }
_ZN3fmt3v1219basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEE6resizeEm:
  888|   182k|  FMT_CONSTEXPR void resize(size_t count) { this->try_resize(count); }
_ZN3fmt3v126detail6bigint20remove_leading_zerosEv:
 2708|   170k|  FMT_CONSTEXPR void remove_leading_zeros() {
 2709|   170k|    int num_bigits = static_cast<int>(bigits_.size()) - 1;
 2710|   178k|    while (num_bigits > 0 && bigits_[num_bigits] == 0) --num_bigits;
  ------------------
  |  Branch (2710:12): [True: 175k, False: 2.69k]
  |  Branch (2710:30): [True: 7.71k, False: 167k]
  ------------------
 2711|   170k|    bigits_.resize(to_unsigned(num_bigits + 1));
 2712|   170k|  }
_ZN3fmt3v126detail6bigint16subtract_alignedERKS2_:
 2715|   166k|  FMT_CONSTEXPR void subtract_aligned(const bigint& other) {
 2716|   166k|    FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints");
  ------------------
  |  |  394|   166k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (394:6): [True: 166k, False: 0]
  |  |  ------------------
  |  |  395|   166k|         ? (void)0                                                          \
  |  |  396|   166k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2717|   166k|    FMT_ASSERT(compare(*this, other) >= 0, "");
  ------------------
  |  |  394|   166k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (394:6): [True: 166k, False: 0]
  |  |  ------------------
  |  |  395|   166k|         ? (void)0                                                          \
  |  |  396|   166k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2718|   166k|    bigit borrow = 0;
 2719|   166k|    int i = other.exp_ - exp_;
 2720|   889k|    for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j)
  ------------------
  |  Branch (2720:50): [True: 723k, False: 166k]
  ------------------
 2721|   723k|      subtract_bigits(i, other.bigits_[j], borrow);
 2722|   166k|    if (borrow != 0) subtract_bigits(i, 0, borrow);
  ------------------
  |  Branch (2722:9): [True: 3.75k, False: 162k]
  ------------------
 2723|   166k|    FMT_ASSERT(borrow == 0, "");
  ------------------
  |  |  394|   166k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (394:6): [True: 166k, False: 0]
  |  |  ------------------
  |  |  395|   166k|         ? (void)0                                                          \
  |  |  396|   166k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2724|   166k|    remove_leading_zeros();
 2725|   166k|  }
_ZN3fmt3v126detail6bigint8multiplyEj:
 2727|  50.3k|  FMT_CONSTEXPR void multiply(uint32_t value) {
 2728|  50.3k|    bigit carry = 0;
 2729|  50.3k|    const double_bigit wide_value = value;
 2730|   512k|    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
  ------------------
  |  Branch (2730:44): [True: 462k, False: 50.3k]
  ------------------
 2731|   462k|      double_bigit result = bigits_[i] * wide_value + carry;
 2732|   462k|      bigits_[i] = static_cast<bigit>(result);
 2733|   462k|      carry = static_cast<bigit>(result >> bigit_bits);
 2734|   462k|    }
 2735|  50.3k|    if (carry != 0) bigits_.push_back(carry);
  ------------------
  |  Branch (2735:9): [True: 4.13k, False: 46.2k]
  ------------------
 2736|  50.3k|  }
_ZN3fmt3v126detail6bigintC2Ev:
 2772|  3.93k|  FMT_CONSTEXPR bigint() : exp_(0) {}
_ZN3fmt3v126detail6bigint6assignImTnNSt3__19enable_ifIXoosr3std7is_sameIT_mEE5valuesr3std7is_sameIS6_oEE5valueEiE4typeELi0EEEvS6_:
 2761|  2.04k|  FMT_CONSTEXPR void assign(UInt n) {
 2762|  2.04k|    size_t num_bigits = 0;
 2763|  2.04k|    do {
 2764|  2.04k|      bigits_[num_bigits++] = static_cast<bigit>(n);
 2765|  2.04k|      n >>= bigit_bits;
 2766|  2.04k|    } while (n != 0);
  ------------------
  |  Branch (2766:14): [True: 0, False: 2.04k]
  ------------------
 2767|  2.04k|    bigits_.resize(num_bigits);
 2768|  2.04k|    exp_ = 0;
 2769|  2.04k|  }
_ZN3fmt3v126detail6bigint6assignERKS2_:
 2778|    508|  FMT_CONSTEXPR void assign(const bigint& other) {
 2779|    508|    auto size = other.bigits_.size();
 2780|    508|    bigits_.resize(size);
 2781|    508|    auto data = other.bigits_.data();
 2782|    508|    copy<bigit>(data, data + size, bigits_.data());
 2783|    508|    exp_ = other.exp_;
 2784|    508|  }
_ZNK3fmt3v126detail6bigint10num_bigitsEv:
 2791|   768k|  FMT_CONSTEXPR auto num_bigits() const -> int {
 2792|   768k|    return static_cast<int>(bigits_.size()) + exp_;
 2793|   768k|  }
_ZN3fmt3v126detail6bigintlSEi:
 2795|  3.24k|  FMT_CONSTEXPR auto operator<<=(int shift) -> bigint& {
 2796|  3.24k|    FMT_ASSERT(shift >= 0, "");
  ------------------
  |  |  394|  3.24k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (394:6): [True: 3.24k, False: 0]
  |  |  ------------------
  |  |  395|  3.24k|         ? (void)0                                                          \
  |  |  396|  3.24k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2797|  3.24k|    exp_ += shift / bigit_bits;
 2798|  3.24k|    shift %= bigit_bits;
 2799|  3.24k|    if (shift == 0) return *this;
  ------------------
  |  Branch (2799:9): [True: 72, False: 3.17k]
  ------------------
 2800|  3.17k|    bigit carry = 0;
 2801|  23.2k|    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
  ------------------
  |  Branch (2801:44): [True: 20.0k, False: 3.17k]
  ------------------
 2802|  20.0k|      bigit c = bigits_[i] >> (bigit_bits - shift);
 2803|  20.0k|      bigits_[i] = (bigits_[i] << shift) + carry;
 2804|  20.0k|      carry = c;
 2805|  20.0k|    }
 2806|  3.17k|    if (carry != 0) bigits_.push_back(carry);
  ------------------
  |  Branch (2806:9): [True: 528, False: 2.64k]
  ------------------
 2807|  3.17k|    return *this;
 2808|  3.24k|  }
_ZN3fmt3v126detail7compareERKNS1_6bigintES4_:
 2816|   381k|  friend FMT_CONSTEXPR auto compare(const bigint& b1, const bigint& b2) -> int {
 2817|   381k|    int num_bigits1 = b1.num_bigits(), num_bigits2 = b2.num_bigits();
 2818|   381k|    if (num_bigits1 != num_bigits2) return num_bigits1 > num_bigits2 ? 1 : -1;
  ------------------
  |  Branch (2818:9): [True: 29.0k, False: 352k]
  |  Branch (2818:44): [True: 12.7k, False: 16.3k]
  ------------------
 2819|   352k|    int i = static_cast<int>(b1.bigits_.size()) - 1;
 2820|   352k|    int j = static_cast<int>(b2.bigits_.size()) - 1;
 2821|   352k|    int end = i - j;
 2822|   352k|    if (end < 0) end = 0;
  ------------------
  |  Branch (2822:9): [True: 145, False: 352k]
  ------------------
 2823|   358k|    for (; i >= end; --i, --j) {
  ------------------
  |  Branch (2823:12): [True: 354k, False: 4.39k]
  ------------------
 2824|   354k|      bigit b1_bigit = b1.bigits_[i], b2_bigit = b2.bigits_[j];
 2825|   354k|      if (b1_bigit != b2_bigit) return b1_bigit > b2_bigit ? 1 : -1;
  ------------------
  |  Branch (2825:11): [True: 347k, False: 6.34k]
  |  Branch (2825:40): [True: 315k, False: 32.8k]
  ------------------
 2826|   354k|    }
 2827|  4.39k|    if (i != j) return i > j ? 1 : -1;
  ------------------
  |  Branch (2827:9): [True: 3.87k, False: 516]
  |  Branch (2827:24): [True: 3.87k, False: 0]
  ------------------
 2828|    516|    return 0;
 2829|  4.39k|  }
_ZN3fmt3v126detail11add_compareERKNS1_6bigintES4_S4_:
 2833|    984|                                        const bigint& rhs) -> int {
 2834|    984|    int max_lhs_bigits = max_of(lhs1.num_bigits(), lhs2.num_bigits());
 2835|    984|    int num_rhs_bigits = rhs.num_bigits();
 2836|    984|    if (max_lhs_bigits + 1 < num_rhs_bigits) return -1;
  ------------------
  |  Branch (2836:9): [True: 37, False: 947]
  ------------------
 2837|    947|    if (max_lhs_bigits > num_rhs_bigits) return 1;
  ------------------
  |  Branch (2837:9): [True: 0, False: 947]
  ------------------
 2838|    947|    double_bigit borrow = 0;
 2839|    947|    int min_exp = min_of(min_of(lhs1.exp_, lhs2.exp_), rhs.exp_);
 2840|  1.04k|    for (int i = num_rhs_bigits - 1; i >= min_exp; --i) {
  ------------------
  |  Branch (2840:38): [True: 1.03k, False: 11]
  ------------------
 2841|  1.03k|      double_bigit sum = double_bigit(lhs1.get_bigit(i)) + lhs2.get_bigit(i);
 2842|  1.03k|      bigit rhs_bigit = rhs.get_bigit(i);
 2843|  1.03k|      if (sum > rhs_bigit + borrow) return 1;
  ------------------
  |  Branch (2843:11): [True: 270, False: 762]
  ------------------
 2844|    762|      borrow = rhs_bigit + borrow - sum;
 2845|    762|      if (borrow > 1) return -1;
  ------------------
  |  Branch (2845:11): [True: 666, False: 96]
  ------------------
 2846|     96|      borrow <<= bigit_bits;
 2847|     96|    }
 2848|     11|    return borrow != 0 ? -1 : 0;
  ------------------
  |  Branch (2848:12): [True: 0, False: 11]
  ------------------
 2849|    947|  }
_ZN3fmt3v126detail6bigintaSIiEEvT_:
 2786|  2.01k|  template <typename Int> FMT_CONSTEXPR void operator=(Int n) {
 2787|  2.01k|    FMT_ASSERT(n > 0, "");
  ------------------
  |  |  394|  2.01k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (394:6): [True: 2.01k, False: 0]
  |  |  ------------------
  |  |  395|  2.01k|         ? (void)0                                                          \
  |  |  396|  2.01k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2788|  2.01k|    assign(uint64_or_128_t<Int>(n));
 2789|  2.01k|  }
_ZN3fmt3v126detail6bigintmLIiEERS2_T_:
 2810|  50.3k|  template <typename Int> FMT_CONSTEXPR auto operator*=(Int value) -> bigint& {
 2811|  50.3k|    FMT_ASSERT(value > 0, "");
  ------------------
  |  |  394|  50.3k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (394:6): [True: 50.3k, False: 0]
  |  |  ------------------
  |  |  395|  50.3k|         ? (void)0                                                          \
  |  |  396|  50.3k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2812|  50.3k|    multiply(uint32_or_64_or_128_t<Int>(value));
 2813|  50.3k|    return *this;
 2814|  50.3k|  }
_ZN3fmt3v126detail6bigint12assign_pow10Ei:
 2852|    984|  FMT_CONSTEXPR20 void assign_pow10(int exp) {
 2853|    984|    FMT_ASSERT(exp >= 0, "");
  ------------------
  |  |  394|    984|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (394:6): [True: 984, False: 0]
  |  |  ------------------
  |  |  395|    984|         ? (void)0                                                          \
  |  |  396|    984|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2854|    984|    if (exp == 0) return *this = 1;
  ------------------
  |  Branch (2854:9): [True: 34, False: 950]
  ------------------
 2855|    950|    int bitmask = 1 << (num_bits<unsigned>() -
 2856|    950|                        countl_zero(static_cast<uint32_t>(exp)) - 1);
 2857|       |    // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by
 2858|       |    // repeated squaring and multiplication.
 2859|    950|    *this = 5;
 2860|    950|    bitmask >>= 1;
 2861|  5.34k|    while (bitmask != 0) {
  ------------------
  |  Branch (2861:12): [True: 4.39k, False: 950]
  ------------------
 2862|  4.39k|      square();
 2863|  4.39k|      if ((exp & bitmask) != 0) *this *= 5;
  ------------------
  |  Branch (2863:11): [True: 2.13k, False: 2.25k]
  ------------------
 2864|  4.39k|      bitmask >>= 1;
 2865|  4.39k|    }
 2866|    950|    *this <<= exp;  // Multiply by pow(2, exp) by shifting.
 2867|    950|  }
_ZN3fmt3v126detail6bigint6squareEv:
 2869|  4.39k|  FMT_CONSTEXPR20 void square() {
 2870|  4.39k|    int num_bigits = static_cast<int>(bigits_.size());
 2871|  4.39k|    int num_result_bigits = 2 * num_bigits;
 2872|  4.39k|    basic_memory_buffer<bigit, bigits_capacity> n(std::move(bigits_));
 2873|  4.39k|    bigits_.resize(to_unsigned(num_result_bigits));
 2874|  4.39k|    auto sum = uint128_t();
 2875|  14.9k|    for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) {
  ------------------
  |  Branch (2875:31): [True: 10.5k, False: 4.39k]
  ------------------
 2876|       |      // Compute bigit at position bigit_index of the result by adding
 2877|       |      // cross-product terms n[i] * n[j] such that i + j == bigit_index.
 2878|  45.3k|      for (int i = 0, j = bigit_index; j >= 0; ++i, --j) {
  ------------------
  |  Branch (2878:40): [True: 34.8k, False: 10.5k]
  ------------------
 2879|       |        // Most terms are multiplied twice which can be optimized in the future.
 2880|  34.8k|        sum += double_bigit(n[i]) * n[j];
 2881|  34.8k|      }
 2882|  10.5k|      bigits_[bigit_index] = static_cast<bigit>(sum);
 2883|  10.5k|      sum >>= num_bits<bigit>();  // Compute the carry.
 2884|  10.5k|    }
 2885|       |    // Do the same for the top half.
 2886|  14.9k|    for (int bigit_index = num_bigits; bigit_index < num_result_bigits;
  ------------------
  |  Branch (2886:40): [True: 10.5k, False: 4.39k]
  ------------------
 2887|  10.5k|         ++bigit_index) {
 2888|  34.8k|      for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;)
  ------------------
  |  Branch (2888:57): [True: 24.3k, False: 10.5k]
  ------------------
 2889|  24.3k|        sum += double_bigit(n[i++]) * n[j--];
 2890|  10.5k|      bigits_[bigit_index] = static_cast<bigit>(sum);
 2891|  10.5k|      sum >>= num_bits<bigit>();
 2892|  10.5k|    }
 2893|  4.39k|    remove_leading_zeros();
 2894|  4.39k|    exp_ *= 2;
 2895|  4.39k|  }
_ZN3fmt3v126detail6fill_nIPjjjEET_S4_T0_RKT1_:
  538|    164|    -> OutputIt {
  539|  2.29k|  for (Size i = 0; i < count; ++i) *out++ = value;
  ------------------
  |  Branch (539:20): [True: 2.13k, False: 164]
  ------------------
  540|    164|  return out;
  541|    164|}
_ZN3fmt3v126detail6bigint5alignERKS2_:
 2899|  32.6k|  FMT_CONSTEXPR void align(const bigint& other) {
 2900|  32.6k|    int exp_difference = exp_ - other.exp_;
 2901|  32.6k|    if (exp_difference <= 0) return;
  ------------------
  |  Branch (2901:9): [True: 32.5k, False: 164]
  ------------------
 2902|    164|    int num_bigits = static_cast<int>(bigits_.size());
 2903|    164|    bigits_.resize(to_unsigned(num_bigits + exp_difference));
 2904|    612|    for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
  ------------------
  |  Branch (2904:58): [True: 448, False: 164]
  ------------------
 2905|    448|      bigits_[j] = bigits_[i];
 2906|    164|    fill_n(bigits_.data(), to_unsigned(exp_difference), 0U);
 2907|    164|    exp_ -= exp_difference;
 2908|    164|  }
_ZN3fmt3v126detail6bigint13divmod_assignERKS2_:
 2912|  49.2k|  FMT_CONSTEXPR auto divmod_assign(const bigint& divisor) -> int {
 2913|  49.2k|    FMT_ASSERT(this != &divisor, "");
  ------------------
  |  |  394|  49.2k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (394:6): [True: 49.2k, False: 0]
  |  |  ------------------
  |  |  395|  49.2k|         ? (void)0                                                          \
  |  |  396|  49.2k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2914|  49.2k|    if (compare(*this, divisor) < 0) return 0;
  ------------------
  |  Branch (2914:9): [True: 16.5k, False: 32.6k]
  ------------------
 2915|  32.6k|    FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, "");
  ------------------
  |  |  394|  32.6k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (394:6): [True: 32.6k, False: 0]
  |  |  ------------------
  |  |  395|  32.6k|         ? (void)0                                                          \
  |  |  396|  32.6k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2916|  32.6k|    align(divisor);
 2917|  32.6k|    int quotient = 0;
 2918|   166k|    do {
 2919|   166k|      subtract_aligned(divisor);
 2920|   166k|      ++quotient;
 2921|   166k|    } while (compare(*this, divisor) >= 0);
  ------------------
  |  Branch (2921:14): [True: 133k, False: 32.6k]
  ------------------
 2922|  32.6k|    return quotient;
 2923|  49.2k|  }
_ZN3fmt3v126detail6bigint6assignIoTnNSt3__19enable_ifIXoosr3std7is_sameIT_mEE5valuesr3std7is_sameIS6_oEE5valueEiE4typeELi0EEEvS6_:
 2761|    549|  FMT_CONSTEXPR void assign(UInt n) {
 2762|    549|    size_t num_bigits = 0;
 2763|  1.09k|    do {
 2764|  1.09k|      bigits_[num_bigits++] = static_cast<bigit>(n);
 2765|  1.09k|      n >>= bigit_bits;
 2766|  1.09k|    } while (n != 0);
  ------------------
  |  Branch (2766:14): [True: 549, False: 549]
  ------------------
 2767|    549|    bigits_.resize(num_bigits);
 2768|    549|    exp_ = 0;
 2769|    549|  }
_ZN3fmt3v126detail6bigintaSIoEEvT_:
 2786|    549|  template <typename Int> FMT_CONSTEXPR void operator=(Int n) {
 2787|    549|    FMT_ASSERT(n > 0, "");
  ------------------
  |  |  394|    549|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (394:6): [True: 549, False: 0]
  |  |  ------------------
  |  |  395|    549|         ? (void)0                                                          \
  |  |  396|    549|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2788|    549|    assign(uint64_or_128_t<Int>(n));
 2789|    549|  }
_ZN3fmt3v126detail8num_bitsImEEiv:
  410|    711|template <typename T> constexpr auto num_bits() -> int {
  411|    711|  return std::numeric_limits<T>::digits;
  412|    711|}
_ZN3fmt3v126detail6bigint8multiplyIoTnNSt3__19enable_ifIXoosr3std7is_sameIT_mEE5valuesr3std7is_sameIS6_oEE5valueEiE4typeELi0EEEvS6_:
 2740|    435|  FMT_CONSTEXPR void multiply(UInt value) {
 2741|    435|    using half_uint =
 2742|    435|        conditional_t<std::is_same<UInt, uint128_t>::value, uint64_t, uint32_t>;
 2743|    435|    const int shift = num_bits<half_uint>() - bigit_bits;
 2744|    435|    const UInt lower = static_cast<half_uint>(value);
 2745|    435|    const UInt upper = value >> num_bits<half_uint>();
 2746|    435|    UInt carry = 0;
 2747|  6.11k|    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
  ------------------
  |  Branch (2747:44): [True: 5.68k, False: 435]
  ------------------
 2748|  5.68k|      UInt result = lower * bigits_[i] + static_cast<bigit>(carry);
 2749|  5.68k|      carry = (upper * bigits_[i] << shift) + (result >> bigit_bits) +
 2750|  5.68k|              (carry >> bigit_bits);
 2751|  5.68k|      bigits_[i] = static_cast<bigit>(result);
 2752|  5.68k|    }
 2753|  1.00k|    while (carry != 0) {
  ------------------
  |  Branch (2753:12): [True: 571, False: 435]
  ------------------
 2754|    571|      bigits_.push_back(static_cast<bigit>(carry));
 2755|    571|      carry >>= bigit_bits;
 2756|    571|    }
 2757|    435|  }
_ZN3fmt3v126detail6bigintmLIoEERS2_T_:
 2810|    435|  template <typename Int> FMT_CONSTEXPR auto operator*=(Int value) -> bigint& {
 2811|    435|    FMT_ASSERT(value > 0, "");
  ------------------
  |  |  394|    435|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (394:6): [True: 435, False: 0]
  |  |  ------------------
  |  |  395|    435|         ? (void)0                                                          \
  |  |  396|    435|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2812|    435|    multiply(uint32_or_64_or_128_t<Int>(value));
 2813|    435|    return *this;
 2814|    435|  }
_ZN3fmt3v126detail6bigintaSIyEEvT_:
 2786|     29|  template <typename Int> FMT_CONSTEXPR void operator=(Int n) {
 2787|     29|    FMT_ASSERT(n > 0, "");
  ------------------
  |  |  394|     29|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (394:6): [True: 29, False: 0]
  |  |  ------------------
  |  |  395|     29|         ? (void)0                                                          \
  |  |  396|     29|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 2788|     29|    assign(uint64_or_128_t<Int>(n));
 2789|     29|  }
_ZN3fmt3v126detail13copy_noinlineIcPcNS0_14basic_appenderIcEEEET1_T0_S7_S6_:
  558|    178|                                              OutputIt out) -> OutputIt {
  559|    178|  return copy<OutChar>(begin, end, out);
  560|    178|}
_ZN3fmt3v126detail13exponent_maskIdEENS1_9dragonbox10float_infoIT_vE12carrier_uintEv:
 1543|  4.03k|    typename dragonbox::float_info<Float>::carrier_uint {
 1544|  4.03k|  using float_uint = typename dragonbox::float_info<Float>::carrier_uint;
 1545|  4.03k|  return ((float_uint(1) << dragonbox::float_info<Float>::exponent_bits) - 1)
 1546|  4.03k|         << num_significand_bits<Float>();
 1547|  4.03k|}
_ZN3fmt3v126detail13exponent_biasIdEEiv:
 1548|  2.67k|template <typename Float> constexpr auto exponent_bias() -> int {
 1549|       |  // std::numeric_limits may not support __float128.
 1550|  2.67k|  return is_float128<Float>() ? 16383
  ------------------
  |  Branch (1550:10): [Folded, False: 2.67k]
  ------------------
 1551|  2.67k|                              : std::numeric_limits<Float>::max_exponent - 1;
 1552|  2.67k|}
_ZN3fmt3v126detail7getsignIcEET_NS0_4signE:
 1045|    727|template <typename Char> constexpr auto getsign(sign s) -> Char {
 1046|    727|  return static_cast<Char>(static_cast<char>(
 1047|    727|      ((' ' << 24) | ('+' << 16) | ('-' << 8)) >> (static_cast<int>(s) * 8)));
 1048|    727|}
_ZN3fmt3v126detail11countl_zeroEj:
  445|    950|FMT_CONSTEXPR20 inline auto countl_zero(uint32_t n) -> int {
  446|    950|#ifdef FMT_BUILTIN_CLZ
  447|    950|  if (!is_constant_evaluated()) return FMT_BUILTIN_CLZ(n);
  ------------------
  |  |  196|    950|#    define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
  ------------------
  |  Branch (447:7): [True: 950, Folded]
  ------------------
  448|      0|#endif
  449|      0|  return countl_zero_fallback(n);
  450|    950|}
_ZN3fmt3v126detail11countl_zeroEm:
  452|    138|FMT_CONSTEXPR20 inline auto countl_zero(uint64_t n) -> int {
  453|    138|#ifdef FMT_BUILTIN_CLZLL
  454|    138|  if (!is_constant_evaluated()) return FMT_BUILTIN_CLZLL(n);
  ------------------
  |  |  199|    138|#    define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
  ------------------
  |  Branch (454:7): [True: 138, Folded]
  ------------------
  455|      0|#endif
  456|      0|  return countl_zero_fallback(n);
  457|    138|}
_ZN3fmt3v126detail7digits2Em:
 1017|  8.04k|inline auto digits2(size_t value) noexcept -> const char* {
 1018|       |  // Align data since unaligned access may be slower when crossing a
 1019|       |  // hardware-specific boundary.
 1020|  8.04k|  alignas(2) static constexpr char data[] =
 1021|  8.04k|      "0001020304050607080910111213141516171819"
 1022|  8.04k|      "2021222324252627282930313233343536373839"
 1023|  8.04k|      "4041424344454647484950515253545556575859"
 1024|  8.04k|      "6061626364656667686970717273747576777879"
 1025|  8.04k|      "8081828384858687888990919293949596979899";
 1026|  8.04k|  return &data[value * 2];
 1027|  8.04k|}
_ZN3fmt3v126detail15do_count_digitsEm:
 1073|  1.96k|inline auto do_count_digits(uint64_t n) -> int {
 1074|       |  // This has comparable performance to the version by Kendall Willets
 1075|       |  // (https://github.com/fmtlib/format-benchmark/blob/master/digits10)
 1076|       |  // but uses smaller tables.
 1077|       |  // Maps bsr(n) to ceil(log10(pow(2, bsr(n) + 1) - 1)).
 1078|  1.96k|  static constexpr uint8_t bsr2log10[] = {
 1079|  1.96k|      1,  1,  1,  2,  2,  2,  3,  3,  3,  4,  4,  4,  4,  5,  5,  5,
 1080|  1.96k|      6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  9,  9,  9,  10, 10, 10,
 1081|  1.96k|      10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15,
 1082|  1.96k|      15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19, 20};
 1083|  1.96k|  auto t = bsr2log10[FMT_BUILTIN_CLZLL(n | 1) ^ 63];
  ------------------
  |  |  199|  1.96k|#    define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
  ------------------
 1084|  1.96k|  static constexpr uint64_t zero_or_powers_of_10[] = {
 1085|  1.96k|      0, 0, FMT_POWERS_OF_10(1U), FMT_POWERS_OF_10(1000000000ULL),
  ------------------
  |  | 1011|  1.96k|  factor * 10, (factor) * 100, (factor) * 1000, (factor) * 10000, \
  |  | 1012|  1.96k|      (factor) * 100000, (factor) * 1000000, (factor) * 10000000, \
  |  | 1013|  1.96k|      (factor) * 100000000, (factor) * 1000000000
  ------------------
                    0, 0, FMT_POWERS_OF_10(1U), FMT_POWERS_OF_10(1000000000ULL),
  ------------------
  |  | 1011|  1.96k|  factor * 10, (factor) * 100, (factor) * 1000, (factor) * 10000, \
  |  | 1012|  1.96k|      (factor) * 100000, (factor) * 1000000, (factor) * 10000000, \
  |  | 1013|  1.96k|      (factor) * 100000000, (factor) * 1000000000
  ------------------
 1086|  1.96k|      10000000000000000000ULL};
 1087|  1.96k|  return t - (n < zero_or_powers_of_10[t]);
 1088|  1.96k|}
_ZN3fmt3v126detail12count_digitsEm:
 1093|  1.96k|FMT_CONSTEXPR20 inline auto count_digits(uint64_t n) -> int {
 1094|  1.96k|#ifdef FMT_BUILTIN_CLZLL
 1095|  1.96k|  if (!is_constant_evaluated() && !FMT_OPTIMIZE_SIZE) return do_count_digits(n);
  ------------------
  |  |  295|      0|#  define FMT_OPTIMIZE_SIZE 0
  ------------------
  |  Branch (1095:7): [True: 0, Folded]
  |  Branch (1095:35): [True: 0, Folded]
  ------------------
 1096|      0|#endif
 1097|      0|  return count_digits_fallback(n);
 1098|  1.96k|}
_ZN3fmt3v126detail6equal2EPKcS3_:
 1199|  1.08k|inline auto equal2(const char* lhs, const char* rhs) -> bool {
 1200|  1.08k|  return memcmp(lhs, rhs, 2) == 0;
 1201|  1.08k|}
_ZN3fmt3v126detail7umul128Emm:
 1411|  1.96k|FMT_INLINE auto umul128(uint64_t x, uint64_t y) noexcept -> uint128 {
 1412|  1.96k|#if FMT_USE_INT128
 1413|  1.96k|  auto p = static_cast<native_uint128>(x) * static_cast<native_uint128>(y);
 1414|  1.96k|  return {static_cast<uint64_t>(p >> 64), static_cast<uint64_t>(p)};
 1415|       |#elif defined(_MSC_VER) && defined(_M_AMD64)
 1416|       |  auto hi = uint64_t();
 1417|       |  auto lo = _umul128(x, y, &hi);
 1418|       |  return {hi, lo};
 1419|       |#else
 1420|       |  const uint64_t mask = static_cast<uint64_t>(max_value<uint32_t>());
 1421|       |
 1422|       |  uint64_t a = x >> 32;
 1423|       |  uint64_t b = x & mask;
 1424|       |  uint64_t c = y >> 32;
 1425|       |  uint64_t d = y & mask;
 1426|       |
 1427|       |  uint64_t ac = a * c;
 1428|       |  uint64_t bc = b * c;
 1429|       |  uint64_t ad = a * d;
 1430|       |  uint64_t bd = b * d;
 1431|       |
 1432|       |  uint64_t intermediate = (bd >> 32) + (ad & mask) + (bc & mask);
 1433|       |
 1434|       |  return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32),
 1435|       |          (intermediate << 32) + (bd & mask)};
 1436|       |#endif
 1437|  1.96k|}
_ZN3fmt3v126detail9dragonbox16floor_log10_pow2Ei:
 1442|  1.81k|inline auto floor_log10_pow2(int e) noexcept -> int {
 1443|  1.81k|  FMT_ASSERT(e <= 2620 && e >= -2620, "too large exponent");
  ------------------
  |  |  394|  3.63k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (394:7): [True: 1.81k, False: 0]
  |  |  |  Branch (394:7): [True: 1.81k, False: 0]
  |  |  ------------------
  |  |  395|  1.81k|         ? (void)0                                                          \
  |  |  396|  1.81k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1444|  1.81k|  static_assert((-1 >> 1) == -1, "right shift is not arithmetic");
 1445|  1.81k|  return (e * 315653) >> 20;
 1446|  1.81k|}
_ZN3fmt3v126detail9dragonbox16floor_log2_pow10Ei:
 1448|  1.96k|inline auto floor_log2_pow10(int e) noexcept -> int {
 1449|  1.96k|  FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent");
  ------------------
  |  |  394|  3.93k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (394:7): [True: 1.96k, False: 0]
  |  |  |  Branch (394:7): [True: 1.96k, False: 0]
  |  |  ------------------
  |  |  395|  1.96k|         ? (void)0                                                          \
  |  |  396|  1.96k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1450|  1.96k|  return (e * 1741647) >> 19;
 1451|  1.96k|}
_ZN3fmt3v126detail9dragonbox15umul128_upper64Emm:
 1454|  2.65k|inline auto umul128_upper64(uint64_t x, uint64_t y) noexcept -> uint64_t {
 1455|  2.65k|#if FMT_USE_INT128
 1456|  2.65k|  auto p = static_cast<native_uint128>(x) * static_cast<native_uint128>(y);
 1457|  2.65k|  return static_cast<uint64_t>(p >> 64);
 1458|       |#elif defined(_MSC_VER) && defined(_M_AMD64)
 1459|       |  return __umulh(x, y);
 1460|       |#else
 1461|       |  return umul128(x, y).high();
 1462|       |#endif
 1463|  2.65k|}
_ZN3fmt3v126detail9dragonbox16umul192_upper128EmNS1_7uint128E:
 1467|  1.81k|inline auto umul192_upper128(uint64_t x, uint128 y) noexcept -> uint128 {
 1468|  1.81k|  uint128 r = umul128(x, y.high());
 1469|  1.81k|  r += umul128_upper64(x, y.low());
 1470|  1.81k|  return r;
 1471|  1.81k|}
_ZN3fmt3v126detail16compute_exp_sizeEi:
 1554|    516|FMT_CONSTEXPR inline auto compute_exp_size(int exp) -> int {
 1555|    516|  auto prefix_size = 2;  // sign + 'e'
 1556|    516|  auto abs_exp = exp >= 0 ? exp : -exp;
  ------------------
  |  Branch (1556:18): [True: 154, False: 362]
  ------------------
 1557|    516|  if (abs_exp < 100) return prefix_size + 2;
  ------------------
  |  Branch (1557:7): [True: 138, False: 378]
  ------------------
 1558|    378|  return prefix_size + (abs_exp >= 1000 ? 4 : 3);
  ------------------
  |  Branch (1558:25): [True: 0, False: 378]
  ------------------
 1559|    516|}
_ZN3fmt3v126detail20get_significand_sizeERKNS1_14big_decimal_fpE:
 2396|    985|constexpr auto get_significand_size(const big_decimal_fp& f) -> int {
 2397|    985|  return f.significand_size;
 2398|    985|}
_ZN3fmt3v126detail9use_fixedEii:
 2502|  1.97k|constexpr auto use_fixed(int exp, int exp_upper) -> bool {
 2503|  1.97k|  return exp >= -4 && exp < exp_upper;
  ------------------
  |  Branch (2503:10): [True: 1.24k, False: 724]
  |  Branch (2503:23): [True: 891, False: 355]
  ------------------
 2504|  1.97k|}
_ZN3fmt3v126detail13format_dragonENS1_8basic_fpIoEEjiRNS1_6bufferIcEERi:
 2938|    984|                                          buffer<char>& buf, int& exp10) {
 2939|    984|  bigint numerator;    // 2 * R in (FPP)^2.
 2940|    984|  bigint denominator;  // 2 * S in (FPP)^2.
 2941|       |  // lower and upper are differences between value and corresponding boundaries.
 2942|    984|  bigint lower;             // (M^- in (FPP)^2).
 2943|    984|  bigint upper_store;       // upper's value if different from lower.
 2944|    984|  bigint* upper = nullptr;  // (M^+ in (FPP)^2).
 2945|       |  // Shift numerator and denominator by an extra bit or two (if lower boundary
 2946|       |  // is closer) to make lower and upper integers. This eliminates multiplication
 2947|       |  // by 2 during later computations.
 2948|    984|  bool is_predecessor_closer = (flags & dragon::predecessor_closer) != 0;
 2949|    984|  int shift = is_predecessor_closer ? 2 : 1;
  ------------------
  |  Branch (2949:15): [True: 148, False: 836]
  ------------------
 2950|    984|  if (value.e >= 0) {
  ------------------
  |  Branch (2950:7): [True: 212, False: 772]
  ------------------
 2951|    212|    numerator = value.f;
 2952|    212|    numerator <<= value.e + shift;
 2953|    212|    lower = 1;
 2954|    212|    lower <<= value.e;
 2955|    212|    if (is_predecessor_closer) {
  ------------------
  |  Branch (2955:9): [True: 46, False: 166]
  ------------------
 2956|     46|      upper_store = 1;
 2957|     46|      upper_store <<= value.e + 1;
 2958|     46|      upper = &upper_store;
 2959|     46|    }
 2960|    212|    denominator.assign_pow10(exp10);
 2961|    212|    denominator <<= shift;
 2962|    772|  } else if (exp10 < 0) {
  ------------------
  |  Branch (2962:14): [True: 435, False: 337]
  ------------------
 2963|    435|    numerator.assign_pow10(-exp10);
 2964|    435|    lower.assign(numerator);
 2965|    435|    if (is_predecessor_closer) {
  ------------------
  |  Branch (2965:9): [True: 73, False: 362]
  ------------------
 2966|     73|      upper_store.assign(numerator);
 2967|     73|      upper_store <<= 1;
 2968|     73|      upper = &upper_store;
 2969|     73|    }
 2970|    435|    numerator *= value.f;
 2971|    435|    numerator <<= shift;
 2972|    435|    denominator = 1;
 2973|    435|    denominator <<= shift - value.e;
 2974|    435|  } else {
 2975|    337|    numerator = value.f;
 2976|    337|    numerator <<= shift;
 2977|    337|    denominator.assign_pow10(exp10);
 2978|    337|    denominator <<= shift - value.e;
 2979|    337|    lower = 1;
 2980|    337|    if (is_predecessor_closer) {
  ------------------
  |  Branch (2980:9): [True: 29, False: 308]
  ------------------
 2981|     29|      upper_store = 1ULL << 1;
 2982|     29|      upper = &upper_store;
 2983|     29|    }
 2984|    337|  }
 2985|    984|  int even = static_cast<int>((value.f & 1) == 0);
 2986|    984|  if (!upper) upper = &lower;
  ------------------
  |  Branch (2986:7): [True: 836, False: 148]
  ------------------
 2987|    984|  bool shortest = num_digits < 0;
 2988|    984|  if ((flags & dragon::fixup) != 0) {
  ------------------
  |  Branch (2988:7): [True: 0, False: 984]
  ------------------
 2989|      0|    if (add_compare(numerator, *upper, denominator) + even <= 0) {
  ------------------
  |  Branch (2989:9): [True: 0, False: 0]
  ------------------
 2990|      0|      --exp10;
 2991|      0|      numerator *= 10;
 2992|      0|      if (num_digits < 0) {
  ------------------
  |  Branch (2992:11): [True: 0, False: 0]
  ------------------
 2993|      0|        lower *= 10;
 2994|      0|        if (upper != &lower) *upper *= 10;
  ------------------
  |  Branch (2994:13): [True: 0, False: 0]
  ------------------
 2995|      0|      }
 2996|      0|    }
 2997|      0|    if ((flags & dragon::fixed) != 0) adjust_precision(num_digits, exp10 + 1);
  ------------------
  |  Branch (2997:9): [True: 0, False: 0]
  ------------------
 2998|      0|  }
 2999|       |  // Invariant: value == (numerator / denominator) * pow(10, exp10).
 3000|    984|  if (shortest) {
  ------------------
  |  Branch (3000:7): [True: 0, False: 984]
  ------------------
 3001|       |    // Generate the shortest representation.
 3002|      0|    num_digits = 0;
 3003|      0|    char* data = buf.data();
 3004|      0|    for (;;) {
 3005|      0|      int digit = numerator.divmod_assign(denominator);
 3006|      0|      bool low = compare(numerator, lower) - even < 0;  // numerator <[=] lower.
 3007|       |      // numerator + upper >[=] pow10:
 3008|      0|      bool high = add_compare(numerator, *upper, denominator) + even > 0;
 3009|      0|      data[num_digits++] = static_cast<char>('0' + digit);
 3010|      0|      if (low || high) {
  ------------------
  |  Branch (3010:11): [True: 0, False: 0]
  |  Branch (3010:18): [True: 0, False: 0]
  ------------------
 3011|      0|        if (!low) {
  ------------------
  |  Branch (3011:13): [True: 0, False: 0]
  ------------------
 3012|      0|          ++data[num_digits - 1];
 3013|      0|        } else if (high) {
  ------------------
  |  Branch (3013:20): [True: 0, False: 0]
  ------------------
 3014|      0|          int result = add_compare(numerator, numerator, denominator);
 3015|       |          // Round half to even.
 3016|      0|          if (result > 0 || (result == 0 && (digit % 2) != 0))
  ------------------
  |  Branch (3016:15): [True: 0, False: 0]
  |  Branch (3016:30): [True: 0, False: 0]
  |  Branch (3016:45): [True: 0, False: 0]
  ------------------
 3017|      0|            ++data[num_digits - 1];
 3018|      0|        }
 3019|      0|        buf.try_resize(to_unsigned(num_digits));
 3020|      0|        exp10 -= num_digits - 1;
 3021|      0|        return;
 3022|      0|      }
 3023|      0|      numerator *= 10;
 3024|      0|      lower *= 10;
 3025|      0|      if (upper != &lower) *upper *= 10;
  ------------------
  |  Branch (3025:11): [True: 0, False: 0]
  ------------------
 3026|      0|    }
 3027|      0|  }
 3028|       |  // Generate the given number of digits.
 3029|    984|  exp10 -= num_digits - 1;
 3030|    984|  if (num_digits <= 0) {
  ------------------
  |  Branch (3030:7): [True: 0, False: 984]
  ------------------
 3031|      0|    auto digit = '0';
 3032|      0|    if (num_digits == 0) {
  ------------------
  |  Branch (3032:9): [True: 0, False: 0]
  ------------------
 3033|      0|      denominator *= 10;
 3034|      0|      digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0';
  ------------------
  |  Branch (3034:15): [True: 0, False: 0]
  ------------------
 3035|      0|    }
 3036|      0|    buf.push_back(digit);
 3037|      0|    return;
 3038|      0|  }
 3039|    984|  buf.try_resize(to_unsigned(num_digits));
 3040|  49.2k|  for (int i = 0; i < num_digits - 1; ++i) {
  ------------------
  |  Branch (3040:19): [True: 48.2k, False: 984]
  ------------------
 3041|  48.2k|    int digit = numerator.divmod_assign(denominator);
 3042|  48.2k|    buf[i] = static_cast<char>('0' + digit);
 3043|  48.2k|    numerator *= 10;
 3044|  48.2k|  }
 3045|    984|  int digit = numerator.divmod_assign(denominator);
 3046|    984|  auto result = add_compare(numerator, numerator, denominator);
 3047|    984|  if (result > 0 || (result == 0 && (digit % 2) != 0)) {
  ------------------
  |  Branch (3047:7): [True: 270, False: 714]
  |  Branch (3047:22): [True: 11, False: 703]
  |  Branch (3047:37): [True: 4, False: 7]
  ------------------
 3048|    274|    if (digit == 9) {
  ------------------
  |  Branch (3048:9): [True: 39, False: 235]
  ------------------
 3049|     39|      const auto overflow = '0' + 10;
 3050|     39|      buf[num_digits - 1] = overflow;
 3051|       |      // Propagate the carry.
 3052|    119|      for (int i = num_digits - 1; i > 0 && buf[i] == overflow; --i) {
  ------------------
  |  Branch (3052:36): [True: 119, False: 0]
  |  Branch (3052:45): [True: 80, False: 39]
  ------------------
 3053|     80|        buf[i] = '0';
 3054|     80|        ++buf[i - 1];
 3055|     80|      }
 3056|     39|      if (buf[0] == overflow) {
  ------------------
  |  Branch (3056:11): [True: 0, False: 39]
  ------------------
 3057|      0|        buf[0] = '1';
 3058|      0|        if ((flags & dragon::fixed) != 0)
  ------------------
  |  Branch (3058:13): [True: 0, False: 0]
  ------------------
 3059|      0|          buf.push_back('0');
 3060|      0|        else
 3061|      0|          ++exp10;
 3062|      0|      }
 3063|     39|      return;
 3064|     39|    }
 3065|    235|    ++digit;
 3066|    235|  }
 3067|    945|  buf[num_digits - 1] = static_cast<char>('0' + digit);
 3068|    945|}
_ZN3fmt3v1219basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEE10deallocateEv:
  786|  8.32k|  FMT_CONSTEXPR20 void deallocate() {
  787|  8.32k|    T* data = this->data();
  788|  8.32k|    if (data != store_) alloc_.deallocate(data, this->capacity());
  ------------------
  |  Branch (788:9): [True: 0, False: 8.32k]
  ------------------
  789|  8.32k|  }
_ZN3fmt3v1219basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEE4moveERS5_:
  850|  4.39k|  FMT_CONSTEXPR20 void move(basic_memory_buffer& other) {
  851|  4.39k|    T* data = other.data();
  852|  4.39k|    size_t size = other.size(), capacity = other.capacity();
  853|  4.39k|    if (!move_alloc(other)) return;
  ------------------
  |  Branch (853:9): [True: 0, False: 4.39k]
  ------------------
  854|  4.39k|    if (data == other.store_) {
  ------------------
  |  Branch (854:9): [True: 4.39k, False: 0]
  ------------------
  855|  4.39k|      this->set(store_, capacity);
  856|  4.39k|      detail::copy<T>(other.store_, other.store_ + size, store_);
  857|  4.39k|    } else {
  858|      0|      this->set(data, capacity);
  859|       |      // Set pointer to the inline array so that delete is not called
  860|       |      // when deallocating.
  861|      0|      other.set(other.store_, 0);
  862|      0|      other.clear();
  863|      0|    }
  864|  4.39k|    this->resize(size);
  865|  4.39k|  }
_ZN3fmt3v126detaileqENS1_9allocatorIjEES3_:
  739|  4.39k|  constexpr friend auto operator==(allocator, allocator) noexcept -> bool {
  740|  4.39k|    return true;  // All instances of this allocator are equivalent.
  741|  4.39k|  }
_ZN3fmt3v1219basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEE10move_allocIS4_TnNSt3__19enable_ifIXntsr3std16allocator_traitsIT_E38propagate_on_container_move_assignmentE5valueEiE4typeELi0EEEbRS5_:
  839|  4.39k|  FMT_CONSTEXPR20 auto move_alloc(basic_memory_buffer& other) -> bool {
  840|  4.39k|    T* data = other.data();
  841|  4.39k|    if (alloc_ == other.alloc_ || data == other.store_) return true;
  ------------------
  |  Branch (841:9): [True: 4.39k, False: 0]
  |  Branch (841:35): [True: 0, False: 0]
  ------------------
  842|      0|    size_t size = other.size();
  843|       |    // Perform copy operation, allocators are different.
  844|      0|    this->resize(size);
  845|      0|    detail::copy<T>(data, data + size, this->data());
  846|      0|    return false;
  847|  4.39k|  }
_ZN3fmt3v126detail10to_pointerIcEEPT_NS0_14basic_appenderIS3_EEm:
  511|    807|FMT_CONSTEXPR20 auto to_pointer(basic_appender<T> it, size_t n) -> T* {
  512|    807|  buffer<T>& buf = get_container(it);
  513|    807|  buf.try_reserve(buf.size() + n);
  514|    807|  auto size = buf.size();
  515|    807|  if (buf.capacity() < size + n) return nullptr;
  ------------------
  |  Branch (515:7): [True: 0, False: 807]
  ------------------
  516|    807|  buf.try_resize(size + n);
  517|    807|  return buf.data() + size;
  518|    807|}
_ZN3fmt3v126detail12write2digitsIcEEvPT_m:
 1205|  7.15k|FMT_CONSTEXPR20 FMT_INLINE void write2digits(Char* out, size_t value) {
 1206|  7.15k|  if (!is_constant_evaluated() && std::is_same<Char, char>::value &&
  ------------------
  |  Branch (1206:7): [True: 0, Folded]
  |  Branch (1206:35): [True: 0, Folded]
  ------------------
 1207|  7.15k|      !FMT_OPTIMIZE_SIZE) {
  ------------------
  |  |  295|      0|#  define FMT_OPTIMIZE_SIZE 0
  ------------------
  |  Branch (1207:7): [True: 0, Folded]
  ------------------
 1208|  7.15k|    memcpy(out, digits2(value), 2);
 1209|  7.15k|    return;
 1210|  7.15k|  }
 1211|      0|  *out++ = static_cast<Char>('0' + value / 10);
 1212|      0|  *out = static_cast<Char>('0' + value % 10);
 1213|      0|}
_ZN3fmt3v126detail17do_format_decimalIcmEEPT_S4_T0_i:
 1229|    982|    -> Char* {
 1230|    982|  FMT_ASSERT(size >= count_digits(value), "invalid digit count");
  ------------------
  |  |  394|    982|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (394:6): [True: 982, False: 0]
  |  |  ------------------
  |  |  395|    982|         ? (void)0                                                          \
  |  |  396|    982|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1231|    982|  unsigned n = to_unsigned(size);
 1232|  6.43k|  while (value >= 100) {
  ------------------
  |  Branch (1232:10): [True: 5.45k, False: 982]
  ------------------
 1233|  5.45k|    n -= 2;
 1234|  5.45k|    if (!is_constant_evaluated() && sizeof(UInt) == 4) {
  ------------------
  |  Branch (1234:9): [True: 0, Folded]
  |  Branch (1234:37): [Folded, False: 0]
  ------------------
 1235|      0|      auto p = value * static_cast<uint64_t>((1ull << 39) / 100 + 1);
 1236|      0|      write2digits_i(out + n, p >> (39 - 7) & ((1 << 7) - 1));
 1237|      0|      value = static_cast<UInt>(p >> 39) +
 1238|      0|              (static_cast<UInt>(value >= (100u << 25)) << 25);
 1239|  5.45k|    } else {
 1240|       |      // Integer division is slow so do it for a group of two digits instead
 1241|       |      // of for every digit. The idea comes from the talk by Alexandrescu
 1242|       |      // "Three Optimization Tips for C++". See speed-test for a comparison.
 1243|  5.45k|      write2digits(out + n, static_cast<unsigned>(value % 100));
 1244|  5.45k|      value /= 100;
 1245|  5.45k|    }
 1246|  5.45k|  }
 1247|    982|  if (value >= 10) {
  ------------------
  |  Branch (1247:7): [True: 567, False: 415]
  ------------------
 1248|    567|    n -= 2;
 1249|    567|    write2digits(out + n, static_cast<unsigned>(value));
 1250|    567|  } else {
 1251|    415|    out[--n] = static_cast<Char>('0' + value);
 1252|    415|  }
 1253|    982|  return out + n;
 1254|    982|}
_ZN3fmt3v126detail14format_decimalIcmEEPT_S4_T0_i:
 1258|    738|                                             int num_digits) -> Char* {
 1259|    738|  do_format_decimal(out, value, num_digits);
 1260|    738|  return out + num_digits;
 1261|    738|}
_ZN3fmt3v126detail14format_decimalIcmNS0_14basic_appenderIcEETnNSt3__19enable_ifIXntsr3std10is_pointerINS5_9remove_cvINS5_16remove_referenceIT1_E4typeEE4typeEEE5valueEiE4typeELi0EEES9_S9_T0_i:
 1266|    244|    -> OutputIt {
 1267|    244|  if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
  ------------------
  |  Branch (1267:12): [True: 244, False: 0]
  ------------------
 1268|    244|    do_format_decimal(ptr, value, num_digits);
 1269|    244|    return out;
 1270|    244|  }
 1271|       |  // Buffer is large enough to hold all digits (digits10 + 1).
 1272|      0|  char buffer[digits10<UInt>() + 1];
 1273|      0|  if (is_constant_evaluated()) fill_n(buffer, sizeof(buffer), '\0');
  ------------------
  |  Branch (1273:7): [Folded, False: 0]
  ------------------
 1274|      0|  do_format_decimal(buffer, value, num_digits);
 1275|      0|  return copy_noinline<Char>(buffer, buffer + num_digits, out);
 1276|    244|}
_ZN3fmt3v126detail7reserveIcEENS0_14basic_appenderIT_EES5_m:
  486|  1.59k|    -> basic_appender<T> {
  487|  1.59k|  buffer<T>& buf = get_container(it);
  488|  1.59k|  buf.try_reserve(buf.size() + n);
  489|  1.59k|  return it;
  490|  1.59k|}
_ZN3fmt3v126detail13base_iteratorINS0_14basic_appenderIcEEEET_S5_S5_:
  530|  1.59k|constexpr auto base_iterator(Iterator, Iterator it) -> Iterator {
  531|  1.59k|  return it;
  532|  1.59k|}
_ZN3fmt3v126detail15write_nonfiniteIcNS0_14basic_appenderIcEEEET0_S5_bNS0_12format_specsENS0_4signE:
 2372|    190|                                     format_specs specs, sign s) -> OutputIt {
 2373|    190|  auto str =
 2374|    190|      isnan ? (specs.upper() ? "NAN" : "nan") : (specs.upper() ? "INF" : "inf");
  ------------------
  |  Branch (2374:7): [True: 188, False: 2]
  |  Branch (2374:16): [True: 0, False: 188]
  |  Branch (2374:50): [True: 0, False: 2]
  ------------------
 2375|    190|  constexpr size_t str_size = 3;
 2376|    190|  auto size = str_size + (s != sign::none ? 1 : 0);
  ------------------
  |  Branch (2376:27): [True: 182, False: 8]
  ------------------
 2377|       |  // Replace '0'-padding with space for non-finite values.
 2378|    190|  const bool is_zero_fill =
 2379|    190|      specs.fill_size() == 1 && specs.fill_unit<Char>() == '0';
  ------------------
  |  Branch (2379:7): [True: 190, False: 0]
  |  Branch (2379:33): [True: 0, False: 190]
  ------------------
 2380|    190|  if (is_zero_fill) specs.set_fill(' ');
  ------------------
  |  Branch (2380:7): [True: 0, False: 190]
  ------------------
 2381|    190|  return write_padded<Char>(out, specs, size,
 2382|    190|                            [=](reserve_iterator<OutputIt> it) {
 2383|    190|                              if (s != sign::none)
 2384|    190|                                *it++ = detail::getsign<Char>(s);
 2385|    190|                              return copy<Char>(str, str + str_size, it);
 2386|    190|                            });
 2387|    190|}
_ZN3fmt3v126detail12write_paddedIcLNS0_5alignE1ENS0_14basic_appenderIcEEZNS1_15write_nonfiniteIcS5_EET0_S7_bNS0_12format_specsENS0_4signEEUlS5_E_EET1_SB_RKS8_mOT2_:
 1733|    190|                            size_t size, F&& f) -> OutputIt {
 1734|    190|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1735|    190|}
_ZN3fmt3v126detail12write_paddedIcLNS0_5alignE1ENS0_14basic_appenderIcEERZNS1_15write_nonfiniteIcS5_EET0_S7_bNS0_12format_specsENS0_4signEEUlS5_E_EET1_SC_RKS8_mmOT2_:
 1712|    190|                                size_t size, size_t width, F&& f) -> OutputIt {
 1713|    190|  static_assert(default_align == align::left || default_align == align::right,
 1714|    190|                "");
 1715|    190|  unsigned spec_width = to_unsigned(specs.width);
 1716|    190|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1716:20): [True: 0, False: 190]
  ------------------
 1717|       |  // Shifts are encoded as string literals because static constexpr is not
 1718|       |  // supported in constexpr functions.
 1719|    190|  auto* shifts =
 1720|    190|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1720:7): [True: 190, Folded]
  ------------------
 1721|    190|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1722|    190|  size_t right_padding = padding - left_padding;
 1723|    190|  auto it = reserve(out, size + padding * specs.fill_size());
 1724|    190|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1724:7): [True: 0, False: 190]
  ------------------
 1725|    190|  it = f(it);
 1726|    190|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1726:7): [True: 0, False: 190]
  ------------------
 1727|    190|  return base_iterator(out, it);
 1728|    190|}
_ZZN3fmt3v126detail15write_nonfiniteIcNS0_14basic_appenderIcEEEET0_S5_bNS0_12format_specsENS0_4signEENKUlS4_E_clES4_:
 2382|    190|                            [=](reserve_iterator<OutputIt> it) {
 2383|    190|                              if (s != sign::none)
  ------------------
  |  Branch (2383:35): [True: 182, False: 8]
  ------------------
 2384|    182|                                *it++ = detail::getsign<Char>(s);
 2385|    190|                              return copy<Char>(str, str + str_size, it);
 2386|    190|                            });
_ZN3fmt3v126detail23fallback_digit_groupingIcEC2ENS0_10locale_refEb:
 2508|    349|  constexpr fallback_digit_grouping(locale_ref, bool) {}
_ZNK3fmt3v126detail23fallback_digit_groupingIcE16count_separatorsEi:
 2512|    349|  constexpr auto count_separators(int) const -> int { return 0; }
_ZNK3fmt3v126detail23fallback_digit_groupingIcE13has_separatorEv:
 2510|    349|  constexpr auto has_separator() const -> bool { return false; }
_ZN3fmt3v126detail6selectILb0EPcNS0_14basic_appenderIcEETnNSt3__19enable_ifIXntT_EiE4typeELi0EEET1_T0_SA_:
 1691|    563|auto select(T, F false_value) -> F {
 1692|    563|  return false_value;
 1693|    563|}
_ZN3fmt3v126detail14write_exponentIcNS0_14basic_appenderIcEEEET0_iS5_:
 1563|    516|FMT_CONSTEXPR auto write_exponent(int exp, OutputIt out) -> OutputIt {
 1564|    516|  FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range");
  ------------------
  |  |  394|  1.03k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (394:7): [True: 516, False: 0]
  |  |  |  Branch (394:7): [True: 516, False: 0]
  |  |  ------------------
  |  |  395|    516|         ? (void)0                                                          \
  |  |  396|    516|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1565|    516|  if (exp < 0) {
  ------------------
  |  Branch (1565:7): [True: 362, False: 154]
  ------------------
 1566|    362|    *out++ = static_cast<Char>('-');
 1567|    362|    exp = -exp;
 1568|    362|  } else {
 1569|    154|    *out++ = static_cast<Char>('+');
 1570|    154|  }
 1571|    516|  auto uexp = static_cast<uint32_t>(exp);
 1572|    516|  if (is_constant_evaluated()) {
  ------------------
  |  Branch (1572:7): [Folded, False: 516]
  ------------------
 1573|      0|    if (uexp < 10) *out++ = '0';
  ------------------
  |  Branch (1573:9): [True: 0, False: 0]
  ------------------
 1574|      0|    return format_decimal<Char>(out, uexp, count_digits(uexp));
 1575|      0|  }
 1576|    516|  if (uexp >= 100u) {
  ------------------
  |  Branch (1576:7): [True: 378, False: 138]
  ------------------
 1577|    378|    const char* top = digits2(uexp / 100);
 1578|    378|    if (uexp >= 1000u) *out++ = static_cast<Char>(top[0]);
  ------------------
  |  Branch (1578:9): [True: 0, False: 378]
  ------------------
 1579|    378|    *out++ = static_cast<Char>(top[1]);
 1580|    378|    uexp %= 100;
 1581|    378|  }
 1582|    516|  const char* d = digits2(uexp);
 1583|    516|  *out++ = static_cast<Char>(d[0]);
 1584|    516|  *out++ = static_cast<Char>(d[1]);
 1585|    516|  return out;
 1586|    516|}
_ZN3fmt3v126detail21default_arg_formatterIcEclIdTnNSt3__19enable_ifIXsr10is_builtinIT_EE5valueEiE4typeELi0EEEvS7_:
 3684|  1.08k|  void operator()(T value) {
 3685|  1.08k|    write<Char>(out, value);
 3686|  1.08k|  }
_ZN3fmt3v126detail5writeIcNS0_14basic_appenderIcEEdTnNSt3__19enable_ifIXsr13is_fast_floatIT1_EE5valueEiE4typeELi0EEET0_SA_S7_:
 3527|  1.08k|FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt {
 3528|  1.08k|  if (is_constant_evaluated()) return write<Char>(out, value, format_specs());
  ------------------
  |  Branch (3528:7): [Folded, False: 1.08k]
  ------------------
 3529|       |
 3530|  1.08k|  auto s = detail::signbit(value) ? sign::minus : sign::none;
  ------------------
  |  Branch (3530:12): [True: 465, False: 615]
  ------------------
 3531|  1.08k|  auto mask = exponent_mask<fast_float_t<T>>();
 3532|  1.08k|  if ((bit_cast<decltype(mask)>(value) & mask) == mask)
  ------------------
  |  Branch (3532:7): [True: 95, False: 985]
  ------------------
 3533|     95|    return write_nonfinite<Char>(out, std::isnan(value), {}, s);
 3534|       |
 3535|    985|  auto dec = dragonbox::to_decimal(static_cast<fast_float_t<T>>(value));
 3536|    985|  auto significand = dec.significand;
 3537|    985|  int significand_size = count_digits(significand);
 3538|    985|  int exponent = dec.exponent + significand_size - 1;
 3539|    985|  if (use_fixed(exponent, detail::exp_upper<T>())) {
  ------------------
  |  Branch (3539:7): [True: 422, False: 563]
  ------------------
 3540|    422|    return write_fixed<Char, fallback_digit_grouping<Char>>(
 3541|    422|        out, dec, significand_size, Char('.'), {}, s);
 3542|    422|  }
 3543|       |
 3544|       |  // Write value in the exponential format.
 3545|    563|  const char* prefix = "e+";
 3546|    563|  int abs_exponent = exponent;
 3547|    563|  if (exponent < 0) {
  ------------------
  |  Branch (3547:7): [True: 362, False: 201]
  ------------------
 3548|    362|    abs_exponent = -exponent;
 3549|    362|    prefix = "e-";
 3550|    362|  }
 3551|    563|  auto has_decimal_point = significand_size != 1;
 3552|    563|  size_t size = std::is_pointer<OutputIt>::value
  ------------------
  |  Branch (3552:17): [Folded, False: 563]
  ------------------
 3553|    563|                    ? 0u
 3554|    563|                    : to_unsigned((s != sign::none ? 1 : 0) + significand_size +
  ------------------
  |  Branch (3554:36): [True: 203, False: 360]
  ------------------
 3555|    563|                                  (has_decimal_point ? 1 : 0) +
  ------------------
  |  Branch (3555:36): [True: 560, False: 3]
  ------------------
 3556|    563|                                  (abs_exponent >= 100 ? 5 : 4));
  ------------------
  |  Branch (3556:36): [True: 378, False: 185]
  ------------------
 3557|    563|  if (auto ptr = to_pointer<Char>(out, size)) {
  ------------------
  |  Branch (3557:12): [True: 563, False: 0]
  ------------------
 3558|    563|    if (s != sign::none) *ptr++ = Char('-');
  ------------------
  |  Branch (3558:9): [True: 203, False: 360]
  ------------------
 3559|    563|    if (has_decimal_point) {
  ------------------
  |  Branch (3559:9): [True: 560, False: 3]
  ------------------
 3560|    560|      auto begin = ptr;
 3561|    560|      ptr = format_decimal<Char>(ptr, significand, significand_size + 1);
 3562|    560|      *begin = begin[1];
 3563|    560|      begin[1] = '.';
 3564|    560|    } else {
 3565|      3|      *ptr++ = static_cast<Char>('0' + significand);
 3566|      3|    }
 3567|    563|    if (std::is_same<Char, char>::value) {
  ------------------
  |  Branch (3567:9): [True: 563, Folded]
  ------------------
 3568|    563|      memcpy(ptr, prefix, 2);
 3569|    563|      ptr += 2;
 3570|    563|    } else {
 3571|      0|      *ptr++ = static_cast<Char>(prefix[0]);
 3572|      0|      *ptr++ = static_cast<Char>(prefix[1]);
 3573|      0|    }
 3574|    563|    if (abs_exponent >= 100) {
  ------------------
  |  Branch (3574:9): [True: 378, False: 185]
  ------------------
 3575|    378|      *ptr++ = static_cast<Char>('0' + abs_exponent / 100);
 3576|    378|      abs_exponent %= 100;
 3577|    378|    }
 3578|    563|    write2digits(ptr, static_cast<unsigned>(abs_exponent));
 3579|    563|    return select<std::is_pointer<OutputIt>::value>(ptr + 2, out);
 3580|    563|  }
 3581|      0|  auto it = reserve(out, size);
 3582|      0|  if (s != sign::none) *it++ = Char('-');
  ------------------
  |  Branch (3582:7): [True: 0, False: 0]
  ------------------
 3583|       |  // Insert a decimal point after the first digit and add an exponent.
 3584|      0|  it = write_significand(it, significand, significand_size, 1,
 3585|      0|                         has_decimal_point ? Char('.') : Char());
  ------------------
  |  Branch (3585:26): [True: 0, False: 0]
  ------------------
 3586|      0|  *it++ = Char('e');
 3587|      0|  it = write_exponent<Char>(exponent, it);
 3588|      0|  return base_iterator(out, it);
 3589|    563|}
_ZN3fmt3v126detail7signbitIdTnNSt3__19enable_ifIXsr17is_floating_pointIT_EE5valueEiE4typeELi0EEEbS5_:
 2666|  2.16k|FMT_INLINE FMT_CONSTEXPR auto signbit(T value) -> bool {
 2667|  2.16k|  if (is_constant_evaluated()) {
  ------------------
  |  Branch (2667:7): [Folded, False: 2.16k]
  ------------------
 2668|       |#ifdef __cpp_if_constexpr
 2669|       |    if constexpr (std::numeric_limits<double>::is_iec559) {
 2670|       |      auto bits = detail::bit_cast<uint64_t>(static_cast<double>(value));
 2671|       |      return (bits >> (num_bits<uint64_t>() - 1)) != 0;
 2672|       |    }
 2673|       |#endif
 2674|      0|  }
 2675|  2.16k|  return std::signbit(static_cast<double>(value));
 2676|  2.16k|}
_ZN3fmt3v126detail9exp_upperIdEEiv:
 2494|  1.97k|template <typename T> FMT_CONSTEVAL auto exp_upper() -> int {
 2495|  1.97k|  return std::numeric_limits<T>::digits10 != 0
  ------------------
  |  Branch (2495:10): [True: 1.97k, Folded]
  ------------------
 2496|  1.97k|             ? min_of(16, std::numeric_limits<T>::digits10 + 1)
 2497|  1.97k|             : 16;
 2498|  1.97k|}
_ZN3fmt3v126detail11write_fixedIcNS1_23fallback_digit_groupingIcEENS0_14basic_appenderIcEENS1_9dragonbox10decimal_fpIdEEEET1_SA_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refE:
 2525|    422|                                 locale_ref loc = {}) -> OutputIt {
 2526|    422|  using iterator = reserve_iterator<OutputIt>;
 2527|       |
 2528|    422|  int exp = f.exponent + significand_size;
 2529|    422|  long long size = significand_size + (s != sign::none ? 1 : 0);
  ------------------
  |  Branch (2529:40): [True: 171, False: 251]
  ------------------
 2530|    422|  if (f.exponent >= 0) {
  ------------------
  |  Branch (2530:7): [True: 171, False: 251]
  ------------------
 2531|       |    // 1234e5 -> 123400000[.0+]
 2532|    171|    size += f.exponent;
 2533|    171|    int num_zeros = specs.precision - exp;
 2534|    171|    abort_fuzzing_if(num_zeros > 5000);
 2535|    171|    if (specs.alt()) {
  ------------------
  |  Branch (2535:9): [True: 0, False: 171]
  ------------------
 2536|      0|      ++size;
 2537|      0|      if (num_zeros <= 0 && specs.type() != presentation_type::fixed)
  ------------------
  |  Branch (2537:11): [True: 0, False: 0]
  |  Branch (2537:29): [True: 0, False: 0]
  ------------------
 2538|      0|        num_zeros = 0;
 2539|      0|      if (num_zeros > 0) size += num_zeros;
  ------------------
  |  Branch (2539:11): [True: 0, False: 0]
  ------------------
 2540|      0|    }
 2541|    171|    auto grouping = Grouping(loc, specs.localized());
 2542|    171|    size += grouping.count_separators(exp);
 2543|    171|    return write_padded<Char, align::right>(
 2544|    171|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2545|    171|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2546|    171|          it = write_significand<Char>(it, f.significand, significand_size,
 2547|    171|                                       f.exponent, grouping);
 2548|    171|          if (!specs.alt()) return it;
 2549|    171|          *it++ = decimal_point;
 2550|    171|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
 2551|    171|        });
 2552|    171|  }
 2553|    251|  if (exp > 0) {
  ------------------
  |  Branch (2553:7): [True: 178, False: 73]
  ------------------
 2554|       |    // 1234e-2 -> 12.34[0+]
 2555|    178|    int num_zeros = specs.alt() ? specs.precision - significand_size : 0;
  ------------------
  |  Branch (2555:21): [True: 0, False: 178]
  ------------------
 2556|    178|    size += 1 + max_of(num_zeros, 0);
 2557|    178|    auto grouping = Grouping(loc, specs.localized());
 2558|    178|    size += grouping.count_separators(exp);
 2559|    178|    return write_padded<Char, align::right>(
 2560|    178|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2561|    178|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2562|    178|          it = write_significand(it, f.significand, significand_size, exp,
 2563|    178|                                 decimal_point, grouping);
 2564|    178|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
 2565|    178|        });
 2566|    178|  }
 2567|       |  // 1234e-6 -> 0.001234
 2568|     73|  int num_zeros = -exp;
 2569|     73|  if (significand_size == 0 && specs.precision >= 0 &&
  ------------------
  |  Branch (2569:7): [True: 0, False: 73]
  |  Branch (2569:32): [True: 0, False: 0]
  ------------------
 2570|      0|      specs.precision < num_zeros) {
  ------------------
  |  Branch (2570:7): [True: 0, False: 0]
  ------------------
 2571|      0|    num_zeros = specs.precision;
 2572|      0|  }
 2573|     73|  bool pointy = num_zeros != 0 || significand_size != 0 || specs.alt();
  ------------------
  |  Branch (2573:17): [True: 39, False: 34]
  |  Branch (2573:35): [True: 34, False: 0]
  |  Branch (2573:60): [True: 0, False: 0]
  ------------------
 2574|     73|  size += 1 + (pointy ? 1 : 0) + num_zeros;
  ------------------
  |  Branch (2574:16): [True: 73, False: 0]
  ------------------
 2575|     73|  return write_padded<Char, align::right>(
 2576|     73|      out, specs, static_cast<size_t>(size), [&](iterator it) {
 2577|     73|        if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2578|     73|        *it++ = Char('0');
 2579|     73|        if (!pointy) return it;
 2580|     73|        *it++ = decimal_point;
 2581|     73|        it = detail::fill_n(it, num_zeros, Char('0'));
 2582|     73|        return write_significand<Char>(it, f.significand, significand_size);
 2583|     73|      });
 2584|    251|}
_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_:
 1733|    171|                            size_t size, F&& f) -> OutputIt {
 1734|    171|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1735|    171|}
_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_:
 1712|    171|                                size_t size, size_t width, F&& f) -> OutputIt {
 1713|    171|  static_assert(default_align == align::left || default_align == align::right,
 1714|    171|                "");
 1715|    171|  unsigned spec_width = to_unsigned(specs.width);
 1716|    171|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1716:20): [True: 0, False: 171]
  ------------------
 1717|       |  // Shifts are encoded as string literals because static constexpr is not
 1718|       |  // supported in constexpr functions.
 1719|    171|  auto* shifts =
 1720|    171|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1720:7): [Folded, False: 171]
  ------------------
 1721|    171|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1722|    171|  size_t right_padding = padding - left_padding;
 1723|    171|  auto it = reserve(out, size + padding * specs.fill_size());
 1724|    171|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1724:7): [True: 0, False: 171]
  ------------------
 1725|    171|  it = f(it);
 1726|    171|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1726:7): [True: 0, False: 171]
  ------------------
 1727|    171|  return base_iterator(out, it);
 1728|    171|}
_ZZN3fmt3v126detail11write_fixedIcNS1_23fallback_digit_groupingIcEENS0_14basic_appenderIcEENS1_9dragonbox10decimal_fpIdEEEET1_SA_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEENKUlS6_E_clES6_:
 2544|    171|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2545|    171|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2545:15): [True: 55, False: 116]
  ------------------
 2546|    171|          it = write_significand<Char>(it, f.significand, significand_size,
 2547|    171|                                       f.exponent, grouping);
 2548|    171|          if (!specs.alt()) return it;
  ------------------
  |  Branch (2548:15): [True: 171, False: 0]
  ------------------
 2549|      0|          *it++ = decimal_point;
 2550|      0|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
  ------------------
  |  Branch (2550:18): [True: 0, False: 0]
  ------------------
 2551|    171|        });
_ZN3fmt3v126detail17write_significandIcNS0_14basic_appenderIcEEmNS1_23fallback_digit_groupingIcEEEET0_S7_T1_iiRKT2_:
 2417|    171|                                       const Grouping& grouping) -> OutputIt {
 2418|    171|  if (!grouping.has_separator()) {
  ------------------
  |  Branch (2418:7): [True: 171, False: 0]
  ------------------
 2419|    171|    out = write_significand<Char>(out, significand, significand_size);
 2420|    171|    return detail::fill_n(out, exponent, static_cast<Char>('0'));
 2421|    171|  }
 2422|      0|  auto buffer = memory_buffer();
 2423|      0|  write_significand<char>(appender(buffer), significand, significand_size);
 2424|      0|  detail::fill_n(appender(buffer), exponent, '0');
 2425|      0|  return grouping.apply(out, string_view(buffer.data(), buffer.size()));
 2426|    171|}
_ZN3fmt3v126detail17write_significandIcNS0_14basic_appenderIcEEmEET0_S5_T1_i:
 2411|    244|                              int significand_size) -> OutputIt {
 2412|    244|  return format_decimal<Char>(out, significand, significand_size);
 2413|    244|}
_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_:
 1733|    178|                            size_t size, F&& f) -> OutputIt {
 1734|    178|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1735|    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_:
 1712|    178|                                size_t size, size_t width, F&& f) -> OutputIt {
 1713|    178|  static_assert(default_align == align::left || default_align == align::right,
 1714|    178|                "");
 1715|    178|  unsigned spec_width = to_unsigned(specs.width);
 1716|    178|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1716:20): [True: 0, False: 178]
  ------------------
 1717|       |  // Shifts are encoded as string literals because static constexpr is not
 1718|       |  // supported in constexpr functions.
 1719|    178|  auto* shifts =
 1720|    178|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1720:7): [Folded, False: 178]
  ------------------
 1721|    178|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1722|    178|  size_t right_padding = padding - left_padding;
 1723|    178|  auto it = reserve(out, size + padding * specs.fill_size());
 1724|    178|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1724:7): [True: 0, False: 178]
  ------------------
 1725|    178|  it = f(it);
 1726|    178|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1726:7): [True: 0, False: 178]
  ------------------
 1727|    178|  return base_iterator(out, it);
 1728|    178|}
_ZZN3fmt3v126detail11write_fixedIcNS1_23fallback_digit_groupingIcEENS0_14basic_appenderIcEENS1_9dragonbox10decimal_fpIdEEEET1_SA_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEENKUlS6_E0_clES6_:
 2560|    178|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2561|    178|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2561:15): [True: 74, False: 104]
  ------------------
 2562|    178|          it = write_significand(it, f.significand, significand_size, exp,
 2563|    178|                                 decimal_point, grouping);
 2564|    178|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
  ------------------
  |  Branch (2564:18): [True: 0, False: 178]
  ------------------
 2565|    178|        });
_ZN3fmt3v126detail17write_significandINS0_14basic_appenderIcEEcmNS1_23fallback_digit_groupingIcEEEET_S7_T1_iiT0_RKT2_:
 2478|    178|                                       const Grouping& grouping) -> OutputIt {
 2479|    178|  if (!grouping.has_separator()) {
  ------------------
  |  Branch (2479:7): [True: 178, False: 0]
  ------------------
 2480|    178|    return write_significand(out, significand, significand_size, integral_size,
 2481|    178|                             decimal_point);
 2482|    178|  }
 2483|      0|  auto buffer = basic_memory_buffer<Char>();
 2484|      0|  write_significand(basic_appender<Char>(buffer), significand, significand_size,
 2485|      0|                    integral_size, decimal_point);
 2486|      0|  grouping.apply(
 2487|      0|      out, basic_string_view<Char>(buffer.data(), to_unsigned(integral_size)));
 2488|      0|  return detail::copy_noinline<Char>(buffer.data() + integral_size,
 2489|      0|                                     buffer.end(), out);
 2490|    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_:
 1733|     73|                            size_t size, F&& f) -> OutputIt {
 1734|     73|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1735|     73|}
_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_:
 1712|     73|                                size_t size, size_t width, F&& f) -> OutputIt {
 1713|     73|  static_assert(default_align == align::left || default_align == align::right,
 1714|     73|                "");
 1715|     73|  unsigned spec_width = to_unsigned(specs.width);
 1716|     73|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1716:20): [True: 0, False: 73]
  ------------------
 1717|       |  // Shifts are encoded as string literals because static constexpr is not
 1718|       |  // supported in constexpr functions.
 1719|     73|  auto* shifts =
 1720|     73|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1720:7): [Folded, False: 73]
  ------------------
 1721|     73|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1722|     73|  size_t right_padding = padding - left_padding;
 1723|     73|  auto it = reserve(out, size + padding * specs.fill_size());
 1724|     73|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1724:7): [True: 0, False: 73]
  ------------------
 1725|     73|  it = f(it);
 1726|     73|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1726:7): [True: 0, False: 73]
  ------------------
 1727|     73|  return base_iterator(out, it);
 1728|     73|}
_ZZN3fmt3v126detail11write_fixedIcNS1_23fallback_digit_groupingIcEENS0_14basic_appenderIcEENS1_9dragonbox10decimal_fpIdEEEET1_SA_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEENKUlS6_E1_clES6_:
 2576|     73|      out, specs, static_cast<size_t>(size), [&](iterator it) {
 2577|     73|        if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2577:13): [True: 42, False: 31]
  ------------------
 2578|     73|        *it++ = Char('0');
 2579|     73|        if (!pointy) return it;
  ------------------
  |  Branch (2579:13): [True: 0, False: 73]
  ------------------
 2580|     73|        *it++ = decimal_point;
 2581|     73|        it = detail::fill_n(it, num_zeros, Char('0'));
 2582|     73|        return write_significand<Char>(it, f.significand, significand_size);
 2583|     73|      });
_ZN3fmt3v126detail17write_significandINS0_14basic_appenderIcEEmcTnNSt3__19enable_ifIXntsr3std10is_pointerINS5_9remove_cvINS5_16remove_referenceIT_E4typeEE4typeEEE5valueEiE4typeELi0EEES9_S9_T0_iiT1_:
 2454|    178|                              Char decimal_point) -> OutputIt {
 2455|       |  // Buffer is large enough to hold digits (digits10 + 1) and a decimal point.
 2456|    178|  Char buffer[digits10<UInt>() + 2];
 2457|    178|  auto end = write_significand(buffer, significand, significand_size,
 2458|    178|                               integral_size, decimal_point);
 2459|    178|  return detail::copy_noinline<Char>(buffer, end, out);
 2460|    178|}
_ZN3fmt3v126detail17write_significandIcmTnNSt3__19enable_ifIXsr3std11is_integralIT0_EE5valueEiE4typeELi0EEEPT_S9_S5_iiS8_:
 2431|    178|                              int integral_size, Char decimal_point) -> Char* {
 2432|    178|  if (!decimal_point) return format_decimal(out, significand, significand_size);
  ------------------
  |  Branch (2432:7): [True: 0, False: 178]
  ------------------
 2433|    178|  out += significand_size + 1;
 2434|    178|  Char* end = out;
 2435|    178|  int floating_size = significand_size - integral_size;
 2436|    746|  for (int i = floating_size / 2; i > 0; --i) {
  ------------------
  |  Branch (2436:35): [True: 568, False: 178]
  ------------------
 2437|    568|    out -= 2;
 2438|    568|    write2digits(out, static_cast<size_t>(significand % 100));
 2439|    568|    significand /= 100;
 2440|    568|  }
 2441|    178|  if (floating_size % 2 != 0) {
  ------------------
  |  Branch (2441:7): [True: 116, False: 62]
  ------------------
 2442|    116|    *--out = static_cast<Char>('0' + significand % 10);
 2443|    116|    significand /= 10;
 2444|    116|  }
 2445|    178|  *--out = decimal_point;
 2446|    178|  format_decimal(out - integral_size, significand, integral_size);
 2447|    178|  return end;
 2448|    178|}
_ZN3fmt3v126detail8basic_fpIoEC2Ev:
 1596|    984|  constexpr basic_fp() : f(0), e(0) {}
_ZN3fmt3v1219basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEEC2ERKS4_:
  821|  3.93k|      : detail::buffer<T>(grow), alloc_(alloc) {
  822|  3.93k|    this->set(store_, SIZE);
  823|  3.93k|    if (detail::is_constant_evaluated()) detail::fill_n(store_, SIZE, T());
  ------------------
  |  Branch (823:9): [Folded, False: 3.93k]
  ------------------
  824|  3.93k|  }
_ZN3fmt3v1219basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEEC2EOS5_:
  871|  4.39k|      : detail::buffer<T>(grow) {
  872|  4.39k|    move(other);
  873|  4.39k|  }
_ZN3fmt3v1219basic_memory_bufferIjLm32ENS0_6detail9allocatorIjEEED2Ev:
  825|  8.32k|  FMT_CONSTEXPR20 ~basic_memory_buffer() { deallocate(); }
_ZN3fmt3v126detail11write_floatIcNS0_14basic_appenderIcEENS1_14big_decimal_fpEEET0_S6_RKT1_RKNS0_12format_specsENS0_4signEiNS0_10locale_refE:
 2629|    985|                                 int exp_upper, locale_ref loc) -> OutputIt {
 2630|    985|  if (is_constant_evaluated()) {
  ------------------
  |  Branch (2630:7): [Folded, False: 985]
  ------------------
 2631|      0|    return do_write_float<Char, fallback_digit_grouping<Char>>(out, f, specs, s,
 2632|      0|                                                               exp_upper, loc);
 2633|    985|  } else {
 2634|    985|    return do_write_float<Char, digit_grouping<Char>>(out, f, specs, s,
 2635|    985|                                                      exp_upper, loc);
 2636|    985|  }
 2637|    985|}
_ZN3fmt3v126detail14do_write_floatIcNS1_14digit_groupingIcEENS0_14basic_appenderIcEENS1_14big_decimal_fpEEET1_S8_RKT2_RKNS0_12format_specsENS0_4signEiNS0_10locale_refE:
 2590|    985|                                    int exp_upper, locale_ref loc) -> OutputIt {
 2591|    985|  Char point = specs.localized() ? detail::decimal_point<Char>(loc) : Char('.');
  ------------------
  |  Branch (2591:16): [True: 0, False: 985]
  ------------------
 2592|    985|  int significand_size = get_significand_size(f);
 2593|    985|  int exp = f.exponent + significand_size - 1;
 2594|    985|  if (specs.type() == presentation_type::fixed ||
  ------------------
  |  Branch (2594:7): [True: 0, False: 985]
  ------------------
 2595|    985|      (specs.type() != presentation_type::exp &&
  ------------------
  |  Branch (2595:8): [True: 985, False: 0]
  ------------------
 2596|    985|       use_fixed(exp, specs.precision > 0 ? specs.precision : exp_upper))) {
  ------------------
  |  Branch (2596:8): [True: 469, False: 516]
  |  Branch (2596:23): [True: 985, False: 0]
  ------------------
 2597|    469|    return write_fixed<Char, Grouping>(out, f, significand_size, point, specs,
 2598|    469|                                       s, loc);
 2599|    469|  }
 2600|       |
 2601|       |  // Write value in the exponential format.
 2602|    516|  int num_zeros = 0;
 2603|    516|  long long size = significand_size + (s != sign::none ? 1 : 0);
  ------------------
  |  Branch (2603:40): [True: 181, False: 335]
  ------------------
 2604|    516|  if (specs.alt()) {
  ------------------
  |  Branch (2604:7): [True: 0, False: 516]
  ------------------
 2605|      0|    num_zeros = max_of(specs.precision - significand_size, 0);
 2606|      0|    size += num_zeros;
 2607|    516|  } else if (significand_size == 1) {
  ------------------
  |  Branch (2607:14): [True: 0, False: 516]
  ------------------
 2608|      0|    point = Char();
 2609|      0|  }
 2610|    516|  size += (point ? 1 : 0) + compute_exp_size(exp);
  ------------------
  |  Branch (2610:12): [True: 516, False: 0]
  ------------------
 2611|    516|  char exp_char = specs.upper() ? 'E' : 'e';
  ------------------
  |  Branch (2611:19): [True: 0, False: 516]
  ------------------
 2612|    516|  auto write = [=](reserve_iterator<OutputIt> it) {
 2613|    516|    if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2614|       |    // Insert a decimal point after the first digit and add an exponent.
 2615|    516|    it = write_significand(it, f.significand, significand_size, 1, point);
 2616|    516|    if (num_zeros > 0) it = detail::fill_n(it, num_zeros, Char('0'));
 2617|    516|    *it++ = Char(exp_char);
 2618|    516|    return write_exponent<Char>(exp, it);
 2619|    516|  };
 2620|    516|  size_t usize = static_cast<size_t>(size);
 2621|    516|  return specs.width > 0
  ------------------
  |  Branch (2621:10): [True: 0, False: 516]
  ------------------
 2622|    516|             ? write_padded<Char, align::right>(out, specs, usize, write)
 2623|    516|             : base_iterator(out, write(reserve(out, usize)));
 2624|    985|}
_ZN3fmt3v126detail11write_fixedIcNS1_14digit_groupingIcEENS0_14basic_appenderIcEENS1_14big_decimal_fpEEET1_S8_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refE:
 2525|    469|                                 locale_ref loc = {}) -> OutputIt {
 2526|    469|  using iterator = reserve_iterator<OutputIt>;
 2527|       |
 2528|    469|  int exp = f.exponent + significand_size;
 2529|    469|  long long size = significand_size + (s != sign::none ? 1 : 0);
  ------------------
  |  Branch (2529:40): [True: 193, False: 276]
  ------------------
 2530|    469|  if (f.exponent >= 0) {
  ------------------
  |  Branch (2530:7): [True: 218, False: 251]
  ------------------
 2531|       |    // 1234e5 -> 123400000[.0+]
 2532|    218|    size += f.exponent;
 2533|    218|    int num_zeros = specs.precision - exp;
 2534|    218|    abort_fuzzing_if(num_zeros > 5000);
 2535|    218|    if (specs.alt()) {
  ------------------
  |  Branch (2535:9): [True: 0, False: 218]
  ------------------
 2536|      0|      ++size;
 2537|      0|      if (num_zeros <= 0 && specs.type() != presentation_type::fixed)
  ------------------
  |  Branch (2537:11): [True: 0, False: 0]
  |  Branch (2537:29): [True: 0, False: 0]
  ------------------
 2538|      0|        num_zeros = 0;
 2539|      0|      if (num_zeros > 0) size += num_zeros;
  ------------------
  |  Branch (2539:11): [True: 0, False: 0]
  ------------------
 2540|      0|    }
 2541|    218|    auto grouping = Grouping(loc, specs.localized());
 2542|    218|    size += grouping.count_separators(exp);
 2543|    218|    return write_padded<Char, align::right>(
 2544|    218|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2545|    218|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2546|    218|          it = write_significand<Char>(it, f.significand, significand_size,
 2547|    218|                                       f.exponent, grouping);
 2548|    218|          if (!specs.alt()) return it;
 2549|    218|          *it++ = decimal_point;
 2550|    218|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
 2551|    218|        });
 2552|    218|  }
 2553|    251|  if (exp > 0) {
  ------------------
  |  Branch (2553:7): [True: 178, False: 73]
  ------------------
 2554|       |    // 1234e-2 -> 12.34[0+]
 2555|    178|    int num_zeros = specs.alt() ? specs.precision - significand_size : 0;
  ------------------
  |  Branch (2555:21): [True: 0, False: 178]
  ------------------
 2556|    178|    size += 1 + max_of(num_zeros, 0);
 2557|    178|    auto grouping = Grouping(loc, specs.localized());
 2558|    178|    size += grouping.count_separators(exp);
 2559|    178|    return write_padded<Char, align::right>(
 2560|    178|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2561|    178|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2562|    178|          it = write_significand(it, f.significand, significand_size, exp,
 2563|    178|                                 decimal_point, grouping);
 2564|    178|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
 2565|    178|        });
 2566|    178|  }
 2567|       |  // 1234e-6 -> 0.001234
 2568|     73|  int num_zeros = -exp;
 2569|     73|  if (significand_size == 0 && specs.precision >= 0 &&
  ------------------
  |  Branch (2569:7): [True: 0, False: 73]
  |  Branch (2569:32): [True: 0, False: 0]
  ------------------
 2570|      0|      specs.precision < num_zeros) {
  ------------------
  |  Branch (2570:7): [True: 0, False: 0]
  ------------------
 2571|      0|    num_zeros = specs.precision;
 2572|      0|  }
 2573|     73|  bool pointy = num_zeros != 0 || significand_size != 0 || specs.alt();
  ------------------
  |  Branch (2573:17): [True: 39, False: 34]
  |  Branch (2573:35): [True: 34, False: 0]
  |  Branch (2573:60): [True: 0, False: 0]
  ------------------
 2574|     73|  size += 1 + (pointy ? 1 : 0) + num_zeros;
  ------------------
  |  Branch (2574:16): [True: 73, False: 0]
  ------------------
 2575|     73|  return write_padded<Char, align::right>(
 2576|     73|      out, specs, static_cast<size_t>(size), [&](iterator it) {
 2577|     73|        if (s != sign::none) *it++ = detail::getsign<Char>(s);
 2578|     73|        *it++ = Char('0');
 2579|     73|        if (!pointy) return it;
 2580|     73|        *it++ = decimal_point;
 2581|     73|        it = detail::fill_n(it, num_zeros, Char('0'));
 2582|     73|        return write_significand<Char>(it, f.significand, significand_size);
 2583|     73|      });
 2584|    251|}
_ZN3fmt3v126detail14digit_groupingIcEC2ENS0_10locale_refEb:
 1914|    396|  explicit digit_grouping(locale_ref loc, bool localized = true) {
 1915|    396|    if (!localized) return;
  ------------------
  |  Branch (1915:9): [True: 396, False: 0]
  ------------------
 1916|      0|    auto sep = thousands_sep<Char>(loc);
 1917|      0|    grouping_ = std::move(sep.grouping);
 1918|      0|    if (sep.thousands_sep) thousands_sep_.assign(1, sep.thousands_sep);
  ------------------
  |  Branch (1918:9): [True: 0, False: 0]
  ------------------
 1919|      0|  }
_ZNK3fmt3v126detail14digit_groupingIcE16count_separatorsEi:
 1925|    396|  auto count_separators(int num_digits) const -> int {
 1926|    396|    int count = 0;
 1927|    396|    auto state = initial_state();
 1928|    396|    while (num_digits > next(state)) ++count;
  ------------------
  |  Branch (1928:12): [True: 0, False: 396]
  ------------------
 1929|    396|    return count;
 1930|    396|  }
_ZNK3fmt3v126detail14digit_groupingIcE13initial_stateEv:
 1901|    396|  auto initial_state() const -> next_state { return {grouping_.begin(), 0}; }
_ZNK3fmt3v126detail14digit_groupingIcE4nextERNS3_10next_stateE:
 1904|    396|  auto next(next_state& state) const -> int {
 1905|    396|    if (thousands_sep_.empty()) return max_value<int>();
  ------------------
  |  Branch (1905:9): [True: 396, False: 0]
  ------------------
 1906|      0|    if (state.group == grouping_.end()) return state.pos += grouping_.back();
  ------------------
  |  Branch (1906:9): [True: 0, False: 0]
  ------------------
 1907|      0|    if (*state.group <= 0 || *state.group == max_value<char>())
  ------------------
  |  Branch (1907:9): [True: 0, False: 0]
  |  Branch (1907:30): [True: 0, False: 0]
  ------------------
 1908|      0|      return max_value<int>();
 1909|      0|    state.pos += *state.group++;
 1910|      0|    return state.pos;
 1911|      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_:
 1733|    218|                            size_t size, F&& f) -> OutputIt {
 1734|    218|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1735|    218|}
_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_:
 1712|    218|                                size_t size, size_t width, F&& f) -> OutputIt {
 1713|    218|  static_assert(default_align == align::left || default_align == align::right,
 1714|    218|                "");
 1715|    218|  unsigned spec_width = to_unsigned(specs.width);
 1716|    218|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1716:20): [True: 0, False: 218]
  ------------------
 1717|       |  // Shifts are encoded as string literals because static constexpr is not
 1718|       |  // supported in constexpr functions.
 1719|    218|  auto* shifts =
 1720|    218|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1720:7): [Folded, False: 218]
  ------------------
 1721|    218|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1722|    218|  size_t right_padding = padding - left_padding;
 1723|    218|  auto it = reserve(out, size + padding * specs.fill_size());
 1724|    218|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1724:7): [True: 0, False: 218]
  ------------------
 1725|    218|  it = f(it);
 1726|    218|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1726:7): [True: 0, False: 218]
  ------------------
 1727|    218|  return base_iterator(out, it);
 1728|    218|}
_ZZN3fmt3v126detail11write_fixedIcNS1_14digit_groupingIcEENS0_14basic_appenderIcEENS1_14big_decimal_fpEEET1_S8_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEENKUlS6_E_clES6_:
 2544|    218|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2545|    218|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2545:15): [True: 77, False: 141]
  ------------------
 2546|    218|          it = write_significand<Char>(it, f.significand, significand_size,
 2547|    218|                                       f.exponent, grouping);
 2548|    218|          if (!specs.alt()) return it;
  ------------------
  |  Branch (2548:15): [True: 218, False: 0]
  ------------------
 2549|      0|          *it++ = decimal_point;
 2550|      0|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
  ------------------
  |  Branch (2550:18): [True: 0, False: 0]
  ------------------
 2551|    218|        });
_ZN3fmt3v126detail17write_significandIcNS0_14basic_appenderIcEEPKcNS1_14digit_groupingIcEEEET0_S9_T1_iiRKT2_:
 2417|    218|                                       const Grouping& grouping) -> OutputIt {
 2418|    218|  if (!grouping.has_separator()) {
  ------------------
  |  Branch (2418:7): [True: 218, False: 0]
  ------------------
 2419|    218|    out = write_significand<Char>(out, significand, significand_size);
 2420|    218|    return detail::fill_n(out, exponent, static_cast<Char>('0'));
 2421|    218|  }
 2422|      0|  auto buffer = memory_buffer();
 2423|      0|  write_significand<char>(appender(buffer), significand, significand_size);
 2424|      0|  detail::fill_n(appender(buffer), exponent, '0');
 2425|      0|  return grouping.apply(out, string_view(buffer.data(), buffer.size()));
 2426|    218|}
_ZNK3fmt3v126detail14digit_groupingIcE13has_separatorEv:
 1923|    396|  auto has_separator() const -> bool { return !thousands_sep_.empty(); }
_ZN3fmt3v126detail17write_significandIcNS0_14basic_appenderIcEEEET0_S5_PKci:
 2406|    291|                                 int significand_size) -> OutputIt {
 2407|    291|  return copy<Char>(significand, significand + significand_size, out);
 2408|    291|}
_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_:
 1733|    178|                            size_t size, F&& f) -> OutputIt {
 1734|    178|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1735|    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_:
 1712|    178|                                size_t size, size_t width, F&& f) -> OutputIt {
 1713|    178|  static_assert(default_align == align::left || default_align == align::right,
 1714|    178|                "");
 1715|    178|  unsigned spec_width = to_unsigned(specs.width);
 1716|    178|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1716:20): [True: 0, False: 178]
  ------------------
 1717|       |  // Shifts are encoded as string literals because static constexpr is not
 1718|       |  // supported in constexpr functions.
 1719|    178|  auto* shifts =
 1720|    178|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1720:7): [Folded, False: 178]
  ------------------
 1721|    178|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1722|    178|  size_t right_padding = padding - left_padding;
 1723|    178|  auto it = reserve(out, size + padding * specs.fill_size());
 1724|    178|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1724:7): [True: 0, False: 178]
  ------------------
 1725|    178|  it = f(it);
 1726|    178|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1726:7): [True: 0, False: 178]
  ------------------
 1727|    178|  return base_iterator(out, it);
 1728|    178|}
_ZZN3fmt3v126detail11write_fixedIcNS1_14digit_groupingIcEENS0_14basic_appenderIcEENS1_14big_decimal_fpEEET1_S8_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEENKUlS6_E0_clES6_:
 2560|    178|        out, specs, static_cast<size_t>(size), [&](iterator it) {
 2561|    178|          if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2561:15): [True: 74, False: 104]
  ------------------
 2562|    178|          it = write_significand(it, f.significand, significand_size, exp,
 2563|    178|                                 decimal_point, grouping);
 2564|    178|          return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;
  ------------------
  |  Branch (2564:18): [True: 0, False: 178]
  ------------------
 2565|    178|        });
_ZN3fmt3v126detail17write_significandINS0_14basic_appenderIcEEcPKcNS1_14digit_groupingIcEEEET_S9_T1_iiT0_RKT2_:
 2478|    178|                                       const Grouping& grouping) -> OutputIt {
 2479|    178|  if (!grouping.has_separator()) {
  ------------------
  |  Branch (2479:7): [True: 178, False: 0]
  ------------------
 2480|    178|    return write_significand(out, significand, significand_size, integral_size,
 2481|    178|                             decimal_point);
 2482|    178|  }
 2483|      0|  auto buffer = basic_memory_buffer<Char>();
 2484|      0|  write_significand(basic_appender<Char>(buffer), significand, significand_size,
 2485|      0|                    integral_size, decimal_point);
 2486|      0|  grouping.apply(
 2487|      0|      out, basic_string_view<Char>(buffer.data(), to_unsigned(integral_size)));
 2488|      0|  return detail::copy_noinline<Char>(buffer.data() + integral_size,
 2489|      0|                                     buffer.end(), out);
 2490|    178|}
_ZN3fmt3v126detail17write_significandINS0_14basic_appenderIcEEcEET_S5_PKciiT0_:
 2465|    694|                                     Char decimal_point) -> OutputIt {
 2466|    694|  out = detail::copy_noinline<Char>(significand, significand + integral_size,
 2467|    694|                                    out);
 2468|    694|  if (!decimal_point) return out;
  ------------------
  |  Branch (2468:7): [True: 0, False: 694]
  ------------------
 2469|    694|  *out++ = decimal_point;
 2470|    694|  return detail::copy_noinline<Char>(significand + integral_size,
 2471|    694|                                     significand + significand_size, out);
 2472|    694|}
_ZN3fmt3v126detail13copy_noinlineIcPKcNS0_14basic_appenderIcEEEET1_T0_S8_S7_:
  558|  3.54k|                                              OutputIt out) -> OutputIt {
  559|  3.54k|  return copy<OutChar>(begin, end, out);
  560|  3.54k|}
_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_:
 1733|     73|                            size_t size, F&& f) -> OutputIt {
 1734|     73|  return write_padded<Char, default_align>(out, specs, size, size, f);
 1735|     73|}
_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_:
 1712|     73|                                size_t size, size_t width, F&& f) -> OutputIt {
 1713|     73|  static_assert(default_align == align::left || default_align == align::right,
 1714|     73|                "");
 1715|     73|  unsigned spec_width = to_unsigned(specs.width);
 1716|     73|  size_t padding = spec_width > width ? spec_width - width : 0;
  ------------------
  |  Branch (1716:20): [True: 0, False: 73]
  ------------------
 1717|       |  // Shifts are encoded as string literals because static constexpr is not
 1718|       |  // supported in constexpr functions.
 1719|     73|  auto* shifts =
 1720|     73|      default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  ------------------
  |  Branch (1720:7): [Folded, False: 73]
  ------------------
 1721|     73|  size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 1722|     73|  size_t right_padding = padding - left_padding;
 1723|     73|  auto it = reserve(out, size + padding * specs.fill_size());
 1724|     73|  if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
  ------------------
  |  Branch (1724:7): [True: 0, False: 73]
  ------------------
 1725|     73|  it = f(it);
 1726|     73|  if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
  ------------------
  |  Branch (1726:7): [True: 0, False: 73]
  ------------------
 1727|     73|  return base_iterator(out, it);
 1728|     73|}
_ZZN3fmt3v126detail11write_fixedIcNS1_14digit_groupingIcEENS0_14basic_appenderIcEENS1_14big_decimal_fpEEET1_S8_RKT2_iT_RKNS0_12format_specsENS0_4signENS0_10locale_refEENKUlS6_E1_clES6_:
 2576|     73|      out, specs, static_cast<size_t>(size), [&](iterator it) {
 2577|     73|        if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2577:13): [True: 42, False: 31]
  ------------------
 2578|     73|        *it++ = Char('0');
 2579|     73|        if (!pointy) return it;
  ------------------
  |  Branch (2579:13): [True: 0, False: 73]
  ------------------
 2580|     73|        *it++ = decimal_point;
 2581|     73|        it = detail::fill_n(it, num_zeros, Char('0'));
 2582|     73|        return write_significand<Char>(it, f.significand, significand_size);
 2583|     73|      });
_ZZN3fmt3v126detail14do_write_floatIcNS1_14digit_groupingIcEENS0_14basic_appenderIcEENS1_14big_decimal_fpEEET1_S8_RKT2_RKNS0_12format_specsENS0_4signEiNS0_10locale_refEENKUlS6_E_clES6_:
 2612|    516|  auto write = [=](reserve_iterator<OutputIt> it) {
 2613|    516|    if (s != sign::none) *it++ = detail::getsign<Char>(s);
  ------------------
  |  Branch (2613:9): [True: 181, False: 335]
  ------------------
 2614|       |    // Insert a decimal point after the first digit and add an exponent.
 2615|    516|    it = write_significand(it, f.significand, significand_size, 1, point);
 2616|    516|    if (num_zeros > 0) it = detail::fill_n(it, num_zeros, Char('0'));
  ------------------
  |  Branch (2616:9): [True: 0, False: 516]
  ------------------
 2617|    516|    *it++ = Char(exp_char);
 2618|    516|    return write_exponent<Char>(exp, it);
 2619|    516|  };
_ZN3fmt3v126detail14format_handlerIcE7on_textEPKcS5_:
 3788|  2.16k|  void on_text(const Char* begin, const Char* end) {
 3789|  2.16k|    copy_noinline<Char>(begin, end, ctx.out());
 3790|  2.16k|  }
_ZN3fmt3v126detail14format_handlerIcE9on_arg_idEv:
 3792|  1.08k|  FMT_CONSTEXPR auto on_arg_id() -> int { return parse_ctx.next_arg_id(); }
_ZN3fmt3v126detail14format_handlerIcE15on_format_specsEiPKcS5_:
 3809|  1.08k|      -> const Char* {
 3810|  1.08k|    auto arg = ctx.arg(id);
 3811|  1.08k|    if (!arg) report_error("argument not found");
  ------------------
  |  Branch (3811:9): [True: 0, False: 1.08k]
  ------------------
 3812|       |    // Not using a visitor for custom types gives better codegen.
 3813|  1.08k|    if (arg.format_custom(begin, parse_ctx, ctx)) return parse_ctx.begin();
  ------------------
  |  Branch (3813:9): [True: 0, False: 1.08k]
  ------------------
 3814|       |
 3815|  1.08k|    auto specs = dynamic_format_specs<Char>();
 3816|  1.08k|    begin = parse_format_specs(begin, end, specs, parse_ctx, arg.type());
 3817|  1.08k|    if (specs.dynamic()) {
  ------------------
  |  Branch (3817:9): [True: 0, False: 1.08k]
  ------------------
 3818|      0|      handle_dynamic_spec(specs.dynamic_width(), specs.width, specs.width_ref,
 3819|      0|                          ctx);
 3820|      0|      handle_dynamic_spec(specs.dynamic_precision(), specs.precision,
 3821|      0|                          specs.precision_ref, ctx);
 3822|      0|    }
 3823|       |
 3824|  1.08k|    arg.visit(arg_formatter<Char>{ctx.out(), specs, ctx.locale()});
 3825|  1.08k|    return begin;
 3826|  1.08k|  }
_ZN3fmt3v126detail12format_floatIdEEiT_iRKNS0_12format_specsEbRNS1_6bufferIcEE:
 3172|    985|                                  buffer<char>& buf) -> int {
 3173|       |  // float is passed as double to reduce the number of instantiations.
 3174|    985|  static_assert(!std::is_same<Float, float>::value, "");
 3175|    985|  auto converted_value = convert_float(value);
 3176|       |
 3177|    985|  const bool fixed = specs.type() == presentation_type::fixed;
 3178|    985|  if (value == 0) {
  ------------------
  |  Branch (3178:7): [True: 1, False: 984]
  ------------------
 3179|      1|    if (precision <= 0 || !fixed) {
  ------------------
  |  Branch (3179:9): [True: 0, False: 1]
  |  Branch (3179:27): [True: 1, False: 0]
  ------------------
 3180|      1|      buf.push_back('0');
 3181|      1|      return 0;
 3182|      1|    }
 3183|      0|    buf.try_resize(to_unsigned(precision));
 3184|      0|    fill_n(buf.data(), precision, '0');
 3185|      0|    return -precision;
 3186|      1|  }
 3187|       |
 3188|    984|  int exp = 0;
 3189|    984|  bool use_dragon = true;
 3190|    984|  unsigned dragon_flags = 0;
 3191|    984|  if (!is_fast_float<Float>() || is_constant_evaluated()) {
  ------------------
  |  Branch (3191:7): [Folded, False: 0]
  |  Branch (3191:7): [Folded, False: 984]
  |  Branch (3191:34): [Folded, False: 0]
  ------------------
 3192|      0|    const auto inv_log2_10 = 0.3010299956639812;  // 1 / log2(10)
 3193|      0|    using info = dragonbox::float_info<decltype(converted_value)>;
 3194|      0|    const auto f = basic_fp<typename info::carrier_uint>(converted_value);
 3195|       |    // Compute exp, an approximate power of 10, such that
 3196|       |    //   10^(exp - 1) <= value < 10^exp or 10^exp <= value < 10^(exp + 1).
 3197|       |    // This is based on log10(value) == log2(value) / log2(10) and approximation
 3198|       |    // of log2(value) by e + num_fraction_bits idea from double-conversion.
 3199|      0|    auto e = (f.e + count_digits<1>(f.f) - 1) * inv_log2_10 - 1e-10;
 3200|      0|    exp = static_cast<int>(e);
 3201|      0|    if (e > exp) ++exp;  // Compute ceil.
  ------------------
  |  Branch (3201:9): [True: 0, False: 0]
  ------------------
 3202|      0|    dragon_flags = dragon::fixup;
 3203|    984|  } else {
 3204|       |    // Extract significand bits and exponent bits.
 3205|    984|    using info = dragonbox::float_info<double>;
 3206|    984|    auto br = bit_cast<uint64_t>(static_cast<double>(value));
 3207|       |
 3208|    984|    const uint64_t significand_mask =
 3209|    984|        (static_cast<uint64_t>(1) << num_significand_bits<double>()) - 1;
 3210|    984|    uint64_t significand = (br & significand_mask);
 3211|    984|    int exponent = static_cast<int>((br & exponent_mask<double>()) >>
 3212|    984|                                    num_significand_bits<double>());
 3213|       |
 3214|    984|    if (exponent != 0) {  // Check if normal.
  ------------------
  |  Branch (3214:9): [True: 846, False: 138]
  ------------------
 3215|    846|      exponent -= exponent_bias<double>() + num_significand_bits<double>();
 3216|    846|      significand |=
 3217|    846|          (static_cast<uint64_t>(1) << num_significand_bits<double>());
 3218|    846|      significand <<= 1;
 3219|    846|    } else {
 3220|       |      // Normalize subnormal inputs.
 3221|    138|      FMT_ASSERT(significand != 0, "zeros should not appear here");
  ------------------
  |  |  394|    138|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (394:6): [True: 138, False: 0]
  |  |  ------------------
  |  |  395|    138|         ? (void)0                                                          \
  |  |  396|    138|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 3222|    138|      int shift = countl_zero(significand);
 3223|    138|      FMT_ASSERT(shift >= num_bits<uint64_t>() - num_significand_bits<double>(),
  ------------------
  |  |  394|    138|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (394:6): [True: 138, False: 0]
  |  |  ------------------
  |  |  395|    138|         ? (void)0                                                          \
  |  |  396|    138|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 3224|    138|                 "");
 3225|    138|      shift -= (num_bits<uint64_t>() - num_significand_bits<double>() - 2);
 3226|    138|      exponent = (std::numeric_limits<double>::min_exponent -
 3227|    138|                  num_significand_bits<double>()) -
 3228|    138|                 shift;
 3229|    138|      significand <<= shift;
 3230|    138|    }
 3231|       |
 3232|       |    // Compute the first several nonzero decimal significand digits.
 3233|       |    // We call the number we get the first segment.
 3234|    984|    const int k = info::kappa - dragonbox::floor_log10_pow2(exponent);
 3235|    984|    exp = -k;
 3236|    984|    const int beta = exponent + dragonbox::floor_log2_pow10(k);
 3237|    984|    uint64_t first_segment;
 3238|    984|    bool has_more_segments;
 3239|    984|    int digits_in_the_first_segment;
 3240|    984|    {
 3241|    984|      const auto r = dragonbox::umul192_upper128(
 3242|    984|          significand << beta, dragonbox::get_cached_power(k));
 3243|    984|      first_segment = r.high();
 3244|    984|      has_more_segments = r.low() != 0;
 3245|       |
 3246|       |      // The first segment can have 18 ~ 19 digits.
 3247|    984|      if (first_segment >= 1000000000000000000ULL) {
  ------------------
  |  Branch (3247:11): [True: 727, False: 257]
  ------------------
 3248|    727|        digits_in_the_first_segment = 19;
 3249|    727|      } else {
 3250|       |        // When it is of 18-digits, we align it to 19-digits by adding a bogus
 3251|       |        // zero at the end.
 3252|    257|        digits_in_the_first_segment = 18;
 3253|    257|        first_segment *= 10;
 3254|    257|      }
 3255|    984|    }
 3256|       |
 3257|       |    // Compute the actual number of decimal digits to print.
 3258|    984|    if (fixed) adjust_precision(precision, exp + digits_in_the_first_segment);
  ------------------
  |  Branch (3258:9): [True: 0, False: 984]
  ------------------
 3259|       |
 3260|       |    // Use Dragon4 only when there might be not enough digits in the first
 3261|       |    // segment.
 3262|    984|    if (digits_in_the_first_segment > precision) {
  ------------------
  |  Branch (3262:9): [True: 0, False: 984]
  ------------------
 3263|      0|      use_dragon = false;
 3264|       |
 3265|      0|      if (precision <= 0) {
  ------------------
  |  Branch (3265:11): [True: 0, False: 0]
  ------------------
 3266|      0|        exp += digits_in_the_first_segment;
 3267|       |
 3268|      0|        if (precision < 0) {
  ------------------
  |  Branch (3268:13): [True: 0, False: 0]
  ------------------
 3269|       |          // Nothing to do, since all we have are just leading zeros.
 3270|      0|          buf.try_resize(0);
 3271|      0|        } else {
 3272|       |          // We may need to round-up.
 3273|      0|          buf.try_resize(1);
 3274|      0|          if ((first_segment | static_cast<uint64_t>(has_more_segments)) >
  ------------------
  |  Branch (3274:15): [True: 0, False: 0]
  ------------------
 3275|      0|              5000000000000000000ULL) {
 3276|      0|            buf[0] = '1';
 3277|      0|          } else {
 3278|      0|            buf[0] = '0';
 3279|      0|          }
 3280|      0|        }
 3281|      0|      }  // precision <= 0
 3282|      0|      else {
 3283|      0|        exp += digits_in_the_first_segment - precision;
 3284|       |
 3285|       |        // When precision > 0, we divide the first segment into three
 3286|       |        // subsegments, each with 9, 9, and 0 ~ 1 digits so that each fits
 3287|       |        // in 32-bits which usually allows faster calculation than in
 3288|       |        // 64-bits. Since some compiler (e.g. MSVC) doesn't know how to optimize
 3289|       |        // division-by-constant for large 64-bit divisors, we do it here
 3290|       |        // manually. The magic number 7922816251426433760 below is equal to
 3291|       |        // ceil(2^(64+32) / 10^10).
 3292|      0|        const uint32_t first_subsegment = static_cast<uint32_t>(
 3293|      0|            dragonbox::umul128_upper64(first_segment, 7922816251426433760ULL) >>
 3294|      0|            32);
 3295|      0|        const uint64_t second_third_subsegments =
 3296|      0|            first_segment - first_subsegment * 10000000000ULL;
 3297|       |
 3298|      0|        uint64_t prod;
 3299|      0|        uint32_t digits;
 3300|      0|        bool should_round_up;
 3301|      0|        int number_of_digits_to_print = min_of(precision, 9);
 3302|       |
 3303|       |        // Print a 9-digits subsegment, either the first or the second.
 3304|      0|        auto print_subsegment = [&](uint32_t subsegment, char* buffer) {
 3305|      0|          int number_of_digits_printed = 0;
 3306|       |
 3307|       |          // If we want to print an odd number of digits from the subsegment,
 3308|      0|          if ((number_of_digits_to_print & 1) != 0) {
 3309|       |            // Convert to 64-bit fixed-point fractional form with 1-digit
 3310|       |            // integer part. The magic number 720575941 is a good enough
 3311|       |            // approximation of 2^(32 + 24) / 10^8; see
 3312|       |            // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case
 3313|       |            // for details.
 3314|      0|            prod = ((subsegment * static_cast<uint64_t>(720575941)) >> 24) + 1;
 3315|      0|            digits = static_cast<uint32_t>(prod >> 32);
 3316|      0|            *buffer = static_cast<char>('0' + digits);
 3317|      0|            number_of_digits_printed++;
 3318|      0|          }
 3319|       |          // If we want to print an even number of digits from the
 3320|       |          // first_subsegment,
 3321|      0|          else {
 3322|       |            // Convert to 64-bit fixed-point fractional form with 2-digits
 3323|       |            // integer part. The magic number 450359963 is a good enough
 3324|       |            // approximation of 2^(32 + 20) / 10^7; see
 3325|       |            // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case
 3326|       |            // for details.
 3327|      0|            prod = ((subsegment * static_cast<uint64_t>(450359963)) >> 20) + 1;
 3328|      0|            digits = static_cast<uint32_t>(prod >> 32);
 3329|      0|            write2digits(buffer, digits);
 3330|      0|            number_of_digits_printed += 2;
 3331|      0|          }
 3332|       |
 3333|       |          // Print all digit pairs.
 3334|      0|          while (number_of_digits_printed < number_of_digits_to_print) {
 3335|      0|            prod = static_cast<uint32_t>(prod) * static_cast<uint64_t>(100);
 3336|      0|            digits = static_cast<uint32_t>(prod >> 32);
 3337|      0|            write2digits(buffer + number_of_digits_printed, digits);
 3338|      0|            number_of_digits_printed += 2;
 3339|      0|          }
 3340|      0|        };
 3341|       |
 3342|       |        // Print first subsegment.
 3343|      0|        print_subsegment(first_subsegment, buf.data());
 3344|       |
 3345|       |        // Perform rounding if the first subsegment is the last subsegment to
 3346|       |        // print.
 3347|      0|        if (precision <= 9) {
  ------------------
  |  Branch (3347:13): [True: 0, False: 0]
  ------------------
 3348|       |          // Rounding inside the subsegment.
 3349|       |          // We round-up if:
 3350|       |          //  - either the fractional part is strictly larger than 1/2, or
 3351|       |          //  - the fractional part is exactly 1/2 and the last digit is odd.
 3352|       |          // We rely on the following observations:
 3353|       |          //  - If fractional_part >= threshold, then the fractional part is
 3354|       |          //    strictly larger than 1/2.
 3355|       |          //  - If the MSB of fractional_part is set, then the fractional part
 3356|       |          //    must be at least 1/2.
 3357|       |          //  - When the MSB of fractional_part is set, either
 3358|       |          //    second_third_subsegments being nonzero or has_more_segments
 3359|       |          //    being true means there are further digits not printed, so the
 3360|       |          //    fractional part is strictly larger than 1/2.
 3361|      0|          if (precision < 9) {
  ------------------
  |  Branch (3361:15): [True: 0, False: 0]
  ------------------
 3362|      0|            uint32_t fractional_part = static_cast<uint32_t>(prod);
 3363|      0|            should_round_up =
 3364|      0|                fractional_part >= fractional_part_rounding_thresholds(
  ------------------
  |  Branch (3364:17): [True: 0, False: 0]
  ------------------
 3365|      0|                                       8 - number_of_digits_to_print) ||
 3366|      0|                ((fractional_part >> 31) &
  ------------------
  |  Branch (3366:17): [True: 0, False: 0]
  ------------------
 3367|      0|                 ((digits & 1) | (second_third_subsegments != 0) |
 3368|      0|                  has_more_segments)) != 0;
 3369|      0|          }
 3370|       |          // Rounding at the subsegment boundary.
 3371|       |          // In this case, the fractional part is at least 1/2 if and only if
 3372|       |          // second_third_subsegments >= 5000000000ULL, and is strictly larger
 3373|       |          // than 1/2 if we further have either second_third_subsegments >
 3374|       |          // 5000000000ULL or has_more_segments == true.
 3375|      0|          else {
 3376|      0|            should_round_up = second_third_subsegments > 5000000000ULL ||
  ------------------
  |  Branch (3376:31): [True: 0, False: 0]
  ------------------
 3377|      0|                              (second_third_subsegments == 5000000000ULL &&
  ------------------
  |  Branch (3377:32): [True: 0, False: 0]
  ------------------
 3378|      0|                               ((digits & 1) != 0 || has_more_segments));
  ------------------
  |  Branch (3378:33): [True: 0, False: 0]
  |  Branch (3378:54): [True: 0, False: 0]
  ------------------
 3379|      0|          }
 3380|      0|        }
 3381|       |        // Otherwise, print the second subsegment.
 3382|      0|        else {
 3383|       |          // Compilers are not aware of how to leverage the maximum value of
 3384|       |          // second_third_subsegments to find out a better magic number which
 3385|       |          // allows us to eliminate an additional shift. 1844674407370955162 =
 3386|       |          // ceil(2^64/10) < ceil(2^64*(10^9/(10^10 - 1))).
 3387|      0|          const uint32_t second_subsegment =
 3388|      0|              static_cast<uint32_t>(dragonbox::umul128_upper64(
 3389|      0|                  second_third_subsegments, 1844674407370955162ULL));
 3390|      0|          const uint32_t third_subsegment =
 3391|      0|              static_cast<uint32_t>(second_third_subsegments) -
 3392|      0|              second_subsegment * 10;
 3393|       |
 3394|      0|          number_of_digits_to_print = precision - 9;
 3395|      0|          print_subsegment(second_subsegment, buf.data() + 9);
 3396|       |
 3397|       |          // Rounding inside the subsegment.
 3398|      0|          if (precision < 18) {
  ------------------
  |  Branch (3398:15): [True: 0, False: 0]
  ------------------
 3399|       |            // The condition third_subsegment != 0 implies that the segment was
 3400|       |            // of 19 digits, so in this case the third segment should be
 3401|       |            // consisting of a genuine digit from the input.
 3402|      0|            uint32_t fractional_part = static_cast<uint32_t>(prod);
 3403|      0|            should_round_up =
 3404|      0|                fractional_part >= fractional_part_rounding_thresholds(
  ------------------
  |  Branch (3404:17): [True: 0, False: 0]
  ------------------
 3405|      0|                                       8 - number_of_digits_to_print) ||
 3406|      0|                ((fractional_part >> 31) &
  ------------------
  |  Branch (3406:17): [True: 0, False: 0]
  ------------------
 3407|      0|                 ((digits & 1) | (third_subsegment != 0) |
 3408|      0|                  has_more_segments)) != 0;
 3409|      0|          }
 3410|       |          // Rounding at the subsegment boundary.
 3411|      0|          else {
 3412|       |            // In this case, the segment must be of 19 digits, thus
 3413|       |            // the third subsegment should be consisting of a genuine digit from
 3414|       |            // the input.
 3415|      0|            should_round_up = third_subsegment > 5 ||
  ------------------
  |  Branch (3415:31): [True: 0, False: 0]
  ------------------
 3416|      0|                              (third_subsegment == 5 &&
  ------------------
  |  Branch (3416:32): [True: 0, False: 0]
  ------------------
 3417|      0|                               ((digits & 1) != 0 || has_more_segments));
  ------------------
  |  Branch (3417:33): [True: 0, False: 0]
  |  Branch (3417:54): [True: 0, False: 0]
  ------------------
 3418|      0|          }
 3419|      0|        }
 3420|       |
 3421|       |        // Round-up if necessary.
 3422|      0|        if (should_round_up) {
  ------------------
  |  Branch (3422:13): [True: 0, False: 0]
  ------------------
 3423|      0|          ++buf[precision - 1];
 3424|      0|          for (int i = precision - 1; i > 0 && buf[i] > '9'; --i) {
  ------------------
  |  Branch (3424:39): [True: 0, False: 0]
  |  Branch (3424:48): [True: 0, False: 0]
  ------------------
 3425|      0|            buf[i] = '0';
 3426|      0|            ++buf[i - 1];
 3427|      0|          }
 3428|      0|          if (buf[0] > '9') {
  ------------------
  |  Branch (3428:15): [True: 0, False: 0]
  ------------------
 3429|      0|            buf[0] = '1';
 3430|      0|            if (fixed)
  ------------------
  |  Branch (3430:17): [True: 0, False: 0]
  ------------------
 3431|      0|              buf[precision++] = '0';
 3432|      0|            else
 3433|      0|              ++exp;
 3434|      0|          }
 3435|      0|        }
 3436|      0|        buf.try_resize(to_unsigned(precision));
 3437|      0|      }
 3438|      0|    }  // if (digits_in_the_first_segment > precision)
 3439|    984|    else {
 3440|       |      // Adjust the exponent for its use in Dragon4.
 3441|    984|      exp += digits_in_the_first_segment - 1;
 3442|    984|    }
 3443|    984|  }
 3444|    984|  if (use_dragon) {
  ------------------
  |  Branch (3444:7): [True: 984, False: 0]
  ------------------
 3445|    984|    auto f = basic_fp<uint128_t>();
 3446|    984|    bool is_predecessor_closer = binary32 ? f.assign(static_cast<float>(value))
  ------------------
  |  Branch (3446:34): [True: 0, False: 984]
  ------------------
 3447|    984|                                          : f.assign(converted_value);
 3448|    984|    if (is_predecessor_closer) dragon_flags |= dragon::predecessor_closer;
  ------------------
  |  Branch (3448:9): [True: 148, False: 836]
  ------------------
 3449|    984|    if (fixed) dragon_flags |= dragon::fixed;
  ------------------
  |  Branch (3449:9): [True: 0, False: 984]
  ------------------
 3450|       |    // Limit precision to the maximum possible number of significant digits in
 3451|       |    // an IEEE754 double because we don't need to generate zeros.
 3452|    984|    const int max_double_digits = 767;
 3453|    984|    if (precision > max_double_digits) precision = max_double_digits;
  ------------------
  |  Branch (3453:9): [True: 0, False: 984]
  ------------------
 3454|    984|    format_dragon(f, dragon_flags, precision, buf, exp);
 3455|    984|  }
 3456|    984|  if (!fixed && !specs.alt()) {
  ------------------
  |  Branch (3456:7): [True: 984, False: 0]
  |  Branch (3456:17): [True: 984, False: 0]
  ------------------
 3457|       |    // Remove trailing zeros.
 3458|    984|    auto num_digits = buf.size();
 3459|  14.1k|    while (num_digits > 0 && buf[num_digits - 1] == '0') {
  ------------------
  |  Branch (3459:12): [True: 14.1k, False: 0]
  |  Branch (3459:30): [True: 13.1k, False: 984]
  ------------------
 3460|  13.1k|      --num_digits;
 3461|  13.1k|      ++exp;
 3462|  13.1k|    }
 3463|    984|    buf.try_resize(num_digits);
 3464|    984|  }
 3465|    984|  return exp;
 3466|    985|}
_ZN3fmt3v126detail13convert_floatIdEENSt3__111conditionalIXoosr3std7is_sameIT_fEE5valueeqcl8num_bitsIS5_EEclL_ZNS1_8num_bitsIdEEivEEEdS5_E4typeES5_:
 1682|  1.97k|constexpr auto convert_float(T value) -> convert_float_result<T> {
 1683|  1.97k|  return static_cast<convert_float_result<T>>(value);
 1684|  1.97k|}
_ZN3fmt3v126detail8basic_fpIoE6assignIdTnNSt3__19enable_ifIXntsr16is_double_doubleIT_EE5valueEiE4typeELi0EEEbS7_:
 1604|    984|  FMT_CONSTEXPR auto assign(Float n) -> bool {
 1605|    984|    static_assert(std::numeric_limits<Float>::digits <= 113, "unsupported FP");
 1606|       |    // Assume Float is in the format [sign][exponent][significand].
 1607|    984|    using carrier_uint = typename dragonbox::float_info<Float>::carrier_uint;
 1608|    984|    const auto num_float_significand_bits =
 1609|    984|        detail::num_significand_bits<Float>();
 1610|    984|    const auto implicit_bit = carrier_uint(1) << num_float_significand_bits;
 1611|    984|    const auto significand_mask = implicit_bit - 1;
 1612|    984|    auto u = bit_cast<carrier_uint>(n);
 1613|    984|    f = static_cast<F>(u & significand_mask);
 1614|    984|    auto biased_e = static_cast<int>((u & exponent_mask<Float>()) >>
 1615|    984|                                     num_float_significand_bits);
 1616|       |    // The predecessor is closer if n is a normalized power of 2 (f == 0)
 1617|       |    // other than the smallest normalized number (biased_e > 1).
 1618|    984|    auto is_predecessor_closer = f == 0 && biased_e > 1;
  ------------------
  |  Branch (1618:34): [True: 149, False: 835]
  |  Branch (1618:44): [True: 148, False: 1]
  ------------------
 1619|    984|    if (biased_e == 0)
  ------------------
  |  Branch (1619:9): [True: 138, False: 846]
  ------------------
 1620|    138|      biased_e = 1;  // Subnormals use biased exponent 1 (min exponent).
 1621|    846|    else if (has_implicit_bit<Float>())
  ------------------
  |  Branch (1621:14): [True: 846, Folded]
  ------------------
 1622|    846|      f += static_cast<F>(implicit_bit);
 1623|    984|    e = biased_e - exponent_bias<Float>() - num_float_significand_bits;
 1624|    984|    if (!has_implicit_bit<Float>()) ++e;
  ------------------
  |  Branch (1624:9): [Folded, False: 984]
  ------------------
 1625|    984|    return is_predecessor_closer;
 1626|    984|  }
_ZN3fmt3v126detail13arg_formatterIcEclIdTnNSt3__19enable_ifIXsr10is_builtinIT_EE5valueEiE4typeELi0EEEvS7_:
 3707|  1.08k|  FMT_CONSTEXPR FMT_INLINE void operator()(T value) {
 3708|  1.08k|    detail::write<Char>(out, value, specs, locale);
 3709|  1.08k|  }
_ZN3fmt3v126detail5writeIcNS0_14basic_appenderIcEEdTnNSt3__19enable_ifIXsr17is_floating_pointIT1_EE5valueEiE4typeELi0EEET0_SA_S7_NS0_12format_specsENS0_10locale_refE:
 3471|  1.08k|                           locale_ref loc = {}) -> OutputIt {
 3472|  1.08k|  if (specs.localized() && write_loc(out, value, specs, loc)) return out;
  ------------------
  |  Branch (3472:7): [True: 0, False: 1.08k]
  |  Branch (3472:7): [True: 0, False: 1.08k]
  |  Branch (3472:28): [True: 0, False: 0]
  ------------------
 3473|       |
 3474|       |  // Use signbit because value < 0 is false for NaN.
 3475|  1.08k|  sign s = detail::signbit(value) ? sign::minus : specs.sign();
  ------------------
  |  Branch (3475:12): [True: 465, False: 615]
  ------------------
 3476|       |
 3477|  1.08k|  if (!detail::isfinite(value))
  ------------------
  |  Branch (3477:7): [True: 95, False: 985]
  ------------------
 3478|     95|    return write_nonfinite<Char>(out, detail::isnan(value), specs, s);
 3479|       |
 3480|    985|  if (specs.align() == align::numeric && s != sign::none) {
  ------------------
  |  Branch (3480:7): [True: 0, False: 985]
  |  Branch (3480:42): [True: 0, False: 0]
  ------------------
 3481|      0|    *out++ = detail::getsign<Char>(s);
 3482|      0|    s = sign::none;
 3483|      0|    if (specs.width != 0) --specs.width;
  ------------------
  |  Branch (3483:9): [True: 0, False: 0]
  ------------------
 3484|      0|  }
 3485|       |
 3486|    985|  const int exp_upper = detail::exp_upper<T>();
 3487|    985|  int precision = specs.precision;
 3488|    985|  if (precision < 0) {
  ------------------
  |  Branch (3488:7): [True: 0, False: 985]
  ------------------
 3489|      0|    if (specs.type() != presentation_type::none) {
  ------------------
  |  Branch (3489:9): [True: 0, False: 0]
  ------------------
 3490|      0|      precision = 6;
 3491|      0|    } else if (is_fast_float<T>::value && !is_constant_evaluated()) {
  ------------------
  |  Branch (3491:16): [True: 0, Folded]
  |  Branch (3491:43): [True: 0, Folded]
  ------------------
 3492|       |      // Use Dragonbox for the shortest format.
 3493|      0|      auto dec = dragonbox::to_decimal(static_cast<fast_float_t<T>>(value));
 3494|      0|      return write_float<Char>(out, dec, specs, s, exp_upper, loc);
 3495|      0|    }
 3496|      0|  }
 3497|       |
 3498|    985|  memory_buffer buffer;
 3499|    985|  if (specs.type() == presentation_type::hexfloat) {
  ------------------
  |  Branch (3499:7): [True: 0, False: 985]
  ------------------
 3500|      0|    if (s != sign::none) buffer.push_back(detail::getsign<char>(s));
  ------------------
  |  Branch (3500:9): [True: 0, False: 0]
  ------------------
 3501|      0|    format_hexfloat(convert_float(value), specs, buffer);
 3502|      0|    return write_bytes<Char, align::right>(out, {buffer.data(), buffer.size()},
 3503|      0|                                           specs);
 3504|      0|  }
 3505|       |
 3506|    985|  if (specs.type() == presentation_type::exp) {
  ------------------
  |  Branch (3506:7): [True: 0, False: 985]
  ------------------
 3507|      0|    if (precision == max_value<int>())
  ------------------
  |  Branch (3507:9): [True: 0, False: 0]
  ------------------
 3508|      0|      report_error("number is too big");
 3509|      0|    else
 3510|      0|      ++precision;
 3511|      0|    if (specs.precision != 0) specs.set_alt();
  ------------------
  |  Branch (3511:9): [True: 0, False: 0]
  ------------------
 3512|    985|  } else if (specs.type() == presentation_type::fixed) {
  ------------------
  |  Branch (3512:14): [True: 0, False: 985]
  ------------------
 3513|      0|    if (specs.precision != 0) specs.set_alt();
  ------------------
  |  Branch (3513:9): [True: 0, False: 0]
  ------------------
 3514|    985|  } else if (precision == 0) {
  ------------------
  |  Branch (3514:14): [True: 0, False: 985]
  ------------------
 3515|      0|    precision = 1;
 3516|      0|  }
 3517|    985|  int exp = format_float(convert_float(value), precision, specs,
 3518|    985|                         std::is_same<T, float>(), buffer);
 3519|       |
 3520|    985|  specs.precision = precision;
 3521|    985|  auto f = big_decimal_fp{buffer.data(), static_cast<int>(buffer.size()), exp};
 3522|    985|  return write_float<Char>(out, f, specs, s, exp_upper, loc);
 3523|    985|}
_ZN3fmt3v126detail8isfiniteIdTnNSt3__19enable_ifIXaasr17is_floating_pointIT_EE5valuesr12has_isfiniteIS5_EE5valueEiE4typeELi0EEEbS5_:
 2652|  1.08k|FMT_CONSTEXPR20 auto isfinite(T value) -> bool {
 2653|  1.08k|  constexpr T inf = T(std::numeric_limits<double>::infinity());
 2654|  1.08k|  if (is_constant_evaluated())
  ------------------
  |  Branch (2654:7): [Folded, False: 1.08k]
  ------------------
 2655|      0|    return !detail::isnan(value) && value < inf && value > -inf;
  ------------------
  |  Branch (2655:12): [True: 0, False: 0]
  |  Branch (2655:37): [True: 0, False: 0]
  |  Branch (2655:52): [True: 0, False: 0]
  ------------------
 2656|  1.08k|  return std::isfinite(value);
 2657|  1.08k|}
_ZN3fmt3v126detail5isnanIdEEbT_:
 2639|     95|template <typename T> constexpr auto isnan(T value) -> bool {
 2640|     95|  return value != value;  // std::isnan doesn't support __float128.
 2641|     95|}
_ZN3fmt3v126detail9max_valueIjEET_v:
  407|    349|template <typename T> constexpr auto max_value() -> T {
  408|    349|  return (std::numeric_limits<T>::max)();
  409|    349|}
_ZN3fmt3v126detail8bit_castImdTnNSt3__19enable_ifIXeqstT_stT0_EiE4typeELi0EEES5_RKS6_:
  268|  4.03k|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|  4.03k|  auto to = To();
  273|       |  // The cast suppresses a bogus -Wclass-memaccess on GCC.
  274|  4.03k|  memcpy(static_cast<void*>(&to), &from, sizeof(to));
  275|  4.03k|  return to;
  276|  4.03k|}

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

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