HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
format-inl.h
Go to the documentation of this file.
1 // Formatting library for C++ - implementation
2 //
3 // Copyright (c) 2012 - 2016, Victor Zverovich
4 // All rights reserved.
5 //
6 // For the license information refer to format.h.
7 
8 #ifndef FMT_FORMAT_INL_H_
9 #define FMT_FORMAT_INL_H_
10 
11 #include <algorithm>
12 #include <cctype>
13 #include <cerrno> // errno
14 #include <climits>
15 #include <cmath>
16 #include <cstdarg>
17 #include <cstring> // std::memmove
18 #include <cwchar>
19 #include <exception>
20 
21 #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
22 # include <locale>
23 #endif
24 
25 #ifdef _WIN32
26 # include <io.h> // _isatty
27 #endif
28 
29 #include "format.h"
30 
32 namespace detail {
33 
34 FMT_FUNC void assert_fail(const char* file, int line, const char* message) {
35  // Use unchecked std::fprintf to avoid triggering another assertion when
36  // writing to stderr fails
37  std::fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message);
38  // Chosen instead of std::abort to satisfy Clang in CUDA mode during device
39  // code pass.
40  std::terminate();
41 }
42 
43 #ifndef _MSC_VER
44 # define FMT_SNPRINTF snprintf
45 #else // _MSC_VER
46 inline int fmt_snprintf(char* buffer, size_t size, const char* format, ...) {
47  va_list args;
48  va_start(args, format);
49  int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
50  va_end(args);
51  return result;
52 }
53 # define FMT_SNPRINTF fmt_snprintf
54 #endif // _MSC_VER
55 
56 FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code,
58  // Report error code making sure that the output fits into
59  // inline_buffer_size to avoid dynamic memory allocation and potential
60  // bad_alloc.
61  out.try_resize(0);
62  static const char SEP[] = ": ";
63  static const char ERROR_STR[] = "error ";
64  // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
65  size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
66  auto abs_value = static_cast<uint32_or_64_or_128_t<int>>(error_code);
67  if (detail::is_negative(error_code)) {
68  abs_value = 0 - abs_value;
69  ++error_code_size;
70  }
71  error_code_size += detail::to_unsigned(detail::count_digits(abs_value));
72  auto it = buffer_appender<char>(out);
73  if (message.size() <= inline_buffer_size - error_code_size)
74  format_to(it, FMT_STRING("{}{}"), message, SEP);
75  format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code);
76  FMT_ASSERT(out.size() <= inline_buffer_size, "");
77 }
78 
79 FMT_FUNC void report_error(format_func func, int error_code,
80  const char* message) FMT_NOEXCEPT {
81  memory_buffer full_message;
82  func(full_message, error_code, message);
83  // Don't use fwrite_fully because the latter may throw.
84  if (std::fwrite(full_message.data(), full_message.size(), 1, stderr) > 0)
85  std::fputc('\n', stderr);
86 }
87 
88 // A wrapper around fwrite that throws on error.
89 inline void fwrite_fully(const void* ptr, size_t size, size_t count,
90  FILE* stream) {
91  size_t written = std::fwrite(ptr, size, count, stream);
92  if (written < count) FMT_THROW(system_error(errno, "cannot write to file"));
93 }
94 
95 #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
96 template <typename Locale>
97 locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
99 }
100 
101 template <typename Locale> Locale locale_ref::get() const {
102  static_assert(std::is_same<Locale, std::locale>::value, "");
103  return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
104 }
105 
106 template <typename Char>
108  auto& facet = std::use_facet<std::numpunct<Char>>(loc.get<std::locale>());
109  auto grouping = facet.grouping();
110  auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep();
111  return {std::move(grouping), thousands_sep};
112 }
113 template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref loc) {
114  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
115  .decimal_point();
116 }
117 #else
118 template <typename Char>
120  return {"\03", FMT_STATIC_THOUSANDS_SEPARATOR};
121 }
122 template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref) {
123  return '.';
124 }
125 #endif
126 } // namespace detail
127 
128 #if !FMT_MSC_VER
130 #endif
131 
133  format_args args) {
134  auto ec = std::error_code(error_code, std::generic_category());
135  return std::system_error(ec, vformat(format_str, args));
136 }
137 
138 namespace detail {
139 
141  // fallback_uintptr is always stored in little endian.
142  int i = static_cast<int>(sizeof(void*)) - 1;
143  while (i > 0 && n.value[i] == 0) --i;
144  auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
145  return i >= 0 ? i * char_digits + count_digits<4, unsigned>(n.value[i]) : 1;
146 }
147 
148 #if __cplusplus < 201703L
149 template <typename T> constexpr const char basic_data<T>::digits[][2];
150 template <typename T> constexpr const char basic_data<T>::hex_digits[];
151 template <typename T> constexpr const char basic_data<T>::signs[];
152 template <typename T> constexpr const unsigned basic_data<T>::prefixes[];
153 template <typename T> constexpr const char basic_data<T>::left_padding_shifts[];
154 template <typename T>
155 constexpr const char basic_data<T>::right_padding_shifts[];
156 #endif
157 
158 template <typename T> struct bits {
159  static FMT_CONSTEXPR_DECL const int value =
160  static_cast<int>(sizeof(T) * std::numeric_limits<unsigned char>::digits);
161 };
162 
163 class fp;
164 template <int SHIFT = 0> fp normalize(fp value);
165 
166 // Lower (upper) boundary is a value half way between a floating-point value
167 // and its predecessor (successor). Boundaries have the same exponent as the
168 // value so only significands are stored.
169 struct boundaries {
170  uint64_t lower;
171  uint64_t upper;
172 };
173 
174 // A handmade floating-point number f * pow(2, e).
175 class fp {
176  private:
177  using significand_type = uint64_t;
178 
179  template <typename Float>
180  using is_supported_float = bool_constant<sizeof(Float) == sizeof(uint64_t) ||
181  sizeof(Float) == sizeof(uint32_t)>;
182 
183  public:
184  significand_type f;
185  int e;
186 
187  // All sizes are in bits.
188  // Subtract 1 to account for an implicit most significant bit in the
189  // normalized form.
191  std::numeric_limits<double>::digits - 1;
192  static FMT_CONSTEXPR_DECL const uint64_t implicit_bit =
193  1ULL << double_significand_size;
196 
197  fp() : f(0), e(0) {}
198  fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {}
199 
200  // Constructs fp from an IEEE754 double. It is a template to prevent compile
201  // errors on platforms where double is not IEEE754.
202  template <typename Double> explicit fp(Double d) { assign(d); }
203 
204  // Assigns d to this and return true iff predecessor is closer than successor.
206  bool assign(Float d) {
207  // Assume float is in the format [sign][exponent][significand].
208  using limits = std::numeric_limits<Float>;
209  const int float_significand_size = limits::digits - 1;
210  const int exponent_size =
211  bits<Float>::value - float_significand_size - 1; // -1 for sign
212  const uint64_t float_implicit_bit = 1ULL << float_significand_size;
213  const uint64_t significand_mask = float_implicit_bit - 1;
214  const uint64_t exponent_mask = (~0ULL >> 1) & ~significand_mask;
215  const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1;
216  constexpr bool is_double = sizeof(Float) == sizeof(uint64_t);
218  f = u & significand_mask;
219  int biased_e =
220  static_cast<int>((u & exponent_mask) >> float_significand_size);
221  // Predecessor is closer if d is a normalized power of 2 (f == 0) other than
222  // the smallest normalized number (biased_e > 1).
223  bool is_predecessor_closer = f == 0 && biased_e > 1;
224  if (biased_e != 0)
225  f += float_implicit_bit;
226  else
227  biased_e = 1; // Subnormals use biased exponent 1 (min exponent).
228  e = biased_e - exponent_bias - float_significand_size;
229  return is_predecessor_closer;
230  }
231 
233  bool assign(Float) {
234  *this = fp();
235  return false;
236  }
237 };
238 
239 // Normalizes the value converted from double and multiplied by (1 << SHIFT).
240 template <int SHIFT> fp normalize(fp value) {
241  // Handle subnormals.
242  const auto shifted_implicit_bit = fp::implicit_bit << SHIFT;
243  while ((value.f & shifted_implicit_bit) == 0) {
244  value.f <<= 1;
245  --value.e;
246  }
247  // Subtract 1 to account for hidden bit.
248  const auto offset =
250  value.f <<= offset;
251  value.e -= offset;
252  return value;
253 }
254 
255 inline bool operator==(fp x, fp y) { return x.f == y.f && x.e == y.e; }
256 
257 // Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking.
258 inline uint64_t multiply(uint64_t lhs, uint64_t rhs) {
259 #if FMT_USE_INT128
260  auto product = static_cast<__uint128_t>(lhs) * rhs;
261  auto f = static_cast<uint64_t>(product >> 64);
262  return (static_cast<uint64_t>(product) & (1ULL << 63)) != 0 ? f + 1 : f;
263 #else
264  // Multiply 32-bit parts of significands.
265  uint64_t mask = (1ULL << 32) - 1;
266  uint64_t a = lhs >> 32, b = lhs & mask;
267  uint64_t c = rhs >> 32, d = rhs & mask;
268  uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;
269  // Compute mid 64-bit of result and round.
270  uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);
271  return ac + (ad >> 32) + (bc >> 32) + (mid >> 32);
272 #endif
273 }
274 
275 inline fp operator*(fp x, fp y) { return {multiply(x.f, y.f), x.e + y.e + 64}; }
276 
277 // Returns a cached power of 10 `c_k = c_k.f * pow(2, c_k.e)` such that its
278 // (binary) exponent satisfies `min_exponent <= c_k.e <= min_exponent + 28`.
279 inline fp get_cached_power(int min_exponent, int& pow10_exponent) {
280  // Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
281  // These are generated by support/compute-powers.py.
282  static constexpr const uint64_t pow10_significands[] = {
283  0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76,
284  0xcf42894a5dce35ea, 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df,
285  0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c,
286  0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,
287  0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57,
288  0xc21094364dfb5637, 0x9096ea6f3848984f, 0xd77485cb25823ac7,
289  0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e,
290  0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,
291  0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126,
292  0xb5b5ada8aaff80b8, 0x87625f056c7c4a8b, 0xc9bcff6034c13053,
293  0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f,
294  0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,
295  0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06,
296  0xaa242499697392d3, 0xfd87b5f28300ca0e, 0xbce5086492111aeb,
297  0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000,
298  0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,
299  0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068,
300  0x9f4f2726179a2245, 0xed63a231d4c4fb27, 0xb0de65388cc8ada8,
301  0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758,
302  0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,
303  0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d,
304  0x952ab45cfa97a0b3, 0xde469fbd99a05fe3, 0xa59bc234db398c25,
305  0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2,
306  0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,
307  0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410,
308  0x8bab8eefb6409c1a, 0xd01fef10a657842c, 0x9b10a4e5e9913129,
309  0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85,
310  0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,
311  0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b,
312  };
313 
314  // Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
315  // to significands above.
316  static constexpr const int16_t pow10_exponents[] = {
317  -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954,
318  -927, -901, -874, -847, -821, -794, -768, -741, -715, -688, -661,
319  -635, -608, -582, -555, -529, -502, -475, -449, -422, -396, -369,
320  -343, -316, -289, -263, -236, -210, -183, -157, -130, -103, -77,
321  -50, -24, 3, 30, 56, 83, 109, 136, 162, 189, 216,
322  242, 269, 295, 322, 348, 375, 402, 428, 455, 481, 508,
323  534, 561, 588, 614, 641, 667, 694, 720, 747, 774, 800,
324  827, 853, 880, 907, 933, 960, 986, 1013, 1039, 1066};
325 
326  const int shift = 32;
327  const auto significand = static_cast<int64_t>(data::log10_2_significand);
328  int index = static_cast<int>(
329  ((min_exponent + fp::significand_size - 1) * (significand >> shift) +
330  ((int64_t(1) << shift) - 1)) // ceil
331  >> 32 // arithmetic shift
332  );
333  // Decimal exponent of the first (smallest) cached power of 10.
334  const int first_dec_exp = -348;
335  // Difference between 2 consecutive decimal exponents in cached powers of 10.
336  const int dec_exp_step = 8;
337  index = (index - first_dec_exp - 1) / dec_exp_step + 1;
338  pow10_exponent = first_dec_exp + index * dec_exp_step;
339  return {pow10_significands[index], pow10_exponents[index]};
340 }
341 
342 // A simple accumulator to hold the sums of terms in bigint::square if uint128_t
343 // is not available.
344 struct accumulator {
345  uint64_t lower;
346  uint64_t upper;
347 
348  accumulator() : lower(0), upper(0) {}
349  explicit operator uint32_t() const { return static_cast<uint32_t>(lower); }
350 
351  void operator+=(uint64_t n) {
352  lower += n;
353  if (lower < n) ++upper;
354  }
355  void operator>>=(int shift) {
356  FMT_ASSERT(shift == 32, "");
357  (void)shift;
358  lower = (upper << 32) | (lower >> 32);
359  upper >>= 32;
360  }
361 };
362 
363 class bigint {
364  private:
365  // A bigint is stored as an array of bigits (big digits), with bigit at index
366  // 0 being the least significant one.
367  using bigit = uint32_t;
368  using double_bigit = uint64_t;
369  enum { bigits_capacity = 32 };
371  int exp_;
372 
373  bigit operator[](int index) const { return bigits_[to_unsigned(index)]; }
374  bigit& operator[](int index) { return bigits_[to_unsigned(index)]; }
375 
376  static FMT_CONSTEXPR_DECL const int bigit_bits = bits<bigit>::value;
377 
378  friend struct formatter<bigint>;
379 
380  void subtract_bigits(int index, bigit other, bigit& borrow) {
381  auto result = static_cast<double_bigit>((*this)[index]) - other - borrow;
382  (*this)[index] = static_cast<bigit>(result);
383  borrow = static_cast<bigit>(result >> (bigit_bits * 2 - 1));
384  }
385 
386  void remove_leading_zeros() {
387  int num_bigits = static_cast<int>(bigits_.size()) - 1;
388  while (num_bigits > 0 && (*this)[num_bigits] == 0) --num_bigits;
389  bigits_.resize(to_unsigned(num_bigits + 1));
390  }
391 
392  // Computes *this -= other assuming aligned bigints and *this >= other.
393  void subtract_aligned(const bigint& other) {
394  FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints");
395  FMT_ASSERT(compare(*this, other) >= 0, "");
396  bigit borrow = 0;
397  int i = other.exp_ - exp_;
398  for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j)
399  subtract_bigits(i, other.bigits_[j], borrow);
400  while (borrow > 0) subtract_bigits(i, 0, borrow);
401  remove_leading_zeros();
402  }
403 
404  void multiply(uint32_t value) {
405  const double_bigit wide_value = value;
406  bigit carry = 0;
407  for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
408  double_bigit result = bigits_[i] * wide_value + carry;
409  bigits_[i] = static_cast<bigit>(result);
410  carry = static_cast<bigit>(result >> bigit_bits);
411  }
412  if (carry != 0) bigits_.push_back(carry);
413  }
414 
415  void multiply(uint64_t value) {
416  const bigit mask = ~bigit(0);
417  const double_bigit lower = value & mask;
418  const double_bigit upper = value >> bigit_bits;
419  double_bigit carry = 0;
420  for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
421  double_bigit result = bigits_[i] * lower + (carry & mask);
422  carry =
423  bigits_[i] * upper + (result >> bigit_bits) + (carry >> bigit_bits);
424  bigits_[i] = static_cast<bigit>(result);
425  }
426  while (carry != 0) {
427  bigits_.push_back(carry & mask);
428  carry >>= bigit_bits;
429  }
430  }
431 
432  public:
433  bigint() : exp_(0) {}
434  explicit bigint(uint64_t n) { assign(n); }
435  ~bigint() { FMT_ASSERT(bigits_.capacity() <= bigits_capacity, ""); }
436 
437  bigint(const bigint&) = delete;
438  void operator=(const bigint&) = delete;
439 
440  void assign(const bigint& other) {
441  auto size = other.bigits_.size();
442  bigits_.resize(size);
443  auto data = other.bigits_.data();
444  std::copy(data, data + size, make_checked(bigits_.data(), size));
445  exp_ = other.exp_;
446  }
447 
448  void assign(uint64_t n) {
449  size_t num_bigits = 0;
450  do {
451  bigits_[num_bigits++] = n & ~bigit(0);
452  n >>= bigit_bits;
453  } while (n != 0);
454  bigits_.resize(num_bigits);
455  exp_ = 0;
456  }
457 
458  int num_bigits() const { return static_cast<int>(bigits_.size()) + exp_; }
459 
461  FMT_ASSERT(shift >= 0, "");
462  exp_ += shift / bigit_bits;
463  shift %= bigit_bits;
464  if (shift == 0) return *this;
465  bigit carry = 0;
466  for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
467  bigit c = bigits_[i] >> (bigit_bits - shift);
468  bigits_[i] = (bigits_[i] << shift) + carry;
469  carry = c;
470  }
471  if (carry != 0) bigits_.push_back(carry);
472  return *this;
473  }
474 
475  template <typename Int> bigint& operator*=(Int value) {
476  FMT_ASSERT(value > 0, "");
478  return *this;
479  }
480 
481  friend int compare(const bigint& lhs, const bigint& rhs) {
482  int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits();
483  if (num_lhs_bigits != num_rhs_bigits)
484  return num_lhs_bigits > num_rhs_bigits ? 1 : -1;
485  int i = static_cast<int>(lhs.bigits_.size()) - 1;
486  int j = static_cast<int>(rhs.bigits_.size()) - 1;
487  int end = i - j;
488  if (end < 0) end = 0;
489  for (; i >= end; --i, --j) {
490  bigit lhs_bigit = lhs[i], rhs_bigit = rhs[j];
491  if (lhs_bigit != rhs_bigit) return lhs_bigit > rhs_bigit ? 1 : -1;
492  }
493  if (i != j) return i > j ? 1 : -1;
494  return 0;
495  }
496 
497  // Returns compare(lhs1 + lhs2, rhs).
498  friend int add_compare(const bigint& lhs1, const bigint& lhs2,
499  const bigint& rhs) {
500  int max_lhs_bigits = (std::max)(lhs1.num_bigits(), lhs2.num_bigits());
501  int num_rhs_bigits = rhs.num_bigits();
502  if (max_lhs_bigits + 1 < num_rhs_bigits) return -1;
503  if (max_lhs_bigits > num_rhs_bigits) return 1;
504  auto get_bigit = [](const bigint& n, int i) -> bigit {
505  return i >= n.exp_ && i < n.num_bigits() ? n[i - n.exp_] : 0;
506  };
507  double_bigit borrow = 0;
508  int min_exp = (std::min)((std::min)(lhs1.exp_, lhs2.exp_), rhs.exp_);
509  for (int i = num_rhs_bigits - 1; i >= min_exp; --i) {
510  double_bigit sum =
511  static_cast<double_bigit>(get_bigit(lhs1, i)) + get_bigit(lhs2, i);
512  bigit rhs_bigit = get_bigit(rhs, i);
513  if (sum > rhs_bigit + borrow) return 1;
514  borrow = rhs_bigit + borrow - sum;
515  if (borrow > 1) return -1;
516  borrow <<= bigit_bits;
517  }
518  return borrow != 0 ? -1 : 0;
519  }
520 
521  // Assigns pow(10, exp) to this bigint.
522  void assign_pow10(int exp) {
523  FMT_ASSERT(exp >= 0, "");
524  if (exp == 0) return assign(1);
525  // Find the top bit.
526  int bitmask = 1;
527  while (exp >= bitmask) bitmask <<= 1;
528  bitmask >>= 1;
529  // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by
530  // repeated squaring and multiplication.
531  assign(5);
532  bitmask >>= 1;
533  while (bitmask != 0) {
534  square();
535  if ((exp & bitmask) != 0) *this *= 5;
536  bitmask >>= 1;
537  }
538  *this <<= exp; // Multiply by pow(2, exp) by shifting.
539  }
540 
541  void square() {
542  int num_bigits = static_cast<int>(bigits_.size());
543  int num_result_bigits = 2 * num_bigits;
545  bigits_.resize(to_unsigned(num_result_bigits));
547  auto sum = accumulator_t();
548  for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) {
549  // Compute bigit at position bigit_index of the result by adding
550  // cross-product terms n[i] * n[j] such that i + j == bigit_index.
551  for (int i = 0, j = bigit_index; j >= 0; ++i, --j) {
552  // Most terms are multiplied twice which can be optimized in the future.
553  sum += static_cast<double_bigit>(n[i]) * n[j];
554  }
555  (*this)[bigit_index] = static_cast<bigit>(sum);
556  sum >>= bits<bigit>::value; // Compute the carry.
557  }
558  // Do the same for the top half.
559  for (int bigit_index = num_bigits; bigit_index < num_result_bigits;
560  ++bigit_index) {
561  for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;)
562  sum += static_cast<double_bigit>(n[i++]) * n[j--];
563  (*this)[bigit_index] = static_cast<bigit>(sum);
564  sum >>= bits<bigit>::value;
565  }
566  --num_result_bigits;
567  remove_leading_zeros();
568  exp_ *= 2;
569  }
570 
571  // If this bigint has a bigger exponent than other, adds trailing zero to make
572  // exponents equal. This simplifies some operations such as subtraction.
573  void align(const bigint& other) {
574  int exp_difference = exp_ - other.exp_;
575  if (exp_difference <= 0) return;
576  int num_bigits = static_cast<int>(bigits_.size());
577  bigits_.resize(to_unsigned(num_bigits + exp_difference));
578  for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
579  bigits_[j] = bigits_[i];
580  std::uninitialized_fill_n(bigits_.data(), exp_difference, 0);
581  exp_ -= exp_difference;
582  }
583 
584  // Divides this bignum by divisor, assigning the remainder to this and
585  // returning the quotient.
587  FMT_ASSERT(this != &divisor, "");
588  if (compare(*this, divisor) < 0) return 0;
589  FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, "");
590  align(divisor);
591  int quotient = 0;
592  do {
593  subtract_aligned(divisor);
594  ++quotient;
595  } while (compare(*this, divisor) >= 0);
596  return quotient;
597  }
598 };
599 
600 enum class round_direction { unknown, up, down };
601 
602 // Given the divisor (normally a power of 10), the remainder = v % divisor for
603 // some number v and the error, returns whether v should be rounded up, down, or
604 // whether the rounding direction can't be determined due to error.
605 // error should be less than divisor / 2.
607  uint64_t error) {
608  FMT_ASSERT(remainder < divisor, ""); // divisor - remainder won't overflow.
609  FMT_ASSERT(error < divisor, ""); // divisor - error won't overflow.
610  FMT_ASSERT(error < divisor - error, ""); // error * 2 won't overflow.
611  // Round down if (remainder + error) * 2 <= divisor.
612  if (remainder <= divisor - remainder && error * 2 <= divisor - remainder * 2)
613  return round_direction::down;
614  // Round up if (remainder - error) * 2 >= divisor.
615  if (remainder >= error &&
616  remainder - error >= divisor - (remainder - error)) {
617  return round_direction::up;
618  }
620 }
621 
622 namespace digits {
623 enum result {
624  more, // Generate more digits.
625  done, // Done generating digits.
626  error // Digit generation cancelled due to an error.
627 };
628 }
629 
630 inline uint64_t power_of_10_64(int exp) {
631  static constexpr const uint64_t data[] = {1, FMT_POWERS_OF_10(1),
632  FMT_POWERS_OF_10(1000000000ULL),
633  10000000000000000000ULL};
634  return data[exp];
635 }
636 
637 // Generates output using the Grisu digit-gen algorithm.
638 // error: the size of the region (lower, upper) outside of which numbers
639 // definitely do not round to value (Delta in Grisu3).
640 template <typename Handler>
642  Handler& handler) {
643  const fp one(1ULL << -value.e, value.e);
644  // The integral part of scaled value (p1 in Grisu) = value / one. It cannot be
645  // zero because it contains a product of two 64-bit numbers with MSB set (due
646  // to normalization) - 1, shifted right by at most 60 bits.
647  auto integral = static_cast<uint32_t>(value.f >> -one.e);
648  FMT_ASSERT(integral != 0, "");
649  FMT_ASSERT(integral == value.f >> -one.e, "");
650  // The fractional part of scaled value (p2 in Grisu) c = value % one.
651  uint64_t fractional = value.f & (one.f - 1);
652  exp = count_digits(integral); // kappa in Grisu.
653  // Divide by 10 to prevent overflow.
654  auto result = handler.on_start(power_of_10_64(exp - 1) << -one.e,
655  value.f / 10, error * 10, exp);
656  if (result != digits::more) return result;
657  // Generate digits for the integral part. This can produce up to 10 digits.
658  do {
659  uint32_t digit = 0;
660  auto divmod_integral = [&](uint32_t divisor) {
661  digit = integral / divisor;
662  integral %= divisor;
663  };
664  // This optimization by Milo Yip reduces the number of integer divisions by
665  // one per iteration.
666  switch (exp) {
667  case 10:
668  divmod_integral(1000000000);
669  break;
670  case 9:
671  divmod_integral(100000000);
672  break;
673  case 8:
674  divmod_integral(10000000);
675  break;
676  case 7:
677  divmod_integral(1000000);
678  break;
679  case 6:
680  divmod_integral(100000);
681  break;
682  case 5:
683  divmod_integral(10000);
684  break;
685  case 4:
686  divmod_integral(1000);
687  break;
688  case 3:
689  divmod_integral(100);
690  break;
691  case 2:
692  divmod_integral(10);
693  break;
694  case 1:
695  digit = integral;
696  integral = 0;
697  break;
698  default:
699  FMT_ASSERT(false, "invalid number of digits");
700  }
701  --exp;
702  auto remainder = (static_cast<uint64_t>(integral) << -one.e) + fractional;
703  result = handler.on_digit(static_cast<char>('0' + digit),
704  power_of_10_64(exp) << -one.e, remainder, error,
705  exp, true);
706  if (result != digits::more) return result;
707  } while (exp > 0);
708  // Generate digits for the fractional part.
709  for (;;) {
710  fractional *= 10;
711  error *= 10;
712  char digit = static_cast<char>('0' + (fractional >> -one.e));
713  fractional &= one.f - 1;
714  --exp;
715  result = handler.on_digit(digit, one.f, fractional, error, exp, false);
716  if (result != digits::more) return result;
717  }
718 }
719 
720 // The fixed precision digit handler.
722  char* buf;
723  int size;
725  int exp10;
726  bool fixed;
727 
728  digits::result on_start(uint64_t divisor, uint64_t remainder, uint64_t error,
729  int& exp) {
730  // Non-fixed formats require at least one digit and no precision adjustment.
731  if (!fixed) return digits::more;
732  // Adjust fixed precision by exponent because it is relative to decimal
733  // point.
734  precision += exp + exp10;
735  // Check if precision is satisfied just by leading zeros, e.g.
736  // format("{:.2f}", 0.001) gives "0.00" without generating any digits.
737  if (precision > 0) return digits::more;
738  if (precision < 0) return digits::done;
739  auto dir = get_round_direction(divisor, remainder, error);
740  if (dir == round_direction::unknown) return digits::error;
741  buf[size++] = dir == round_direction::up ? '1' : '0';
742  return digits::done;
743  }
744 
745  digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder,
746  uint64_t error, int, bool integral) {
747  FMT_ASSERT(remainder < divisor, "");
748  buf[size++] = digit;
749  if (!integral && error >= remainder) return digits::error;
750  if (size < precision) return digits::more;
751  if (!integral) {
752  // Check if error * 2 < divisor with overflow prevention.
753  // The check is not needed for the integral part because error = 1
754  // and divisor > (1 << 32) there.
755  if (error >= divisor || error >= divisor - error) return digits::error;
756  } else {
757  FMT_ASSERT(error == 1 && divisor > 2, "");
758  }
759  auto dir = get_round_direction(divisor, remainder, error);
760  if (dir != round_direction::up)
762  ++buf[size - 1];
763  for (int i = size - 1; i > 0 && buf[i] > '9'; --i) {
764  buf[i] = '0';
765  ++buf[i - 1];
766  }
767  if (buf[0] > '9') {
768  buf[0] = '1';
769  if (fixed)
770  buf[size++] = '0';
771  else
772  ++exp10;
773  }
774  return digits::done;
775  }
776 };
777 
778 // A 128-bit integer type used internally,
780  uint128_wrapper() = default;
781 
782 #if FMT_USE_INT128
783  uint128_t internal_;
784 
785  constexpr uint128_wrapper(uint64_t high, uint64_t low) FMT_NOEXCEPT
786  : internal_{static_cast<uint128_t>(low) |
787  (static_cast<uint128_t>(high) << 64)} {}
788 
789  constexpr uint128_wrapper(uint128_t u) : internal_{u} {}
790 
791  constexpr uint64_t high() const FMT_NOEXCEPT {
792  return uint64_t(internal_ >> 64);
793  }
794  constexpr uint64_t low() const FMT_NOEXCEPT { return uint64_t(internal_); }
795 
796  uint128_wrapper& operator+=(uint64_t n) FMT_NOEXCEPT {
797  internal_ += n;
798  return *this;
799  }
800 #else
801  uint64_t high_;
802  uint64_t low_;
803 
804  constexpr uint128_wrapper(uint64_t high, uint64_t low) FMT_NOEXCEPT
805  : high_{high},
806  low_{low} {}
807 
808  constexpr uint64_t high() const FMT_NOEXCEPT { return high_; }
809  constexpr uint64_t low() const FMT_NOEXCEPT { return low_; }
810 
811  uint128_wrapper& operator+=(uint64_t n) FMT_NOEXCEPT {
812 # if defined(_MSC_VER) && defined(_M_X64)
813  unsigned char carry = _addcarry_u64(0, low_, n, &low_);
814  _addcarry_u64(carry, high_, 0, &high_);
815  return *this;
816 # else
817  uint64_t sum = low_ + n;
818  high_ += (sum < low_ ? 1 : 0);
819  low_ = sum;
820  return *this;
821 # endif
822  }
823 #endif
824 };
825 
826 // Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox.
827 namespace dragonbox {
828 // Computes 128-bit result of multiplication of two 64-bit unsigned integers.
829 inline uint128_wrapper umul128(uint64_t x, uint64_t y) FMT_NOEXCEPT {
830 #if FMT_USE_INT128
831  return static_cast<uint128_t>(x) * static_cast<uint128_t>(y);
832 #elif defined(_MSC_VER) && defined(_M_X64)
834  result.low_ = _umul128(x, y, &result.high_);
835  return result;
836 #else
837  const uint64_t mask = (uint64_t(1) << 32) - uint64_t(1);
838 
839  uint64_t a = x >> 32;
840  uint64_t b = x & mask;
841  uint64_t c = y >> 32;
842  uint64_t d = y & mask;
843 
844  uint64_t ac = a * c;
845  uint64_t bc = b * c;
846  uint64_t ad = a * d;
847  uint64_t bd = b * d;
848 
849  uint64_t intermediate = (bd >> 32) + (ad & mask) + (bc & mask);
850 
851  return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32),
852  (intermediate << 32) + (bd & mask)};
853 #endif
854 }
855 
856 // Computes upper 64 bits of multiplication of two 64-bit unsigned integers.
857 inline uint64_t umul128_upper64(uint64_t x, uint64_t y) FMT_NOEXCEPT {
858 #if FMT_USE_INT128
859  auto p = static_cast<uint128_t>(x) * static_cast<uint128_t>(y);
860  return static_cast<uint64_t>(p >> 64);
861 #elif defined(_MSC_VER) && defined(_M_X64)
862  return __umulh(x, y);
863 #else
864  return umul128(x, y).high();
865 #endif
866 }
867 
868 // Computes upper 64 bits of multiplication of a 64-bit unsigned integer and a
869 // 128-bit unsigned integer.
870 inline uint64_t umul192_upper64(uint64_t x, uint128_wrapper y) FMT_NOEXCEPT {
871  uint128_wrapper g0 = umul128(x, y.high());
872  g0 += umul128_upper64(x, y.low());
873  return g0.high();
874 }
875 
876 // Computes upper 32 bits of multiplication of a 32-bit unsigned integer and a
877 // 64-bit unsigned integer.
878 inline uint32_t umul96_upper32(uint32_t x, uint64_t y) FMT_NOEXCEPT {
879  return static_cast<uint32_t>(umul128_upper64(x, y));
880 }
881 
882 // Computes middle 64 bits of multiplication of a 64-bit unsigned integer and a
883 // 128-bit unsigned integer.
884 inline uint64_t umul192_middle64(uint64_t x, uint128_wrapper y) FMT_NOEXCEPT {
885  uint64_t g01 = x * y.high();
886  uint64_t g10 = umul128_upper64(x, y.low());
887  return g01 + g10;
888 }
889 
890 // Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a
891 // 64-bit unsigned integer.
892 inline uint64_t umul96_lower64(uint32_t x, uint64_t y) FMT_NOEXCEPT {
893  return x * y;
894 }
895 
896 // Computes floor(log10(pow(2, e))) for e in [-1700, 1700] using the method from
897 // https://fmt.dev/papers/Grisu-Exact.pdf#page=5, section 3.4.
898 inline int floor_log10_pow2(int e) FMT_NOEXCEPT {
899  FMT_ASSERT(e <= 1700 && e >= -1700, "too large exponent");
900  const int shift = 22;
901  return (e * static_cast<int>(data::log10_2_significand >> (64 - shift))) >>
902  shift;
903 }
904 
905 // Various fast log computations.
906 inline int floor_log2_pow10(int e) FMT_NOEXCEPT {
907  FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent");
908  const uint64_t log2_10_integer_part = 3;
909  const uint64_t log2_10_fractional_digits = 0x5269e12f346e2bf9;
910  const int shift_amount = 19;
911  return (e * static_cast<int>(
912  (log2_10_integer_part << shift_amount) |
913  (log2_10_fractional_digits >> (64 - shift_amount)))) >>
914  shift_amount;
915 }
917  FMT_ASSERT(e <= 1700 && e >= -1700, "too large exponent");
918  const uint64_t log10_4_over_3_fractional_digits = 0x1ffbfc2bbc780375;
919  const int shift_amount = 22;
920  return (e * static_cast<int>(data::log10_2_significand >>
921  (64 - shift_amount)) -
922  static_cast<int>(log10_4_over_3_fractional_digits >>
923  (64 - shift_amount))) >>
924  shift_amount;
925 }
926 
927 // Returns true iff x is divisible by pow(2, exp).
928 inline bool divisible_by_power_of_2(uint32_t x, int exp) FMT_NOEXCEPT {
929  FMT_ASSERT(exp >= 1, "");
930  FMT_ASSERT(x != 0, "");
931 #ifdef FMT_BUILTIN_CTZ
932  return FMT_BUILTIN_CTZ(x) >= exp;
933 #else
934  return exp < num_bits<uint32_t>() && x == ((x >> exp) << exp);
935 #endif
936 }
937 inline bool divisible_by_power_of_2(uint64_t x, int exp) FMT_NOEXCEPT {
938  FMT_ASSERT(exp >= 1, "");
939  FMT_ASSERT(x != 0, "");
940 #ifdef FMT_BUILTIN_CTZLL
941  return FMT_BUILTIN_CTZLL(x) >= exp;
942 #else
943  return exp < num_bits<uint64_t>() && x == ((x >> exp) << exp);
944 #endif
945 }
946 
947 // Table entry type for divisibility test.
948 template <typename T> struct divtest_table_entry {
951 };
952 
953 // Returns true iff x is divisible by pow(5, exp).
954 inline bool divisible_by_power_of_5(uint32_t x, int exp) FMT_NOEXCEPT {
955  FMT_ASSERT(exp <= 10, "too large exponent");
956  static constexpr const divtest_table_entry<uint32_t> divtest_table[] = {
957  {0x00000001, 0xffffffff}, {0xcccccccd, 0x33333333},
958  {0xc28f5c29, 0x0a3d70a3}, {0x26e978d5, 0x020c49ba},
959  {0x3afb7e91, 0x0068db8b}, {0x0bcbe61d, 0x0014f8b5},
960  {0x68c26139, 0x000431bd}, {0xae8d46a5, 0x0000d6bf},
961  {0x22e90e21, 0x00002af3}, {0x3a2e9c6d, 0x00000897},
962  {0x3ed61f49, 0x000001b7}};
963  return x * divtest_table[exp].mod_inv <= divtest_table[exp].max_quotient;
964 }
965 inline bool divisible_by_power_of_5(uint64_t x, int exp) FMT_NOEXCEPT {
966  FMT_ASSERT(exp <= 23, "too large exponent");
967  static constexpr const divtest_table_entry<uint64_t> divtest_table[] = {
968  {0x0000000000000001, 0xffffffffffffffff},
969  {0xcccccccccccccccd, 0x3333333333333333},
970  {0x8f5c28f5c28f5c29, 0x0a3d70a3d70a3d70},
971  {0x1cac083126e978d5, 0x020c49ba5e353f7c},
972  {0xd288ce703afb7e91, 0x0068db8bac710cb2},
973  {0x5d4e8fb00bcbe61d, 0x0014f8b588e368f0},
974  {0x790fb65668c26139, 0x000431bde82d7b63},
975  {0xe5032477ae8d46a5, 0x0000d6bf94d5e57a},
976  {0xc767074b22e90e21, 0x00002af31dc46118},
977  {0x8e47ce423a2e9c6d, 0x0000089705f4136b},
978  {0x4fa7f60d3ed61f49, 0x000001b7cdfd9d7b},
979  {0x0fee64690c913975, 0x00000057f5ff85e5},
980  {0x3662e0e1cf503eb1, 0x000000119799812d},
981  {0xa47a2cf9f6433fbd, 0x0000000384b84d09},
982  {0x54186f653140a659, 0x00000000b424dc35},
983  {0x7738164770402145, 0x0000000024075f3d},
984  {0xe4a4d1417cd9a041, 0x000000000734aca5},
985  {0xc75429d9e5c5200d, 0x000000000170ef54},
986  {0xc1773b91fac10669, 0x000000000049c977},
987  {0x26b172506559ce15, 0x00000000000ec1e4},
988  {0xd489e3a9addec2d1, 0x000000000002f394},
989  {0x90e860bb892c8d5d, 0x000000000000971d},
990  {0x502e79bf1b6f4f79, 0x0000000000001e39},
991  {0xdcd618596be30fe5, 0x000000000000060b}};
992  return x * divtest_table[exp].mod_inv <= divtest_table[exp].max_quotient;
993 }
994 
995 // Replaces n by floor(n / pow(5, N)) returning true if and only if n is
996 // divisible by pow(5, N).
997 // Precondition: n <= 2 * pow(5, N + 1).
998 template <int N>
1000  static constexpr struct {
1001  uint32_t magic_number;
1002  int bits_for_comparison;
1003  uint32_t threshold;
1004  int shift_amount;
1005  } infos[] = {{0xcccd, 16, 0x3333, 18}, {0xa429, 8, 0x0a, 20}};
1006  constexpr auto info = infos[N - 1];
1007  n *= info.magic_number;
1008  const uint32_t comparison_mask = (1u << info.bits_for_comparison) - 1;
1009  bool result = (n & comparison_mask) <= info.threshold;
1010  n >>= info.shift_amount;
1011  return result;
1012 }
1013 
1014 // Computes floor(n / pow(10, N)) for small n and N.
1015 // Precondition: n <= pow(10, N + 1).
1016 template <int N> uint32_t small_division_by_pow10(uint32_t n) FMT_NOEXCEPT {
1017  static constexpr struct {
1018  uint32_t magic_number;
1019  int shift_amount;
1020  uint32_t divisor_times_10;
1021  } infos[] = {{0xcccd, 19, 100}, {0xa3d8, 22, 1000}};
1022  constexpr auto info = infos[N - 1];
1023  FMT_ASSERT(n <= info.divisor_times_10, "n is too large");
1024  return n * info.magic_number >> info.shift_amount;
1025 }
1026 
1027 // Computes floor(n / 10^(kappa + 1)) (float)
1028 inline uint32_t divide_by_10_to_kappa_plus_1(uint32_t n) FMT_NOEXCEPT {
1029  return n / float_info<float>::big_divisor;
1030 }
1031 // Computes floor(n / 10^(kappa + 1)) (double)
1032 inline uint64_t divide_by_10_to_kappa_plus_1(uint64_t n) FMT_NOEXCEPT {
1033  return umul128_upper64(n, 0x83126e978d4fdf3c) >> 9;
1034 }
1035 
1036 // Various subroutines using pow10 cache
1037 template <class T> struct cache_accessor;
1038 
1039 template <> struct cache_accessor<float> {
1040  using carrier_uint = float_info<float>::carrier_uint;
1041  using cache_entry_type = uint64_t;
1042 
1043  static uint64_t get_cached_power(int k) FMT_NOEXCEPT {
1044  FMT_ASSERT(k >= float_info<float>::min_k && k <= float_info<float>::max_k,
1045  "k is out of range");
1046  constexpr const uint64_t pow10_significands[] = {
1047  0x81ceb32c4b43fcf5, 0xa2425ff75e14fc32, 0xcad2f7f5359a3b3f,
1048  0xfd87b5f28300ca0e, 0x9e74d1b791e07e49, 0xc612062576589ddb,
1049  0xf79687aed3eec552, 0x9abe14cd44753b53, 0xc16d9a0095928a28,
1050  0xf1c90080baf72cb2, 0x971da05074da7bef, 0xbce5086492111aeb,
1051  0xec1e4a7db69561a6, 0x9392ee8e921d5d08, 0xb877aa3236a4b44a,
1052  0xe69594bec44de15c, 0x901d7cf73ab0acda, 0xb424dc35095cd810,
1053  0xe12e13424bb40e14, 0x8cbccc096f5088cc, 0xafebff0bcb24aaff,
1054  0xdbe6fecebdedd5bf, 0x89705f4136b4a598, 0xabcc77118461cefd,
1055  0xd6bf94d5e57a42bd, 0x8637bd05af6c69b6, 0xa7c5ac471b478424,
1056  0xd1b71758e219652c, 0x83126e978d4fdf3c, 0xa3d70a3d70a3d70b,
1057  0xcccccccccccccccd, 0x8000000000000000, 0xa000000000000000,
1058  0xc800000000000000, 0xfa00000000000000, 0x9c40000000000000,
1059  0xc350000000000000, 0xf424000000000000, 0x9896800000000000,
1060  0xbebc200000000000, 0xee6b280000000000, 0x9502f90000000000,
1061  0xba43b74000000000, 0xe8d4a51000000000, 0x9184e72a00000000,
1062  0xb5e620f480000000, 0xe35fa931a0000000, 0x8e1bc9bf04000000,
1063  0xb1a2bc2ec5000000, 0xde0b6b3a76400000, 0x8ac7230489e80000,
1064  0xad78ebc5ac620000, 0xd8d726b7177a8000, 0x878678326eac9000,
1065  0xa968163f0a57b400, 0xd3c21bcecceda100, 0x84595161401484a0,
1066  0xa56fa5b99019a5c8, 0xcecb8f27f4200f3a, 0x813f3978f8940984,
1067  0xa18f07d736b90be5, 0xc9f2c9cd04674ede, 0xfc6f7c4045812296,
1068  0x9dc5ada82b70b59d, 0xc5371912364ce305, 0xf684df56c3e01bc6,
1069  0x9a130b963a6c115c, 0xc097ce7bc90715b3, 0xf0bdc21abb48db20,
1070  0x96769950b50d88f4, 0xbc143fa4e250eb31, 0xeb194f8e1ae525fd,
1071  0x92efd1b8d0cf37be, 0xb7abc627050305ad, 0xe596b7b0c643c719,
1072  0x8f7e32ce7bea5c6f, 0xb35dbf821ae4f38b, 0xe0352f62a19e306e};
1073  return pow10_significands[k - float_info<float>::min_k];
1074  }
1075 
1077  const cache_entry_type& cache) FMT_NOEXCEPT {
1078  return umul96_upper32(u, cache);
1079  }
1080 
1081  static uint32_t compute_delta(const cache_entry_type& cache,
1082  int beta_minus_1) FMT_NOEXCEPT {
1083  return static_cast<uint32_t>(cache >> (64 - 1 - beta_minus_1));
1084  }
1085 
1087  const cache_entry_type& cache,
1088  int beta_minus_1) FMT_NOEXCEPT {
1089  FMT_ASSERT(beta_minus_1 >= 1, "");
1090  FMT_ASSERT(beta_minus_1 < 64, "");
1091 
1092  return ((umul96_lower64(two_f, cache) >> (64 - beta_minus_1)) & 1) != 0;
1093  }
1094 
1096  const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT {
1097  return static_cast<carrier_uint>(
1098  (cache - (cache >> (float_info<float>::significand_bits + 2))) >>
1099  (64 - float_info<float>::significand_bits - 1 - beta_minus_1));
1100  }
1101 
1103  const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT {
1104  return static_cast<carrier_uint>(
1105  (cache + (cache >> (float_info<float>::significand_bits + 1))) >>
1106  (64 - float_info<float>::significand_bits - 1 - beta_minus_1));
1107  }
1108 
1110  const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT {
1111  return (static_cast<carrier_uint>(
1112  cache >>
1113  (64 - float_info<float>::significand_bits - 2 - beta_minus_1)) +
1114  1) /
1115  2;
1116  }
1117 };
1118 
1119 template <> struct cache_accessor<double> {
1120  using carrier_uint = float_info<double>::carrier_uint;
1122 
1124  FMT_ASSERT(k >= float_info<double>::min_k && k <= float_info<double>::max_k,
1125  "k is out of range");
1126 
1127  static constexpr const uint128_wrapper pow10_significands[] = {
1128 #if FMT_USE_FULL_CACHE_DRAGONBOX
1129  {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
1130  {0x9faacf3df73609b1, 0x77b191618c54e9ad},
1131  {0xc795830d75038c1d, 0xd59df5b9ef6a2418},
1132  {0xf97ae3d0d2446f25, 0x4b0573286b44ad1e},
1133  {0x9becce62836ac577, 0x4ee367f9430aec33},
1134  {0xc2e801fb244576d5, 0x229c41f793cda740},
1135  {0xf3a20279ed56d48a, 0x6b43527578c11110},
1136  {0x9845418c345644d6, 0x830a13896b78aaaa},
1137  {0xbe5691ef416bd60c, 0x23cc986bc656d554},
1138  {0xedec366b11c6cb8f, 0x2cbfbe86b7ec8aa9},
1139  {0x94b3a202eb1c3f39, 0x7bf7d71432f3d6aa},
1140  {0xb9e08a83a5e34f07, 0xdaf5ccd93fb0cc54},
1141  {0xe858ad248f5c22c9, 0xd1b3400f8f9cff69},
1142  {0x91376c36d99995be, 0x23100809b9c21fa2},
1143  {0xb58547448ffffb2d, 0xabd40a0c2832a78b},
1144  {0xe2e69915b3fff9f9, 0x16c90c8f323f516d},
1145  {0x8dd01fad907ffc3b, 0xae3da7d97f6792e4},
1146  {0xb1442798f49ffb4a, 0x99cd11cfdf41779d},
1147  {0xdd95317f31c7fa1d, 0x40405643d711d584},
1148  {0x8a7d3eef7f1cfc52, 0x482835ea666b2573},
1149  {0xad1c8eab5ee43b66, 0xda3243650005eed0},
1150  {0xd863b256369d4a40, 0x90bed43e40076a83},
1151  {0x873e4f75e2224e68, 0x5a7744a6e804a292},
1152  {0xa90de3535aaae202, 0x711515d0a205cb37},
1153  {0xd3515c2831559a83, 0x0d5a5b44ca873e04},
1154  {0x8412d9991ed58091, 0xe858790afe9486c3},
1155  {0xa5178fff668ae0b6, 0x626e974dbe39a873},
1156  {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
1157  {0x80fa687f881c7f8e, 0x7ce66634bc9d0b9a},
1158  {0xa139029f6a239f72, 0x1c1fffc1ebc44e81},
1159  {0xc987434744ac874e, 0xa327ffb266b56221},
1160  {0xfbe9141915d7a922, 0x4bf1ff9f0062baa9},
1161  {0x9d71ac8fada6c9b5, 0x6f773fc3603db4aa},
1162  {0xc4ce17b399107c22, 0xcb550fb4384d21d4},
1163  {0xf6019da07f549b2b, 0x7e2a53a146606a49},
1164  {0x99c102844f94e0fb, 0x2eda7444cbfc426e},
1165  {0xc0314325637a1939, 0xfa911155fefb5309},
1166  {0xf03d93eebc589f88, 0x793555ab7eba27cb},
1167  {0x96267c7535b763b5, 0x4bc1558b2f3458df},
1168  {0xbbb01b9283253ca2, 0x9eb1aaedfb016f17},
1169  {0xea9c227723ee8bcb, 0x465e15a979c1cadd},
1170  {0x92a1958a7675175f, 0x0bfacd89ec191eca},
1171  {0xb749faed14125d36, 0xcef980ec671f667c},
1172  {0xe51c79a85916f484, 0x82b7e12780e7401b},
1173  {0x8f31cc0937ae58d2, 0xd1b2ecb8b0908811},
1174  {0xb2fe3f0b8599ef07, 0x861fa7e6dcb4aa16},
1175  {0xdfbdcece67006ac9, 0x67a791e093e1d49b},
1176  {0x8bd6a141006042bd, 0xe0c8bb2c5c6d24e1},
1177  {0xaecc49914078536d, 0x58fae9f773886e19},
1178  {0xda7f5bf590966848, 0xaf39a475506a899f},
1179  {0x888f99797a5e012d, 0x6d8406c952429604},
1180  {0xaab37fd7d8f58178, 0xc8e5087ba6d33b84},
1181  {0xd5605fcdcf32e1d6, 0xfb1e4a9a90880a65},
1182  {0x855c3be0a17fcd26, 0x5cf2eea09a550680},
1183  {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},
1184  {0xd0601d8efc57b08b, 0xf13b94daf124da27},
1185  {0x823c12795db6ce57, 0x76c53d08d6b70859},
1186  {0xa2cb1717b52481ed, 0x54768c4b0c64ca6f},
1187  {0xcb7ddcdda26da268, 0xa9942f5dcf7dfd0a},
1188  {0xfe5d54150b090b02, 0xd3f93b35435d7c4d},
1189  {0x9efa548d26e5a6e1, 0xc47bc5014a1a6db0},
1190  {0xc6b8e9b0709f109a, 0x359ab6419ca1091c},
1191  {0xf867241c8cc6d4c0, 0xc30163d203c94b63},
1192  {0x9b407691d7fc44f8, 0x79e0de63425dcf1e},
1193  {0xc21094364dfb5636, 0x985915fc12f542e5},
1194  {0xf294b943e17a2bc4, 0x3e6f5b7b17b2939e},
1195  {0x979cf3ca6cec5b5a, 0xa705992ceecf9c43},
1196  {0xbd8430bd08277231, 0x50c6ff782a838354},
1197  {0xece53cec4a314ebd, 0xa4f8bf5635246429},
1198  {0x940f4613ae5ed136, 0x871b7795e136be9a},
1199  {0xb913179899f68584, 0x28e2557b59846e40},
1200  {0xe757dd7ec07426e5, 0x331aeada2fe589d0},
1201  {0x9096ea6f3848984f, 0x3ff0d2c85def7622},
1202  {0xb4bca50b065abe63, 0x0fed077a756b53aa},
1203  {0xe1ebce4dc7f16dfb, 0xd3e8495912c62895},
1204  {0x8d3360f09cf6e4bd, 0x64712dd7abbbd95d},
1205  {0xb080392cc4349dec, 0xbd8d794d96aacfb4},
1206  {0xdca04777f541c567, 0xecf0d7a0fc5583a1},
1207  {0x89e42caaf9491b60, 0xf41686c49db57245},
1208  {0xac5d37d5b79b6239, 0x311c2875c522ced6},
1209  {0xd77485cb25823ac7, 0x7d633293366b828c},
1210  {0x86a8d39ef77164bc, 0xae5dff9c02033198},
1211  {0xa8530886b54dbdeb, 0xd9f57f830283fdfd},
1212  {0xd267caa862a12d66, 0xd072df63c324fd7c},
1213  {0x8380dea93da4bc60, 0x4247cb9e59f71e6e},
1214  {0xa46116538d0deb78, 0x52d9be85f074e609},
1215  {0xcd795be870516656, 0x67902e276c921f8c},
1216  {0x806bd9714632dff6, 0x00ba1cd8a3db53b7},
1217  {0xa086cfcd97bf97f3, 0x80e8a40eccd228a5},
1218  {0xc8a883c0fdaf7df0, 0x6122cd128006b2ce},
1219  {0xfad2a4b13d1b5d6c, 0x796b805720085f82},
1220  {0x9cc3a6eec6311a63, 0xcbe3303674053bb1},
1221  {0xc3f490aa77bd60fc, 0xbedbfc4411068a9d},
1222  {0xf4f1b4d515acb93b, 0xee92fb5515482d45},
1223  {0x991711052d8bf3c5, 0x751bdd152d4d1c4b},
1224  {0xbf5cd54678eef0b6, 0xd262d45a78a0635e},
1225  {0xef340a98172aace4, 0x86fb897116c87c35},
1226  {0x9580869f0e7aac0e, 0xd45d35e6ae3d4da1},
1227  {0xbae0a846d2195712, 0x8974836059cca10a},
1228  {0xe998d258869facd7, 0x2bd1a438703fc94c},
1229  {0x91ff83775423cc06, 0x7b6306a34627ddd0},
1230  {0xb67f6455292cbf08, 0x1a3bc84c17b1d543},
1231  {0xe41f3d6a7377eeca, 0x20caba5f1d9e4a94},
1232  {0x8e938662882af53e, 0x547eb47b7282ee9d},
1233  {0xb23867fb2a35b28d, 0xe99e619a4f23aa44},
1234  {0xdec681f9f4c31f31, 0x6405fa00e2ec94d5},
1235  {0x8b3c113c38f9f37e, 0xde83bc408dd3dd05},
1236  {0xae0b158b4738705e, 0x9624ab50b148d446},
1237  {0xd98ddaee19068c76, 0x3badd624dd9b0958},
1238  {0x87f8a8d4cfa417c9, 0xe54ca5d70a80e5d7},
1239  {0xa9f6d30a038d1dbc, 0x5e9fcf4ccd211f4d},
1240  {0xd47487cc8470652b, 0x7647c32000696720},
1241  {0x84c8d4dfd2c63f3b, 0x29ecd9f40041e074},
1242  {0xa5fb0a17c777cf09, 0xf468107100525891},
1243  {0xcf79cc9db955c2cc, 0x7182148d4066eeb5},
1244  {0x81ac1fe293d599bf, 0xc6f14cd848405531},
1245  {0xa21727db38cb002f, 0xb8ada00e5a506a7d},
1246  {0xca9cf1d206fdc03b, 0xa6d90811f0e4851d},
1247  {0xfd442e4688bd304a, 0x908f4a166d1da664},
1248  {0x9e4a9cec15763e2e, 0x9a598e4e043287ff},
1249  {0xc5dd44271ad3cdba, 0x40eff1e1853f29fe},
1250  {0xf7549530e188c128, 0xd12bee59e68ef47d},
1251  {0x9a94dd3e8cf578b9, 0x82bb74f8301958cf},
1252  {0xc13a148e3032d6e7, 0xe36a52363c1faf02},
1253  {0xf18899b1bc3f8ca1, 0xdc44e6c3cb279ac2},
1254  {0x96f5600f15a7b7e5, 0x29ab103a5ef8c0ba},
1255  {0xbcb2b812db11a5de, 0x7415d448f6b6f0e8},
1256  {0xebdf661791d60f56, 0x111b495b3464ad22},
1257  {0x936b9fcebb25c995, 0xcab10dd900beec35},
1258  {0xb84687c269ef3bfb, 0x3d5d514f40eea743},
1259  {0xe65829b3046b0afa, 0x0cb4a5a3112a5113},
1260  {0x8ff71a0fe2c2e6dc, 0x47f0e785eaba72ac},
1261  {0xb3f4e093db73a093, 0x59ed216765690f57},
1262  {0xe0f218b8d25088b8, 0x306869c13ec3532d},
1263  {0x8c974f7383725573, 0x1e414218c73a13fc},
1264  {0xafbd2350644eeacf, 0xe5d1929ef90898fb},
1265  {0xdbac6c247d62a583, 0xdf45f746b74abf3a},
1266  {0x894bc396ce5da772, 0x6b8bba8c328eb784},
1267  {0xab9eb47c81f5114f, 0x066ea92f3f326565},
1268  {0xd686619ba27255a2, 0xc80a537b0efefebe},
1269  {0x8613fd0145877585, 0xbd06742ce95f5f37},
1270  {0xa798fc4196e952e7, 0x2c48113823b73705},
1271  {0xd17f3b51fca3a7a0, 0xf75a15862ca504c6},
1272  {0x82ef85133de648c4, 0x9a984d73dbe722fc},
1273  {0xa3ab66580d5fdaf5, 0xc13e60d0d2e0ebbb},
1274  {0xcc963fee10b7d1b3, 0x318df905079926a9},
1275  {0xffbbcfe994e5c61f, 0xfdf17746497f7053},
1276  {0x9fd561f1fd0f9bd3, 0xfeb6ea8bedefa634},
1277  {0xc7caba6e7c5382c8, 0xfe64a52ee96b8fc1},
1278  {0xf9bd690a1b68637b, 0x3dfdce7aa3c673b1},
1279  {0x9c1661a651213e2d, 0x06bea10ca65c084f},
1280  {0xc31bfa0fe5698db8, 0x486e494fcff30a63},
1281  {0xf3e2f893dec3f126, 0x5a89dba3c3efccfb},
1282  {0x986ddb5c6b3a76b7, 0xf89629465a75e01d},
1283  {0xbe89523386091465, 0xf6bbb397f1135824},
1284  {0xee2ba6c0678b597f, 0x746aa07ded582e2d},
1285  {0x94db483840b717ef, 0xa8c2a44eb4571cdd},
1286  {0xba121a4650e4ddeb, 0x92f34d62616ce414},
1287  {0xe896a0d7e51e1566, 0x77b020baf9c81d18},
1288  {0x915e2486ef32cd60, 0x0ace1474dc1d122f},
1289  {0xb5b5ada8aaff80b8, 0x0d819992132456bb},
1290  {0xe3231912d5bf60e6, 0x10e1fff697ed6c6a},
1291  {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},
1292  {0xb1736b96b6fd83b3, 0xbd308ff8a6b17cb3},
1293  {0xddd0467c64bce4a0, 0xac7cb3f6d05ddbdf},
1294  {0x8aa22c0dbef60ee4, 0x6bcdf07a423aa96c},
1295  {0xad4ab7112eb3929d, 0x86c16c98d2c953c7},
1296  {0xd89d64d57a607744, 0xe871c7bf077ba8b8},
1297  {0x87625f056c7c4a8b, 0x11471cd764ad4973},
1298  {0xa93af6c6c79b5d2d, 0xd598e40d3dd89bd0},
1299  {0xd389b47879823479, 0x4aff1d108d4ec2c4},
1300  {0x843610cb4bf160cb, 0xcedf722a585139bb},
1301  {0xa54394fe1eedb8fe, 0xc2974eb4ee658829},
1302  {0xce947a3da6a9273e, 0x733d226229feea33},
1303  {0x811ccc668829b887, 0x0806357d5a3f5260},
1304  {0xa163ff802a3426a8, 0xca07c2dcb0cf26f8},
1305  {0xc9bcff6034c13052, 0xfc89b393dd02f0b6},
1306  {0xfc2c3f3841f17c67, 0xbbac2078d443ace3},
1307  {0x9d9ba7832936edc0, 0xd54b944b84aa4c0e},
1308  {0xc5029163f384a931, 0x0a9e795e65d4df12},
1309  {0xf64335bcf065d37d, 0x4d4617b5ff4a16d6},
1310  {0x99ea0196163fa42e, 0x504bced1bf8e4e46},
1311  {0xc06481fb9bcf8d39, 0xe45ec2862f71e1d7},
1312  {0xf07da27a82c37088, 0x5d767327bb4e5a4d},
1313  {0x964e858c91ba2655, 0x3a6a07f8d510f870},
1314  {0xbbe226efb628afea, 0x890489f70a55368c},
1315  {0xeadab0aba3b2dbe5, 0x2b45ac74ccea842f},
1316  {0x92c8ae6b464fc96f, 0x3b0b8bc90012929e},
1317  {0xb77ada0617e3bbcb, 0x09ce6ebb40173745},
1318  {0xe55990879ddcaabd, 0xcc420a6a101d0516},
1319  {0x8f57fa54c2a9eab6, 0x9fa946824a12232e},
1320  {0xb32df8e9f3546564, 0x47939822dc96abfa},
1321  {0xdff9772470297ebd, 0x59787e2b93bc56f8},
1322  {0x8bfbea76c619ef36, 0x57eb4edb3c55b65b},
1323  {0xaefae51477a06b03, 0xede622920b6b23f2},
1324  {0xdab99e59958885c4, 0xe95fab368e45ecee},
1325  {0x88b402f7fd75539b, 0x11dbcb0218ebb415},
1326  {0xaae103b5fcd2a881, 0xd652bdc29f26a11a},
1327  {0xd59944a37c0752a2, 0x4be76d3346f04960},
1328  {0x857fcae62d8493a5, 0x6f70a4400c562ddc},
1329  {0xa6dfbd9fb8e5b88e, 0xcb4ccd500f6bb953},
1330  {0xd097ad07a71f26b2, 0x7e2000a41346a7a8},
1331  {0x825ecc24c873782f, 0x8ed400668c0c28c9},
1332  {0xa2f67f2dfa90563b, 0x728900802f0f32fb},
1333  {0xcbb41ef979346bca, 0x4f2b40a03ad2ffba},
1334  {0xfea126b7d78186bc, 0xe2f610c84987bfa9},
1335  {0x9f24b832e6b0f436, 0x0dd9ca7d2df4d7ca},
1336  {0xc6ede63fa05d3143, 0x91503d1c79720dbc},
1337  {0xf8a95fcf88747d94, 0x75a44c6397ce912b},
1338  {0x9b69dbe1b548ce7c, 0xc986afbe3ee11abb},
1339  {0xc24452da229b021b, 0xfbe85badce996169},
1340  {0xf2d56790ab41c2a2, 0xfae27299423fb9c4},
1341  {0x97c560ba6b0919a5, 0xdccd879fc967d41b},
1342  {0xbdb6b8e905cb600f, 0x5400e987bbc1c921},
1343  {0xed246723473e3813, 0x290123e9aab23b69},
1344  {0x9436c0760c86e30b, 0xf9a0b6720aaf6522},
1345  {0xb94470938fa89bce, 0xf808e40e8d5b3e6a},
1346  {0xe7958cb87392c2c2, 0xb60b1d1230b20e05},
1347  {0x90bd77f3483bb9b9, 0xb1c6f22b5e6f48c3},
1348  {0xb4ecd5f01a4aa828, 0x1e38aeb6360b1af4},
1349  {0xe2280b6c20dd5232, 0x25c6da63c38de1b1},
1350  {0x8d590723948a535f, 0x579c487e5a38ad0f},
1351  {0xb0af48ec79ace837, 0x2d835a9df0c6d852},
1352  {0xdcdb1b2798182244, 0xf8e431456cf88e66},
1353  {0x8a08f0f8bf0f156b, 0x1b8e9ecb641b5900},
1354  {0xac8b2d36eed2dac5, 0xe272467e3d222f40},
1355  {0xd7adf884aa879177, 0x5b0ed81dcc6abb10},
1356  {0x86ccbb52ea94baea, 0x98e947129fc2b4ea},
1357  {0xa87fea27a539e9a5, 0x3f2398d747b36225},
1358  {0xd29fe4b18e88640e, 0x8eec7f0d19a03aae},
1359  {0x83a3eeeef9153e89, 0x1953cf68300424ad},
1360  {0xa48ceaaab75a8e2b, 0x5fa8c3423c052dd8},
1361  {0xcdb02555653131b6, 0x3792f412cb06794e},
1362  {0x808e17555f3ebf11, 0xe2bbd88bbee40bd1},
1363  {0xa0b19d2ab70e6ed6, 0x5b6aceaeae9d0ec5},
1364  {0xc8de047564d20a8b, 0xf245825a5a445276},
1365  {0xfb158592be068d2e, 0xeed6e2f0f0d56713},
1366  {0x9ced737bb6c4183d, 0x55464dd69685606c},
1367  {0xc428d05aa4751e4c, 0xaa97e14c3c26b887},
1368  {0xf53304714d9265df, 0xd53dd99f4b3066a9},
1369  {0x993fe2c6d07b7fab, 0xe546a8038efe402a},
1370  {0xbf8fdb78849a5f96, 0xde98520472bdd034},
1371  {0xef73d256a5c0f77c, 0x963e66858f6d4441},
1372  {0x95a8637627989aad, 0xdde7001379a44aa9},
1373  {0xbb127c53b17ec159, 0x5560c018580d5d53},
1374  {0xe9d71b689dde71af, 0xaab8f01e6e10b4a7},
1375  {0x9226712162ab070d, 0xcab3961304ca70e9},
1376  {0xb6b00d69bb55c8d1, 0x3d607b97c5fd0d23},
1377  {0xe45c10c42a2b3b05, 0x8cb89a7db77c506b},
1378  {0x8eb98a7a9a5b04e3, 0x77f3608e92adb243},
1379  {0xb267ed1940f1c61c, 0x55f038b237591ed4},
1380  {0xdf01e85f912e37a3, 0x6b6c46dec52f6689},
1381  {0x8b61313bbabce2c6, 0x2323ac4b3b3da016},
1382  {0xae397d8aa96c1b77, 0xabec975e0a0d081b},
1383  {0xd9c7dced53c72255, 0x96e7bd358c904a22},
1384  {0x881cea14545c7575, 0x7e50d64177da2e55},
1385  {0xaa242499697392d2, 0xdde50bd1d5d0b9ea},
1386  {0xd4ad2dbfc3d07787, 0x955e4ec64b44e865},
1387  {0x84ec3c97da624ab4, 0xbd5af13bef0b113f},
1388  {0xa6274bbdd0fadd61, 0xecb1ad8aeacdd58f},
1389  {0xcfb11ead453994ba, 0x67de18eda5814af3},
1390  {0x81ceb32c4b43fcf4, 0x80eacf948770ced8},
1391  {0xa2425ff75e14fc31, 0xa1258379a94d028e},
1392  {0xcad2f7f5359a3b3e, 0x096ee45813a04331},
1393  {0xfd87b5f28300ca0d, 0x8bca9d6e188853fd},
1394  {0x9e74d1b791e07e48, 0x775ea264cf55347e},
1395  {0xc612062576589dda, 0x95364afe032a819e},
1396  {0xf79687aed3eec551, 0x3a83ddbd83f52205},
1397  {0x9abe14cd44753b52, 0xc4926a9672793543},
1398  {0xc16d9a0095928a27, 0x75b7053c0f178294},
1399  {0xf1c90080baf72cb1, 0x5324c68b12dd6339},
1400  {0x971da05074da7bee, 0xd3f6fc16ebca5e04},
1401  {0xbce5086492111aea, 0x88f4bb1ca6bcf585},
1402  {0xec1e4a7db69561a5, 0x2b31e9e3d06c32e6},
1403  {0x9392ee8e921d5d07, 0x3aff322e62439fd0},
1404  {0xb877aa3236a4b449, 0x09befeb9fad487c3},
1405  {0xe69594bec44de15b, 0x4c2ebe687989a9b4},
1406  {0x901d7cf73ab0acd9, 0x0f9d37014bf60a11},
1407  {0xb424dc35095cd80f, 0x538484c19ef38c95},
1408  {0xe12e13424bb40e13, 0x2865a5f206b06fba},
1409  {0x8cbccc096f5088cb, 0xf93f87b7442e45d4},
1410  {0xafebff0bcb24aafe, 0xf78f69a51539d749},
1411  {0xdbe6fecebdedd5be, 0xb573440e5a884d1c},
1412  {0x89705f4136b4a597, 0x31680a88f8953031},
1413  {0xabcc77118461cefc, 0xfdc20d2b36ba7c3e},
1414  {0xd6bf94d5e57a42bc, 0x3d32907604691b4d},
1415  {0x8637bd05af6c69b5, 0xa63f9a49c2c1b110},
1416  {0xa7c5ac471b478423, 0x0fcf80dc33721d54},
1417  {0xd1b71758e219652b, 0xd3c36113404ea4a9},
1418  {0x83126e978d4fdf3b, 0x645a1cac083126ea},
1419  {0xa3d70a3d70a3d70a, 0x3d70a3d70a3d70a4},
1420  {0xcccccccccccccccc, 0xcccccccccccccccd},
1421  {0x8000000000000000, 0x0000000000000000},
1422  {0xa000000000000000, 0x0000000000000000},
1423  {0xc800000000000000, 0x0000000000000000},
1424  {0xfa00000000000000, 0x0000000000000000},
1425  {0x9c40000000000000, 0x0000000000000000},
1426  {0xc350000000000000, 0x0000000000000000},
1427  {0xf424000000000000, 0x0000000000000000},
1428  {0x9896800000000000, 0x0000000000000000},
1429  {0xbebc200000000000, 0x0000000000000000},
1430  {0xee6b280000000000, 0x0000000000000000},
1431  {0x9502f90000000000, 0x0000000000000000},
1432  {0xba43b74000000000, 0x0000000000000000},
1433  {0xe8d4a51000000000, 0x0000000000000000},
1434  {0x9184e72a00000000, 0x0000000000000000},
1435  {0xb5e620f480000000, 0x0000000000000000},
1436  {0xe35fa931a0000000, 0x0000000000000000},
1437  {0x8e1bc9bf04000000, 0x0000000000000000},
1438  {0xb1a2bc2ec5000000, 0x0000000000000000},
1439  {0xde0b6b3a76400000, 0x0000000000000000},
1440  {0x8ac7230489e80000, 0x0000000000000000},
1441  {0xad78ebc5ac620000, 0x0000000000000000},
1442  {0xd8d726b7177a8000, 0x0000000000000000},
1443  {0x878678326eac9000, 0x0000000000000000},
1444  {0xa968163f0a57b400, 0x0000000000000000},
1445  {0xd3c21bcecceda100, 0x0000000000000000},
1446  {0x84595161401484a0, 0x0000000000000000},
1447  {0xa56fa5b99019a5c8, 0x0000000000000000},
1448  {0xcecb8f27f4200f3a, 0x0000000000000000},
1449  {0x813f3978f8940984, 0x4000000000000000},
1450  {0xa18f07d736b90be5, 0x5000000000000000},
1451  {0xc9f2c9cd04674ede, 0xa400000000000000},
1452  {0xfc6f7c4045812296, 0x4d00000000000000},
1453  {0x9dc5ada82b70b59d, 0xf020000000000000},
1454  {0xc5371912364ce305, 0x6c28000000000000},
1455  {0xf684df56c3e01bc6, 0xc732000000000000},
1456  {0x9a130b963a6c115c, 0x3c7f400000000000},
1457  {0xc097ce7bc90715b3, 0x4b9f100000000000},
1458  {0xf0bdc21abb48db20, 0x1e86d40000000000},
1459  {0x96769950b50d88f4, 0x1314448000000000},
1460  {0xbc143fa4e250eb31, 0x17d955a000000000},
1461  {0xeb194f8e1ae525fd, 0x5dcfab0800000000},
1462  {0x92efd1b8d0cf37be, 0x5aa1cae500000000},
1463  {0xb7abc627050305ad, 0xf14a3d9e40000000},
1464  {0xe596b7b0c643c719, 0x6d9ccd05d0000000},
1465  {0x8f7e32ce7bea5c6f, 0xe4820023a2000000},
1466  {0xb35dbf821ae4f38b, 0xdda2802c8a800000},
1467  {0xe0352f62a19e306e, 0xd50b2037ad200000},
1468  {0x8c213d9da502de45, 0x4526f422cc340000},
1469  {0xaf298d050e4395d6, 0x9670b12b7f410000},
1470  {0xdaf3f04651d47b4c, 0x3c0cdd765f114000},
1471  {0x88d8762bf324cd0f, 0xa5880a69fb6ac800},
1472  {0xab0e93b6efee0053, 0x8eea0d047a457a00},
1473  {0xd5d238a4abe98068, 0x72a4904598d6d880},
1474  {0x85a36366eb71f041, 0x47a6da2b7f864750},
1475  {0xa70c3c40a64e6c51, 0x999090b65f67d924},
1476  {0xd0cf4b50cfe20765, 0xfff4b4e3f741cf6d},
1477  {0x82818f1281ed449f, 0xbff8f10e7a8921a4},
1478  {0xa321f2d7226895c7, 0xaff72d52192b6a0d},
1479  {0xcbea6f8ceb02bb39, 0x9bf4f8a69f764490},
1480  {0xfee50b7025c36a08, 0x02f236d04753d5b4},
1481  {0x9f4f2726179a2245, 0x01d762422c946590},
1482  {0xc722f0ef9d80aad6, 0x424d3ad2b7b97ef5},
1483  {0xf8ebad2b84e0d58b, 0xd2e0898765a7deb2},
1484  {0x9b934c3b330c8577, 0x63cc55f49f88eb2f},
1485  {0xc2781f49ffcfa6d5, 0x3cbf6b71c76b25fb},
1486  {0xf316271c7fc3908a, 0x8bef464e3945ef7a},
1487  {0x97edd871cfda3a56, 0x97758bf0e3cbb5ac},
1488  {0xbde94e8e43d0c8ec, 0x3d52eeed1cbea317},
1489  {0xed63a231d4c4fb27, 0x4ca7aaa863ee4bdd},
1490  {0x945e455f24fb1cf8, 0x8fe8caa93e74ef6a},
1491  {0xb975d6b6ee39e436, 0xb3e2fd538e122b44},
1492  {0xe7d34c64a9c85d44, 0x60dbbca87196b616},
1493  {0x90e40fbeea1d3a4a, 0xbc8955e946fe31cd},
1494  {0xb51d13aea4a488dd, 0x6babab6398bdbe41},
1495  {0xe264589a4dcdab14, 0xc696963c7eed2dd1},
1496  {0x8d7eb76070a08aec, 0xfc1e1de5cf543ca2},
1497  {0xb0de65388cc8ada8, 0x3b25a55f43294bcb},
1498  {0xdd15fe86affad912, 0x49ef0eb713f39ebe},
1499  {0x8a2dbf142dfcc7ab, 0x6e3569326c784337},
1500  {0xacb92ed9397bf996, 0x49c2c37f07965404},
1501  {0xd7e77a8f87daf7fb, 0xdc33745ec97be906},
1502  {0x86f0ac99b4e8dafd, 0x69a028bb3ded71a3},
1503  {0xa8acd7c0222311bc, 0xc40832ea0d68ce0c},
1504  {0xd2d80db02aabd62b, 0xf50a3fa490c30190},
1505  {0x83c7088e1aab65db, 0x792667c6da79e0fa},
1506  {0xa4b8cab1a1563f52, 0x577001b891185938},
1507  {0xcde6fd5e09abcf26, 0xed4c0226b55e6f86},
1508  {0x80b05e5ac60b6178, 0x544f8158315b05b4},
1509  {0xa0dc75f1778e39d6, 0x696361ae3db1c721},
1510  {0xc913936dd571c84c, 0x03bc3a19cd1e38e9},
1511  {0xfb5878494ace3a5f, 0x04ab48a04065c723},
1512  {0x9d174b2dcec0e47b, 0x62eb0d64283f9c76},
1513  {0xc45d1df942711d9a, 0x3ba5d0bd324f8394},
1514  {0xf5746577930d6500, 0xca8f44ec7ee36479},
1515  {0x9968bf6abbe85f20, 0x7e998b13cf4e1ecb},
1516  {0xbfc2ef456ae276e8, 0x9e3fedd8c321a67e},
1517  {0xefb3ab16c59b14a2, 0xc5cfe94ef3ea101e},
1518  {0x95d04aee3b80ece5, 0xbba1f1d158724a12},
1519  {0xbb445da9ca61281f, 0x2a8a6e45ae8edc97},
1520  {0xea1575143cf97226, 0xf52d09d71a3293bd},
1521  {0x924d692ca61be758, 0x593c2626705f9c56},
1522  {0xb6e0c377cfa2e12e, 0x6f8b2fb00c77836c},
1523  {0xe498f455c38b997a, 0x0b6dfb9c0f956447},
1524  {0x8edf98b59a373fec, 0x4724bd4189bd5eac},
1525  {0xb2977ee300c50fe7, 0x58edec91ec2cb657},
1526  {0xdf3d5e9bc0f653e1, 0x2f2967b66737e3ed},
1527  {0x8b865b215899f46c, 0xbd79e0d20082ee74},
1528  {0xae67f1e9aec07187, 0xecd8590680a3aa11},
1529  {0xda01ee641a708de9, 0xe80e6f4820cc9495},
1530  {0x884134fe908658b2, 0x3109058d147fdcdd},
1531  {0xaa51823e34a7eede, 0xbd4b46f0599fd415},
1532  {0xd4e5e2cdc1d1ea96, 0x6c9e18ac7007c91a},
1533  {0x850fadc09923329e, 0x03e2cf6bc604ddb0},
1534  {0xa6539930bf6bff45, 0x84db8346b786151c},
1535  {0xcfe87f7cef46ff16, 0xe612641865679a63},
1536  {0x81f14fae158c5f6e, 0x4fcb7e8f3f60c07e},
1537  {0xa26da3999aef7749, 0xe3be5e330f38f09d},
1538  {0xcb090c8001ab551c, 0x5cadf5bfd3072cc5},
1539  {0xfdcb4fa002162a63, 0x73d9732fc7c8f7f6},
1540  {0x9e9f11c4014dda7e, 0x2867e7fddcdd9afa},
1541  {0xc646d63501a1511d, 0xb281e1fd541501b8},
1542  {0xf7d88bc24209a565, 0x1f225a7ca91a4226},
1543  {0x9ae757596946075f, 0x3375788de9b06958},
1544  {0xc1a12d2fc3978937, 0x0052d6b1641c83ae},
1545  {0xf209787bb47d6b84, 0xc0678c5dbd23a49a},
1546  {0x9745eb4d50ce6332, 0xf840b7ba963646e0},
1547  {0xbd176620a501fbff, 0xb650e5a93bc3d898},
1548  {0xec5d3fa8ce427aff, 0xa3e51f138ab4cebe},
1549  {0x93ba47c980e98cdf, 0xc66f336c36b10137},
1550  {0xb8a8d9bbe123f017, 0xb80b0047445d4184},
1551  {0xe6d3102ad96cec1d, 0xa60dc059157491e5},
1552  {0x9043ea1ac7e41392, 0x87c89837ad68db2f},
1553  {0xb454e4a179dd1877, 0x29babe4598c311fb},
1554  {0xe16a1dc9d8545e94, 0xf4296dd6fef3d67a},
1555  {0x8ce2529e2734bb1d, 0x1899e4a65f58660c},
1556  {0xb01ae745b101e9e4, 0x5ec05dcff72e7f8f},
1557  {0xdc21a1171d42645d, 0x76707543f4fa1f73},
1558  {0x899504ae72497eba, 0x6a06494a791c53a8},
1559  {0xabfa45da0edbde69, 0x0487db9d17636892},
1560  {0xd6f8d7509292d603, 0x45a9d2845d3c42b6},
1561  {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b2},
1562  {0xa7f26836f282b732, 0x8e6cac7768d7141e},
1563  {0xd1ef0244af2364ff, 0x3207d795430cd926},
1564  {0x8335616aed761f1f, 0x7f44e6bd49e807b8},
1565  {0xa402b9c5a8d3a6e7, 0x5f16206c9c6209a6},
1566  {0xcd036837130890a1, 0x36dba887c37a8c0f},
1567  {0x802221226be55a64, 0xc2494954da2c9789},
1568  {0xa02aa96b06deb0fd, 0xf2db9baa10b7bd6c},
1569  {0xc83553c5c8965d3d, 0x6f92829494e5acc7},
1570  {0xfa42a8b73abbf48c, 0xcb772339ba1f17f9},
1571  {0x9c69a97284b578d7, 0xff2a760414536efb},
1572  {0xc38413cf25e2d70d, 0xfef5138519684aba},
1573  {0xf46518c2ef5b8cd1, 0x7eb258665fc25d69},
1574  {0x98bf2f79d5993802, 0xef2f773ffbd97a61},
1575  {0xbeeefb584aff8603, 0xaafb550ffacfd8fa},
1576  {0xeeaaba2e5dbf6784, 0x95ba2a53f983cf38},
1577  {0x952ab45cfa97a0b2, 0xdd945a747bf26183},
1578  {0xba756174393d88df, 0x94f971119aeef9e4},
1579  {0xe912b9d1478ceb17, 0x7a37cd5601aab85d},
1580  {0x91abb422ccb812ee, 0xac62e055c10ab33a},
1581  {0xb616a12b7fe617aa, 0x577b986b314d6009},
1582  {0xe39c49765fdf9d94, 0xed5a7e85fda0b80b},
1583  {0x8e41ade9fbebc27d, 0x14588f13be847307},
1584  {0xb1d219647ae6b31c, 0x596eb2d8ae258fc8},
1585  {0xde469fbd99a05fe3, 0x6fca5f8ed9aef3bb},
1586  {0x8aec23d680043bee, 0x25de7bb9480d5854},
1587  {0xada72ccc20054ae9, 0xaf561aa79a10ae6a},
1588  {0xd910f7ff28069da4, 0x1b2ba1518094da04},
1589  {0x87aa9aff79042286, 0x90fb44d2f05d0842},
1590  {0xa99541bf57452b28, 0x353a1607ac744a53},
1591  {0xd3fa922f2d1675f2, 0x42889b8997915ce8},
1592  {0x847c9b5d7c2e09b7, 0x69956135febada11},
1593  {0xa59bc234db398c25, 0x43fab9837e699095},
1594  {0xcf02b2c21207ef2e, 0x94f967e45e03f4bb},
1595  {0x8161afb94b44f57d, 0x1d1be0eebac278f5},
1596  {0xa1ba1ba79e1632dc, 0x6462d92a69731732},
1597  {0xca28a291859bbf93, 0x7d7b8f7503cfdcfe},
1598  {0xfcb2cb35e702af78, 0x5cda735244c3d43e},
1599  {0x9defbf01b061adab, 0x3a0888136afa64a7},
1600  {0xc56baec21c7a1916, 0x088aaa1845b8fdd0},
1601  {0xf6c69a72a3989f5b, 0x8aad549e57273d45},
1602  {0x9a3c2087a63f6399, 0x36ac54e2f678864b},
1603  {0xc0cb28a98fcf3c7f, 0x84576a1bb416a7dd},
1604  {0xf0fdf2d3f3c30b9f, 0x656d44a2a11c51d5},
1605  {0x969eb7c47859e743, 0x9f644ae5a4b1b325},
1606  {0xbc4665b596706114, 0x873d5d9f0dde1fee},
1607  {0xeb57ff22fc0c7959, 0xa90cb506d155a7ea},
1608  {0x9316ff75dd87cbd8, 0x09a7f12442d588f2},
1609  {0xb7dcbf5354e9bece, 0x0c11ed6d538aeb2f},
1610  {0xe5d3ef282a242e81, 0x8f1668c8a86da5fa},
1611  {0x8fa475791a569d10, 0xf96e017d694487bc},
1612  {0xb38d92d760ec4455, 0x37c981dcc395a9ac},
1613  {0xe070f78d3927556a, 0x85bbe253f47b1417},
1614  {0x8c469ab843b89562, 0x93956d7478ccec8e},
1615  {0xaf58416654a6babb, 0x387ac8d1970027b2},
1616  {0xdb2e51bfe9d0696a, 0x06997b05fcc0319e},
1617  {0x88fcf317f22241e2, 0x441fece3bdf81f03},
1618  {0xab3c2fddeeaad25a, 0xd527e81cad7626c3},
1619  {0xd60b3bd56a5586f1, 0x8a71e223d8d3b074},
1620  {0x85c7056562757456, 0xf6872d5667844e49},
1621  {0xa738c6bebb12d16c, 0xb428f8ac016561db},
1622  {0xd106f86e69d785c7, 0xe13336d701beba52},
1623  {0x82a45b450226b39c, 0xecc0024661173473},
1624  {0xa34d721642b06084, 0x27f002d7f95d0190},
1625  {0xcc20ce9bd35c78a5, 0x31ec038df7b441f4},
1626  {0xff290242c83396ce, 0x7e67047175a15271},
1627  {0x9f79a169bd203e41, 0x0f0062c6e984d386},
1628  {0xc75809c42c684dd1, 0x52c07b78a3e60868},
1629  {0xf92e0c3537826145, 0xa7709a56ccdf8a82},
1630  {0x9bbcc7a142b17ccb, 0x88a66076400bb691},
1631  {0xc2abf989935ddbfe, 0x6acff893d00ea435},
1632  {0xf356f7ebf83552fe, 0x0583f6b8c4124d43},
1633  {0x98165af37b2153de, 0xc3727a337a8b704a},
1634  {0xbe1bf1b059e9a8d6, 0x744f18c0592e4c5c},
1635  {0xeda2ee1c7064130c, 0x1162def06f79df73},
1636  {0x9485d4d1c63e8be7, 0x8addcb5645ac2ba8},
1637  {0xb9a74a0637ce2ee1, 0x6d953e2bd7173692},
1638  {0xe8111c87c5c1ba99, 0xc8fa8db6ccdd0437},
1639  {0x910ab1d4db9914a0, 0x1d9c9892400a22a2},
1640  {0xb54d5e4a127f59c8, 0x2503beb6d00cab4b},
1641  {0xe2a0b5dc971f303a, 0x2e44ae64840fd61d},
1642  {0x8da471a9de737e24, 0x5ceaecfed289e5d2},
1643  {0xb10d8e1456105dad, 0x7425a83e872c5f47},
1644  {0xdd50f1996b947518, 0xd12f124e28f77719},
1645  {0x8a5296ffe33cc92f, 0x82bd6b70d99aaa6f},
1646  {0xace73cbfdc0bfb7b, 0x636cc64d1001550b},
1647  {0xd8210befd30efa5a, 0x3c47f7e05401aa4e},
1648  {0x8714a775e3e95c78, 0x65acfaec34810a71},
1649  {0xa8d9d1535ce3b396, 0x7f1839a741a14d0d},
1650  {0xd31045a8341ca07c, 0x1ede48111209a050},
1651  {0x83ea2b892091e44d, 0x934aed0aab460432},
1652  {0xa4e4b66b68b65d60, 0xf81da84d5617853f},
1653  {0xce1de40642e3f4b9, 0x36251260ab9d668e},
1654  {0x80d2ae83e9ce78f3, 0xc1d72b7c6b426019},
1655  {0xa1075a24e4421730, 0xb24cf65b8612f81f},
1656  {0xc94930ae1d529cfc, 0xdee033f26797b627},
1657  {0xfb9b7cd9a4a7443c, 0x169840ef017da3b1},
1658  {0x9d412e0806e88aa5, 0x8e1f289560ee864e},
1659  {0xc491798a08a2ad4e, 0xf1a6f2bab92a27e2},
1660  {0xf5b5d7ec8acb58a2, 0xae10af696774b1db},
1661  {0x9991a6f3d6bf1765, 0xacca6da1e0a8ef29},
1662  {0xbff610b0cc6edd3f, 0x17fd090a58d32af3},
1663  {0xeff394dcff8a948e, 0xddfc4b4cef07f5b0},
1664  {0x95f83d0a1fb69cd9, 0x4abdaf101564f98e},
1665  {0xbb764c4ca7a4440f, 0x9d6d1ad41abe37f1},
1666  {0xea53df5fd18d5513, 0x84c86189216dc5ed},
1667  {0x92746b9be2f8552c, 0x32fd3cf5b4e49bb4},
1668  {0xb7118682dbb66a77, 0x3fbc8c33221dc2a1},
1669  {0xe4d5e82392a40515, 0x0fabaf3feaa5334a},
1670  {0x8f05b1163ba6832d, 0x29cb4d87f2a7400e},
1671  {0xb2c71d5bca9023f8, 0x743e20e9ef511012},
1672  {0xdf78e4b2bd342cf6, 0x914da9246b255416},
1673  {0x8bab8eefb6409c1a, 0x1ad089b6c2f7548e},
1674  {0xae9672aba3d0c320, 0xa184ac2473b529b1},
1675  {0xda3c0f568cc4f3e8, 0xc9e5d72d90a2741e},
1676  {0x8865899617fb1871, 0x7e2fa67c7a658892},
1677  {0xaa7eebfb9df9de8d, 0xddbb901b98feeab7},
1678  {0xd51ea6fa85785631, 0x552a74227f3ea565},
1679  {0x8533285c936b35de, 0xd53a88958f87275f},
1680  {0xa67ff273b8460356, 0x8a892abaf368f137},
1681  {0xd01fef10a657842c, 0x2d2b7569b0432d85},
1682  {0x8213f56a67f6b29b, 0x9c3b29620e29fc73},
1683  {0xa298f2c501f45f42, 0x8349f3ba91b47b8f},
1684  {0xcb3f2f7642717713, 0x241c70a936219a73},
1685  {0xfe0efb53d30dd4d7, 0xed238cd383aa0110},
1686  {0x9ec95d1463e8a506, 0xf4363804324a40aa},
1687  {0xc67bb4597ce2ce48, 0xb143c6053edcd0d5},
1688  {0xf81aa16fdc1b81da, 0xdd94b7868e94050a},
1689  {0x9b10a4e5e9913128, 0xca7cf2b4191c8326},
1690  {0xc1d4ce1f63f57d72, 0xfd1c2f611f63a3f0},
1691  {0xf24a01a73cf2dccf, 0xbc633b39673c8cec},
1692  {0x976e41088617ca01, 0xd5be0503e085d813},
1693  {0xbd49d14aa79dbc82, 0x4b2d8644d8a74e18},
1694  {0xec9c459d51852ba2, 0xddf8e7d60ed1219e},
1695  {0x93e1ab8252f33b45, 0xcabb90e5c942b503},
1696  {0xb8da1662e7b00a17, 0x3d6a751f3b936243},
1697  {0xe7109bfba19c0c9d, 0x0cc512670a783ad4},
1698  {0x906a617d450187e2, 0x27fb2b80668b24c5},
1699  {0xb484f9dc9641e9da, 0xb1f9f660802dedf6},
1700  {0xe1a63853bbd26451, 0x5e7873f8a0396973},
1701  {0x8d07e33455637eb2, 0xdb0b487b6423e1e8},
1702  {0xb049dc016abc5e5f, 0x91ce1a9a3d2cda62},
1703  {0xdc5c5301c56b75f7, 0x7641a140cc7810fb},
1704  {0x89b9b3e11b6329ba, 0xa9e904c87fcb0a9d},
1705  {0xac2820d9623bf429, 0x546345fa9fbdcd44},
1706  {0xd732290fbacaf133, 0xa97c177947ad4095},
1707  {0x867f59a9d4bed6c0, 0x49ed8eabcccc485d},
1708  {0xa81f301449ee8c70, 0x5c68f256bfff5a74},
1709  {0xd226fc195c6a2f8c, 0x73832eec6fff3111},
1710  {0x83585d8fd9c25db7, 0xc831fd53c5ff7eab},
1711  {0xa42e74f3d032f525, 0xba3e7ca8b77f5e55},
1712  {0xcd3a1230c43fb26f, 0x28ce1bd2e55f35eb},
1713  {0x80444b5e7aa7cf85, 0x7980d163cf5b81b3},
1714  {0xa0555e361951c366, 0xd7e105bcc332621f},
1715  {0xc86ab5c39fa63440, 0x8dd9472bf3fefaa7},
1716  {0xfa856334878fc150, 0xb14f98f6f0feb951},
1717  {0x9c935e00d4b9d8d2, 0x6ed1bf9a569f33d3},
1718  {0xc3b8358109e84f07, 0x0a862f80ec4700c8},
1719  {0xf4a642e14c6262c8, 0xcd27bb612758c0fa},
1720  {0x98e7e9cccfbd7dbd, 0x8038d51cb897789c},
1721  {0xbf21e44003acdd2c, 0xe0470a63e6bd56c3},
1722  {0xeeea5d5004981478, 0x1858ccfce06cac74},
1723  {0x95527a5202df0ccb, 0x0f37801e0c43ebc8},
1724  {0xbaa718e68396cffd, 0xd30560258f54e6ba},
1725  {0xe950df20247c83fd, 0x47c6b82ef32a2069},
1726  {0x91d28b7416cdd27e, 0x4cdc331d57fa5441},
1727  {0xb6472e511c81471d, 0xe0133fe4adf8e952},
1728  {0xe3d8f9e563a198e5, 0x58180fddd97723a6},
1729  {0x8e679c2f5e44ff8f, 0x570f09eaa7ea7648},
1730  {0xb201833b35d63f73, 0x2cd2cc6551e513da},
1731  {0xde81e40a034bcf4f, 0xf8077f7ea65e58d1},
1732  {0x8b112e86420f6191, 0xfb04afaf27faf782},
1733  {0xadd57a27d29339f6, 0x79c5db9af1f9b563},
1734  {0xd94ad8b1c7380874, 0x18375281ae7822bc},
1735  {0x87cec76f1c830548, 0x8f2293910d0b15b5},
1736  {0xa9c2794ae3a3c69a, 0xb2eb3875504ddb22},
1737  {0xd433179d9c8cb841, 0x5fa60692a46151eb},
1738  {0x849feec281d7f328, 0xdbc7c41ba6bcd333},
1739  {0xa5c7ea73224deff3, 0x12b9b522906c0800},
1740  {0xcf39e50feae16bef, 0xd768226b34870a00},
1741  {0x81842f29f2cce375, 0xe6a1158300d46640},
1742  {0xa1e53af46f801c53, 0x60495ae3c1097fd0},
1743  {0xca5e89b18b602368, 0x385bb19cb14bdfc4},
1744  {0xfcf62c1dee382c42, 0x46729e03dd9ed7b5},
1745  {0x9e19db92b4e31ba9, 0x6c07a2c26a8346d1},
1746  {0xc5a05277621be293, 0xc7098b7305241885},
1747  { 0xf70867153aa2db38,
1748  0xb8cbee4fc66d1ea7 }
1749 #else
1750  {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
1751  {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
1752  {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},
1753  {0x86a8d39ef77164bc, 0xae5dff9c02033198},
1754  {0xd98ddaee19068c76, 0x3badd624dd9b0958},
1755  {0xafbd2350644eeacf, 0xe5d1929ef90898fb},
1756  {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},
1757  {0xe55990879ddcaabd, 0xcc420a6a101d0516},
1758  {0xb94470938fa89bce, 0xf808e40e8d5b3e6a},
1759  {0x95a8637627989aad, 0xdde7001379a44aa9},
1760  {0xf1c90080baf72cb1, 0x5324c68b12dd6339},
1761  {0xc350000000000000, 0x0000000000000000},
1762  {0x9dc5ada82b70b59d, 0xf020000000000000},
1763  {0xfee50b7025c36a08, 0x02f236d04753d5b4},
1764  {0xcde6fd5e09abcf26, 0xed4c0226b55e6f86},
1765  {0xa6539930bf6bff45, 0x84db8346b786151c},
1766  {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b2},
1767  {0xd910f7ff28069da4, 0x1b2ba1518094da04},
1768  {0xaf58416654a6babb, 0x387ac8d1970027b2},
1769  {0x8da471a9de737e24, 0x5ceaecfed289e5d2},
1770  {0xe4d5e82392a40515, 0x0fabaf3feaa5334a},
1771  {0xb8da1662e7b00a17, 0x3d6a751f3b936243},
1772  { 0x95527a5202df0ccb,
1773  0x0f37801e0c43ebc8 }
1774 #endif
1775  };
1776 
1777 #if FMT_USE_FULL_CACHE_DRAGONBOX
1778  return pow10_significands[k - float_info<double>::min_k];
1779 #else
1780  static constexpr const uint64_t powers_of_5_64[] = {
1781  0x0000000000000001, 0x0000000000000005, 0x0000000000000019,
1782  0x000000000000007d, 0x0000000000000271, 0x0000000000000c35,
1783  0x0000000000003d09, 0x000000000001312d, 0x000000000005f5e1,
1784  0x00000000001dcd65, 0x00000000009502f9, 0x0000000002e90edd,
1785  0x000000000e8d4a51, 0x0000000048c27395, 0x000000016bcc41e9,
1786  0x000000071afd498d, 0x0000002386f26fc1, 0x000000b1a2bc2ec5,
1787  0x000003782dace9d9, 0x00001158e460913d, 0x000056bc75e2d631,
1788  0x0001b1ae4d6e2ef5, 0x000878678326eac9, 0x002a5a058fc295ed,
1789  0x00d3c21bcecceda1, 0x0422ca8b0a00a425, 0x14adf4b7320334b9};
1790 
1791  static constexpr const uint32_t pow10_recovery_errors[] = {
1792  0x50001400, 0x54044100, 0x54014555, 0x55954415, 0x54115555, 0x00000001,
1793  0x50000000, 0x00104000, 0x54010004, 0x05004001, 0x55555544, 0x41545555,
1794  0x54040551, 0x15445545, 0x51555514, 0x10000015, 0x00101100, 0x01100015,
1795  0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x04450514, 0x45414110,
1796  0x55555145, 0x50544050, 0x15040155, 0x11054140, 0x50111514, 0x11451454,
1797  0x00400541, 0x00000000, 0x55555450, 0x10056551, 0x10054011, 0x55551014,
1798  0x69514555, 0x05151109, 0x00155555};
1799 
1800  static const int compression_ratio = 27;
1801 
1802  // Compute base index.
1803  int cache_index = (k - float_info<double>::min_k) / compression_ratio;
1804  int kb = cache_index * compression_ratio + float_info<double>::min_k;
1805  int offset = k - kb;
1806 
1807  // Get base cache.
1808  uint128_wrapper base_cache = pow10_significands[cache_index];
1809  if (offset == 0) return base_cache;
1810 
1811  // Compute the required amount of bit-shift.
1812  int alpha = floor_log2_pow10(kb + offset) - floor_log2_pow10(kb) - offset;
1813  FMT_ASSERT(alpha > 0 && alpha < 64, "shifting error detected");
1814 
1815  // Try to recover the real cache.
1816  uint64_t pow5 = powers_of_5_64[offset];
1817  uint128_wrapper recovered_cache = umul128(base_cache.high(), pow5);
1818  uint128_wrapper middle_low =
1819  umul128(base_cache.low() - (kb < 0 ? 1u : 0u), pow5);
1820 
1821  recovered_cache += middle_low.high();
1822 
1823  uint64_t high_to_middle = recovered_cache.high() << (64 - alpha);
1824  uint64_t middle_to_low = recovered_cache.low() << (64 - alpha);
1825 
1826  recovered_cache =
1827  uint128_wrapper{(recovered_cache.low() >> alpha) | high_to_middle,
1828  ((middle_low.low() >> alpha) | middle_to_low)};
1829 
1830  if (kb < 0) recovered_cache += 1;
1831 
1832  // Get error.
1833  int error_idx = (k - float_info<double>::min_k) / 16;
1834  uint32_t error = (pow10_recovery_errors[error_idx] >>
1835  ((k - float_info<double>::min_k) % 16) * 2) &
1836  0x3;
1837 
1838  // Add the error back.
1839  FMT_ASSERT(recovered_cache.low() + error >= recovered_cache.low(), "");
1840  return {recovered_cache.high(), recovered_cache.low() + error};
1841 #endif
1842  }
1843 
1845  const cache_entry_type& cache) FMT_NOEXCEPT {
1846  return umul192_upper64(u, cache);
1847  }
1848 
1849  static uint32_t compute_delta(cache_entry_type const& cache,
1850  int beta_minus_1) FMT_NOEXCEPT {
1851  return static_cast<uint32_t>(cache.high() >> (64 - 1 - beta_minus_1));
1852  }
1853 
1855  const cache_entry_type& cache,
1856  int beta_minus_1) FMT_NOEXCEPT {
1857  FMT_ASSERT(beta_minus_1 >= 1, "");
1858  FMT_ASSERT(beta_minus_1 < 64, "");
1859 
1860  return ((umul192_middle64(two_f, cache) >> (64 - beta_minus_1)) & 1) != 0;
1861  }
1862 
1864  const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT {
1865  return (cache.high() -
1866  (cache.high() >> (float_info<double>::significand_bits + 2))) >>
1867  (64 - float_info<double>::significand_bits - 1 - beta_minus_1);
1868  }
1869 
1871  const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT {
1872  return (cache.high() +
1873  (cache.high() >> (float_info<double>::significand_bits + 1))) >>
1874  (64 - float_info<double>::significand_bits - 1 - beta_minus_1);
1875  }
1876 
1878  const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT {
1879  return ((cache.high() >>
1880  (64 - float_info<double>::significand_bits - 2 - beta_minus_1)) +
1881  1) /
1882  2;
1883  }
1884 };
1885 
1886 // Various integer checks
1887 template <class T>
1889  return exponent >=
1890  float_info<
1891  T>::case_shorter_interval_left_endpoint_lower_threshold &&
1892  exponent <=
1893  float_info<T>::case_shorter_interval_left_endpoint_upper_threshold;
1894 }
1895 template <class T>
1896 bool is_endpoint_integer(typename float_info<T>::carrier_uint two_f,
1897  int exponent, int minus_k) FMT_NOEXCEPT {
1898  if (exponent < float_info<T>::case_fc_pm_half_lower_threshold) return false;
1899  // For k >= 0.
1900  if (exponent <= float_info<T>::case_fc_pm_half_upper_threshold) return true;
1901  // For k < 0.
1902  if (exponent > float_info<T>::divisibility_check_by_5_threshold) return false;
1903  return divisible_by_power_of_5(two_f, minus_k);
1904 }
1905 
1906 template <class T>
1907 bool is_center_integer(typename float_info<T>::carrier_uint two_f, int exponent,
1908  int minus_k) FMT_NOEXCEPT {
1909  // Exponent for 5 is negative.
1910  if (exponent > float_info<T>::divisibility_check_by_5_threshold) return false;
1911  if (exponent > float_info<T>::case_fc_upper_threshold)
1912  return divisible_by_power_of_5(two_f, minus_k);
1913  // Both exponents are nonnegative.
1914  if (exponent >= float_info<T>::case_fc_lower_threshold) return true;
1915  // Exponent for 2 is negative.
1916  return divisible_by_power_of_2(two_f, minus_k - exponent + 1);
1917 }
1918 
1919 // Remove trailing zeros from n and return the number of zeros removed (float)
1921 #ifdef FMT_BUILTIN_CTZ
1922  int t = FMT_BUILTIN_CTZ(n);
1923 #else
1924  int t = ctz(n);
1925 #endif
1926  if (t > float_info<float>::max_trailing_zeros)
1927  t = float_info<float>::max_trailing_zeros;
1928 
1929  const uint32_t mod_inv1 = 0xcccccccd;
1930  const uint32_t max_quotient1 = 0x33333333;
1931  const uint32_t mod_inv2 = 0xc28f5c29;
1932  const uint32_t max_quotient2 = 0x0a3d70a3;
1933 
1934  int s = 0;
1935  for (; s < t - 1; s += 2) {
1936  if (n * mod_inv2 > max_quotient2) break;
1937  n *= mod_inv2;
1938  }
1939  if (s < t && n * mod_inv1 <= max_quotient1) {
1940  n *= mod_inv1;
1941  ++s;
1942  }
1943  n >>= s;
1944  return s;
1945 }
1946 
1947 // Removes trailing zeros and returns the number of zeros removed (double)
1949 #ifdef FMT_BUILTIN_CTZLL
1950  int t = FMT_BUILTIN_CTZLL(n);
1951 #else
1952  int t = ctzll(n);
1953 #endif
1954  if (t > float_info<double>::max_trailing_zeros)
1955  t = float_info<double>::max_trailing_zeros;
1956  // Divide by 10^8 and reduce to 32-bits
1957  // Since ret_value.significand <= (2^64 - 1) / 1000 < 10^17,
1958  // both of the quotient and the r should fit in 32-bits
1959 
1960  const uint32_t mod_inv1 = 0xcccccccd;
1961  const uint32_t max_quotient1 = 0x33333333;
1962  const uint64_t mod_inv8 = 0xc767074b22e90e21;
1963  const uint64_t max_quotient8 = 0x00002af31dc46118;
1964 
1965  // If the number is divisible by 1'0000'0000, work with the quotient
1966  if (t >= 8) {
1967  auto quotient_candidate = n * mod_inv8;
1968 
1969  if (quotient_candidate <= max_quotient8) {
1970  auto quotient = static_cast<uint32_t>(quotient_candidate >> 8);
1971 
1972  int s = 8;
1973  for (; s < t; ++s) {
1974  if (quotient * mod_inv1 > max_quotient1) break;
1975  quotient *= mod_inv1;
1976  }
1977  quotient >>= (s - 8);
1978  n = quotient;
1979  return s;
1980  }
1981  }
1982 
1983  // Otherwise, work with the remainder
1984  auto quotient = static_cast<uint32_t>(n / 100000000);
1985  auto remainder = static_cast<uint32_t>(n - 100000000 * quotient);
1986 
1987  if (t == 0 || remainder * mod_inv1 > max_quotient1) {
1988  return 0;
1989  }
1990  remainder *= mod_inv1;
1991 
1992  if (t == 1 || remainder * mod_inv1 > max_quotient1) {
1993  n = (remainder >> 1) + quotient * 10000000ull;
1994  return 1;
1995  }
1996  remainder *= mod_inv1;
1997 
1998  if (t == 2 || remainder * mod_inv1 > max_quotient1) {
1999  n = (remainder >> 2) + quotient * 1000000ull;
2000  return 2;
2001  }
2002  remainder *= mod_inv1;
2003 
2004  if (t == 3 || remainder * mod_inv1 > max_quotient1) {
2005  n = (remainder >> 3) + quotient * 100000ull;
2006  return 3;
2007  }
2008  remainder *= mod_inv1;
2009 
2010  if (t == 4 || remainder * mod_inv1 > max_quotient1) {
2011  n = (remainder >> 4) + quotient * 10000ull;
2012  return 4;
2013  }
2014  remainder *= mod_inv1;
2015 
2016  if (t == 5 || remainder * mod_inv1 > max_quotient1) {
2017  n = (remainder >> 5) + quotient * 1000ull;
2018  return 5;
2019  }
2020  remainder *= mod_inv1;
2021 
2022  if (t == 6 || remainder * mod_inv1 > max_quotient1) {
2023  n = (remainder >> 6) + quotient * 100ull;
2024  return 6;
2025  }
2026  remainder *= mod_inv1;
2027 
2028  n = (remainder >> 7) + quotient * 10ull;
2029  return 7;
2030 }
2031 
2032 // The main algorithm for shorter interval case
2033 template <class T>
2034 FMT_INLINE decimal_fp<T> shorter_interval_case(int exponent) FMT_NOEXCEPT {
2035  decimal_fp<T> ret_value;
2036  // Compute k and beta
2037  const int minus_k = floor_log10_pow2_minus_log10_4_over_3(exponent);
2038  const int beta_minus_1 = exponent + floor_log2_pow10(-minus_k);
2039 
2040  // Compute xi and zi
2041  using cache_entry_type = typename cache_accessor<T>::cache_entry_type;
2042  const cache_entry_type cache = cache_accessor<T>::get_cached_power(-minus_k);
2043 
2045  cache, beta_minus_1);
2047  cache, beta_minus_1);
2048 
2049  // If the left endpoint is not an integer, increase it
2050  if (!is_left_endpoint_integer_shorter_interval<T>(exponent)) ++xi;
2051 
2052  // Try bigger divisor
2053  ret_value.significand = zi / 10;
2054 
2055  // If succeed, remove trailing zeros if necessary and return
2056  if (ret_value.significand * 10 >= xi) {
2057  ret_value.exponent = minus_k + 1;
2058  ret_value.exponent += remove_trailing_zeros(ret_value.significand);
2059  return ret_value;
2060  }
2061 
2062  // Otherwise, compute the round-up of y
2063  ret_value.significand =
2065  cache, beta_minus_1);
2066  ret_value.exponent = minus_k;
2067 
2068  // When tie occurs, choose one of them according to the rule
2069  if (exponent >= float_info<T>::shorter_interval_tie_lower_threshold &&
2070  exponent <= float_info<T>::shorter_interval_tie_upper_threshold) {
2071  ret_value.significand = ret_value.significand % 2 == 0
2072  ? ret_value.significand
2073  : ret_value.significand - 1;
2074  } else if (ret_value.significand < xi) {
2075  ++ret_value.significand;
2076  }
2077  return ret_value;
2078 }
2079 
2080 template <typename T> decimal_fp<T> to_decimal(T x) FMT_NOEXCEPT {
2081  // Step 1: integer promotion & Schubfach multiplier calculation.
2082 
2083  using carrier_uint = typename float_info<T>::carrier_uint;
2084  using cache_entry_type = typename cache_accessor<T>::cache_entry_type;
2085  auto br = bit_cast<carrier_uint>(x);
2086 
2087  // Extract significand bits and exponent bits.
2088  const carrier_uint significand_mask =
2089  (static_cast<carrier_uint>(1) << float_info<T>::significand_bits) - 1;
2090  carrier_uint significand = (br & significand_mask);
2091  int exponent = static_cast<int>((br & exponent_mask<T>()) >>
2093 
2094  if (exponent != 0) { // Check if normal.
2096 
2097  // Shorter interval case; proceed like Schubfach.
2098  if (significand == 0) return shorter_interval_case<T>(exponent);
2099 
2100  significand |=
2101  (static_cast<carrier_uint>(1) << float_info<T>::significand_bits);
2102  } else {
2103  // Subnormal case; the interval is always regular.
2104  if (significand == 0) return {0, 0};
2106  }
2107 
2108  const bool include_left_endpoint = (significand % 2 == 0);
2109  const bool include_right_endpoint = include_left_endpoint;
2110 
2111  // Compute k and beta.
2112  const int minus_k = floor_log10_pow2(exponent) - float_info<T>::kappa;
2113  const cache_entry_type cache = cache_accessor<T>::get_cached_power(-minus_k);
2114  const int beta_minus_1 = exponent + floor_log2_pow10(-minus_k);
2115 
2116  // Compute zi and deltai
2117  // 10^kappa <= deltai < 10^(kappa + 1)
2118  const uint32_t deltai = cache_accessor<T>::compute_delta(cache, beta_minus_1);
2119  const carrier_uint two_fc = significand << 1;
2120  const carrier_uint two_fr = two_fc | 1;
2121  const carrier_uint zi =
2122  cache_accessor<T>::compute_mul(two_fr << beta_minus_1, cache);
2123 
2124  // Step 2: Try larger divisor; remove trailing zeros if necessary
2125 
2126  // Using an upper bound on zi, we might be able to optimize the division
2127  // better than the compiler; we are computing zi / big_divisor here
2128  decimal_fp<T> ret_value;
2129  ret_value.significand = divide_by_10_to_kappa_plus_1(zi);
2130  uint32_t r = static_cast<uint32_t>(zi - float_info<T>::big_divisor *
2131  ret_value.significand);
2132 
2133  if (r > deltai) {
2134  goto small_divisor_case_label;
2135  } else if (r < deltai) {
2136  // Exclude the right endpoint if necessary
2137  if (r == 0 && !include_right_endpoint &&
2138  is_endpoint_integer<T>(two_fr, exponent, minus_k)) {
2139  --ret_value.significand;
2141  goto small_divisor_case_label;
2142  }
2143  } else {
2144  // r == deltai; compare fractional parts
2145  // Check conditions in the order different from the paper
2146  // to take advantage of short-circuiting
2147  const carrier_uint two_fl = two_fc - 1;
2148  if ((!include_left_endpoint ||
2149  !is_endpoint_integer<T>(two_fl, exponent, minus_k)) &&
2150  !cache_accessor<T>::compute_mul_parity(two_fl, cache, beta_minus_1)) {
2151  goto small_divisor_case_label;
2152  }
2153  }
2154  ret_value.exponent = minus_k + float_info<T>::kappa + 1;
2155 
2156  // We may need to remove trailing zeros
2157  ret_value.exponent += remove_trailing_zeros(ret_value.significand);
2158  return ret_value;
2159 
2160  // Step 3: Find the significand with the smaller divisor
2161 
2162 small_divisor_case_label:
2163  ret_value.significand *= 10;
2164  ret_value.exponent = minus_k + float_info<T>::kappa;
2165 
2166  const uint32_t mask = (1u << float_info<T>::kappa) - 1;
2167  auto dist = r - (deltai / 2) + (float_info<T>::small_divisor / 2);
2168 
2169  // Is dist divisible by 2^kappa?
2170  if ((dist & mask) == 0) {
2171  const bool approx_y_parity =
2172  ((dist ^ (float_info<T>::small_divisor / 2)) & 1) != 0;
2173  dist >>= float_info<T>::kappa;
2174 
2175  // Is dist divisible by 5^kappa?
2176  if (check_divisibility_and_divide_by_pow5<float_info<T>::kappa>(dist)) {
2177  ret_value.significand += dist;
2178 
2179  // Check z^(f) >= epsilon^(f)
2180  // We have either yi == zi - epsiloni or yi == (zi - epsiloni) - 1,
2181  // where yi == zi - epsiloni if and only if z^(f) >= epsilon^(f)
2182  // Since there are only 2 possibilities, we only need to care about the
2183  // parity. Also, zi and r should have the same parity since the divisor
2184  // is an even number
2185  if (cache_accessor<T>::compute_mul_parity(two_fc, cache, beta_minus_1) !=
2186  approx_y_parity) {
2187  --ret_value.significand;
2188  } else {
2189  // If z^(f) >= epsilon^(f), we might have a tie
2190  // when z^(f) == epsilon^(f), or equivalently, when y is an integer
2191  if (is_center_integer<T>(two_fc, exponent, minus_k)) {
2192  ret_value.significand = ret_value.significand % 2 == 0
2193  ? ret_value.significand
2194  : ret_value.significand - 1;
2195  }
2196  }
2197  }
2198  // Is dist not divisible by 5^kappa?
2199  else {
2200  ret_value.significand += dist;
2201  }
2202  }
2203  // Is dist not divisible by 2^kappa?
2204  else {
2205  // Since we know dist is small, we might be able to optimize the division
2206  // better than the compiler; we are computing dist / small_divisor here
2207  ret_value.significand +=
2208  small_division_by_pow10<float_info<T>::kappa>(dist);
2209  }
2210  return ret_value;
2211 }
2212 } // namespace dragonbox
2213 
2214 // Formats value using a variation of the Fixed-Precision Positive
2215 // Floating-Point Printout ((FPP)^2) algorithm by Steele & White:
2216 // https://fmt.dev/papers/p372-steele.pdf.
2217 template <typename Double>
2218 void fallback_format(Double d, int num_digits, bool binary32, buffer<char>& buf,
2219  int& exp10) {
2220  bigint numerator; // 2 * R in (FPP)^2.
2221  bigint denominator; // 2 * S in (FPP)^2.
2222  // lower and upper are differences between value and corresponding boundaries.
2223  bigint lower; // (M^- in (FPP)^2).
2224  bigint upper_store; // upper's value if different from lower.
2225  bigint* upper = nullptr; // (M^+ in (FPP)^2).
2226  fp value;
2227  // Shift numerator and denominator by an extra bit or two (if lower boundary
2228  // is closer) to make lower and upper integers. This eliminates multiplication
2229  // by 2 during later computations.
2230  const bool is_predecessor_closer =
2231  binary32 ? value.assign(static_cast<float>(d)) : value.assign(d);
2232  int shift = is_predecessor_closer ? 2 : 1;
2233  uint64_t significand = value.f << shift;
2234  if (value.e >= 0) {
2235  numerator.assign(significand);
2236  numerator <<= value.e;
2237  lower.assign(1);
2238  lower <<= value.e;
2239  if (shift != 1) {
2240  upper_store.assign(1);
2241  upper_store <<= value.e + 1;
2242  upper = &upper_store;
2243  }
2244  denominator.assign_pow10(exp10);
2245  denominator <<= shift;
2246  } else if (exp10 < 0) {
2247  numerator.assign_pow10(-exp10);
2248  lower.assign(numerator);
2249  if (shift != 1) {
2250  upper_store.assign(numerator);
2251  upper_store <<= 1;
2252  upper = &upper_store;
2253  }
2254  numerator *= significand;
2255  denominator.assign(1);
2256  denominator <<= shift - value.e;
2257  } else {
2258  numerator.assign(significand);
2259  denominator.assign_pow10(exp10);
2260  denominator <<= shift - value.e;
2261  lower.assign(1);
2262  if (shift != 1) {
2263  upper_store.assign(1ULL << 1);
2264  upper = &upper_store;
2265  }
2266  }
2267  // Invariant: value == (numerator / denominator) * pow(10, exp10).
2268  if (num_digits < 0) {
2269  // Generate the shortest representation.
2270  if (!upper) upper = &lower;
2271  bool even = (value.f & 1) == 0;
2272  num_digits = 0;
2273  char* data = buf.data();
2274  for (;;) {
2275  int digit = numerator.divmod_assign(denominator);
2276  bool low = compare(numerator, lower) - even < 0; // numerator <[=] lower.
2277  // numerator + upper >[=] pow10:
2278  bool high = add_compare(numerator, *upper, denominator) + even > 0;
2279  data[num_digits++] = static_cast<char>('0' + digit);
2280  if (low || high) {
2281  if (!low) {
2282  ++data[num_digits - 1];
2283  } else if (high) {
2284  int result = add_compare(numerator, numerator, denominator);
2285  // Round half to even.
2286  if (result > 0 || (result == 0 && (digit % 2) != 0))
2287  ++data[num_digits - 1];
2288  }
2289  buf.try_resize(to_unsigned(num_digits));
2290  exp10 -= num_digits - 1;
2291  return;
2292  }
2293  numerator *= 10;
2294  lower *= 10;
2295  if (upper != &lower) *upper *= 10;
2296  }
2297  }
2298  // Generate the given number of digits.
2299  exp10 -= num_digits - 1;
2300  if (num_digits == 0) {
2301  buf.try_resize(1);
2302  denominator *= 10;
2303  buf[0] = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0';
2304  return;
2305  }
2306  buf.try_resize(to_unsigned(num_digits));
2307  for (int i = 0; i < num_digits - 1; ++i) {
2308  int digit = numerator.divmod_assign(denominator);
2309  buf[i] = static_cast<char>('0' + digit);
2310  numerator *= 10;
2311  }
2312  int digit = numerator.divmod_assign(denominator);
2313  auto result = add_compare(numerator, numerator, denominator);
2314  if (result > 0 || (result == 0 && (digit % 2) != 0)) {
2315  if (digit == 9) {
2316  const auto overflow = '0' + 10;
2317  buf[num_digits - 1] = overflow;
2318  // Propagate the carry.
2319  for (int i = num_digits - 1; i > 0 && buf[i] == overflow; --i) {
2320  buf[i] = '0';
2321  ++buf[i - 1];
2322  }
2323  if (buf[0] == overflow) {
2324  buf[0] = '1';
2325  ++exp10;
2326  }
2327  return;
2328  }
2329  ++digit;
2330  }
2331  buf[num_digits - 1] = static_cast<char>('0' + digit);
2332 }
2333 
2334 template <typename T>
2335 int format_float(T value, int precision, float_specs specs, buffer<char>& buf) {
2336  static_assert(!std::is_same<T, float>::value, "");
2337  FMT_ASSERT(value >= 0, "value is negative");
2338 
2339  const bool fixed = specs.format == float_format::fixed;
2340  if (value <= 0) { // <= instead of == to silence a warning.
2341  if (precision <= 0 || !fixed) {
2342  buf.push_back('0');
2343  return 0;
2344  }
2345  buf.try_resize(to_unsigned(precision));
2346  std::uninitialized_fill_n(buf.data(), precision, '0');
2347  return -precision;
2348  }
2349 
2350  if (!specs.use_grisu) return snprintf_float(value, precision, specs, buf);
2351 
2352  if (precision < 0) {
2353  // Use Dragonbox for the shortest format.
2354  if (specs.binary32) {
2355  auto dec = dragonbox::to_decimal(static_cast<float>(value));
2356  write<char>(buffer_appender<char>(buf), dec.significand);
2357  return dec.exponent;
2358  }
2359  auto dec = dragonbox::to_decimal(static_cast<double>(value));
2360  write<char>(buffer_appender<char>(buf), dec.significand);
2361  return dec.exponent;
2362  }
2363 
2364  // Use Grisu + Dragon4 for the given precision:
2365  // https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf.
2366  int exp = 0;
2367  const int min_exp = -60; // alpha in Grisu.
2368  int cached_exp10 = 0; // K in Grisu.
2369  fp normalized = normalize(fp(value));
2370  const auto cached_pow = get_cached_power(
2371  min_exp - (normalized.e + fp::significand_size), cached_exp10);
2372  normalized = normalized * cached_pow;
2373  // Limit precision to the maximum possible number of significant digits in an
2374  // IEEE754 double because we don't need to generate zeros.
2375  const int max_double_digits = 767;
2376  if (precision > max_double_digits) precision = max_double_digits;
2377  fixed_handler handler{buf.data(), 0, precision, -cached_exp10, fixed};
2378  if (grisu_gen_digits(normalized, 1, exp, handler) == digits::error) {
2379  exp += handler.size - cached_exp10 - 1;
2380  fallback_format(value, handler.precision, specs.binary32, buf, exp);
2381  } else {
2382  exp += handler.exp10;
2383  buf.try_resize(to_unsigned(handler.size));
2384  }
2385  if (!fixed && !specs.showpoint) {
2386  // Remove trailing zeros.
2387  auto num_digits = buf.size();
2388  while (num_digits > 0 && buf[num_digits - 1] == '0') {
2389  --num_digits;
2390  ++exp;
2391  }
2392  buf.try_resize(num_digits);
2393  }
2394  return exp;
2395 } // namespace detail
2396 
2397 template <typename T>
2398 int snprintf_float(T value, int precision, float_specs specs,
2399  buffer<char>& buf) {
2400  // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
2401  FMT_ASSERT(buf.capacity() > buf.size(), "empty buffer");
2402  static_assert(!std::is_same<T, float>::value, "");
2403 
2404  // Subtract 1 to account for the difference in precision since we use %e for
2405  // both general and exponent format.
2406  if (specs.format == float_format::general ||
2407  specs.format == float_format::exp)
2408  precision = (precision >= 0 ? precision : 6) - 1;
2409 
2410  // Build the format string.
2411  enum { max_format_size = 7 }; // The longest format is "%#.*Le".
2412  char format[max_format_size];
2413  char* format_ptr = format;
2414  *format_ptr++ = '%';
2415  if (specs.showpoint && specs.format == float_format::hex) *format_ptr++ = '#';
2416  if (precision >= 0) {
2417  *format_ptr++ = '.';
2418  *format_ptr++ = '*';
2419  }
2420  if (std::is_same<T, long double>()) *format_ptr++ = 'L';
2421  *format_ptr++ = specs.format != float_format::hex
2422  ? (specs.format == float_format::fixed ? 'f' : 'e')
2423  : (specs.upper ? 'A' : 'a');
2424  *format_ptr = '\0';
2425 
2426  // Format using snprintf.
2427  auto offset = buf.size();
2428  for (;;) {
2429  auto begin = buf.data() + offset;
2430  auto capacity = buf.capacity() - offset;
2431 #ifdef FMT_FUZZ
2432  if (precision > 100000)
2433  throw std::runtime_error(
2434  "fuzz mode - avoid large allocation inside snprintf");
2435 #endif
2436  // Suppress the warning about a nonliteral format string.
2437  // Cannot use auto because of a bug in MinGW (#1532).
2438  int (*snprintf_ptr)(char*, size_t, const char*, ...) = FMT_SNPRINTF;
2439  int result = precision >= 0
2440  ? snprintf_ptr(begin, capacity, format, precision, value)
2441  : snprintf_ptr(begin, capacity, format, value);
2442  if (result < 0) {
2443  // The buffer will grow exponentially.
2444  buf.try_reserve(buf.capacity() + 1);
2445  continue;
2446  }
2447  auto size = to_unsigned(result);
2448  // Size equal to capacity means that the last character was truncated.
2449  if (size >= capacity) {
2450  buf.try_reserve(size + offset + 1); // Add 1 for the terminating '\0'.
2451  continue;
2452  }
2453  auto is_digit = [](char c) { return c >= '0' && c <= '9'; };
2454  if (specs.format == float_format::fixed) {
2455  if (precision == 0) {
2456  buf.try_resize(size);
2457  return 0;
2458  }
2459  // Find and remove the decimal point.
2460  auto end = begin + size, p = end;
2461  do {
2462  --p;
2463  } while (is_digit(*p));
2464  int fraction_size = static_cast<int>(end - p - 1);
2465  std::memmove(p, p + 1, to_unsigned(fraction_size));
2466  buf.try_resize(size - 1);
2467  return -fraction_size;
2468  }
2469  if (specs.format == float_format::hex) {
2470  buf.try_resize(size + offset);
2471  return 0;
2472  }
2473  // Find and parse the exponent.
2474  auto end = begin + size, exp_pos = end;
2475  do {
2476  --exp_pos;
2477  } while (*exp_pos != 'e');
2478  char sign = exp_pos[1];
2479  FMT_ASSERT(sign == '+' || sign == '-', "");
2480  int exp = 0;
2481  auto p = exp_pos + 2; // Skip 'e' and sign.
2482  do {
2483  FMT_ASSERT(is_digit(*p), "");
2484  exp = exp * 10 + (*p++ - '0');
2485  } while (p != end);
2486  if (sign == '-') exp = -exp;
2487  int fraction_size = 0;
2488  if (exp_pos != begin + 1) {
2489  // Remove trailing zeros.
2490  auto fraction_end = exp_pos - 1;
2491  while (*fraction_end == '0') --fraction_end;
2492  // Move the fractional part left to get rid of the decimal point.
2493  fraction_size = static_cast<int>(fraction_end - begin - 1);
2494  std::memmove(begin + 1, begin + 2, to_unsigned(fraction_size));
2495  }
2496  buf.try_resize(to_unsigned(fraction_size) + offset + 1);
2497  return exp - fraction_size;
2498  }
2499 }
2500 } // namespace detail
2501 
2502 template <> struct formatter<detail::bigint> {
2504  format_parse_context& ctx) {
2505  return ctx.begin();
2506  }
2507 
2509  format_context& ctx) {
2510  auto out = ctx.out();
2511  bool first = true;
2512  for (auto i = n.bigits_.size(); i > 0; --i) {
2513  auto value = n.bigits_[i - 1u];
2514  if (first) {
2515  out = format_to(out, FMT_STRING("{:x}"), value);
2516  first = false;
2517  continue;
2518  }
2519  out = format_to(out, FMT_STRING("{:08x}"), value);
2520  }
2521  if (n.exp_ > 0)
2522  out = format_to(out, FMT_STRING("p{}"),
2523  n.exp_ * detail::bigint::bigit_bits);
2524  return out;
2525  }
2526 };
2527 
2529  for_each_codepoint(s, [this](uint32_t cp, int error) {
2530  if (error != 0) FMT_THROW(std::runtime_error("invalid utf8"));
2531  if (cp <= 0xFFFF) {
2532  buffer_.push_back(static_cast<wchar_t>(cp));
2533  } else {
2534  cp -= 0x10000;
2535  buffer_.push_back(static_cast<wchar_t>(0xD800 + (cp >> 10)));
2536  buffer_.push_back(static_cast<wchar_t>(0xDC00 + (cp & 0x3FF)));
2537  }
2538  });
2539  buffer_.push_back(0);
2540 }
2541 
2542 FMT_FUNC void format_system_error(detail::buffer<char>& out, int error_code,
2543  const char* message) FMT_NOEXCEPT {
2544  FMT_TRY {
2545  auto ec = std::error_code(error_code, std::generic_category());
2546  write(std::back_inserter(out), std::system_error(ec, message).what());
2547  return;
2548  }
2549  FMT_CATCH(...) {}
2550  format_error_code(out, error_code, message);
2551 }
2552 
2553 FMT_FUNC void detail::error_handler::on_error(const char* message) {
2554  FMT_THROW(format_error(message));
2555 }
2556 
2557 FMT_FUNC void report_system_error(int error_code,
2558  const char* message) FMT_NOEXCEPT {
2560 }
2561 
2563  // Don't optimize the "{}" case to keep the binary size small and because it
2564  // can be better optimized in fmt::format anyway.
2565  auto buffer = memory_buffer();
2566  detail::vformat_to(buffer, fmt, args);
2567  return to_string(buffer);
2568 }
2569 
2570 #ifdef _WIN32
2571 namespace detail {
2573 extern "C" __declspec(dllimport) int __stdcall WriteConsoleW( //
2574  void*, const void*, dword, dword*, void*);
2575 } // namespace detail
2576 #endif
2577 
2578 namespace detail {
2579 FMT_FUNC void print(std::FILE* f, string_view text) {
2580 #ifdef _WIN32
2581  auto fd = _fileno(f);
2582  if (_isatty(fd)) {
2583  detail::utf8_to_utf16 u16(string_view(text.data(), text.size()));
2584  auto written = detail::dword();
2585  if (detail::WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)),
2586  u16.c_str(), static_cast<uint32_t>(u16.size()),
2587  &written, nullptr)) {
2588  return;
2589  }
2590  // Fallback to fwrite on failure. It can happen if the output has been
2591  // redirected to NUL.
2592  }
2593 #endif
2594  detail::fwrite_fully(text.data(), 1, text.size(), f);
2595 }
2596 } // namespace detail
2597 
2598 FMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args args) {
2600  detail::vformat_to(buffer, format_str, args);
2601  detail::print(f, {buffer.data(), buffer.size()});
2602 }
2603 
2604 #ifdef _WIN32
2605 // Print assuming legacy (non-Unicode) encoding.
2606 FMT_FUNC void detail::vprint_mojibake(std::FILE* f, string_view format_str,
2607  format_args args) {
2609  detail::vformat_to(buffer, format_str,
2611  fwrite_fully(buffer.data(), 1, buffer.size(), f);
2612 }
2613 #endif
2614 
2615 FMT_FUNC void vprint(string_view format_str, format_args args) {
2616  vprint(stdout, format_str, args);
2617 }
2618 
2620 
2621 #endif // FMT_FORMAT_INL_H_
FMT_CONSTEXPR auto to_unsigned(Int value) -> typename std::make_unsigned< Int >::type
Definition: core.h:405
#define FMT_STRING(s)
Definition: format.h:2152
FMT_INLINE int remove_trailing_zeros(uint64_t &n) FMT_NOEXCEPT
Definition: format-inl.h:1948
auto data() FMT_NOEXCEPT-> T *
Definition: core.h:808
GLuint GLsizei const GLchar * message
Definition: glcorearb.h:2543
FMT_API auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result< Char >
Definition: format-inl.h:107
auto make_checked(T *p, size_t) -> T *
Definition: format.h:347
GA_API const UT_StringHolder dist
GLboolean GLboolean GLboolean b
Definition: glcorearb.h:1222
static carrier_uint compute_right_endpoint_for_shorter_interval_case(const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
Definition: format-inl.h:1870
std::string upper(string_view a)
Return an all-upper case version of a (locale-independent).
Definition: strutil.h:402
uint32_t umul96_upper32(uint32_t x, uint64_t y) FMT_NOEXCEPT
Definition: format-inl.h:878
float_info< float >::carrier_uint carrier_uint
Definition: format-inl.h:1040
static carrier_uint compute_right_endpoint_for_shorter_interval_case(const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
Definition: format-inl.h:1102
FMT_API void vprint_mojibake(std::FILE *, string_view, format_args)
Definition: core.h:2745
auto to_string(const T &value) -> std::string
Definition: format.h:2597
#define FMT_CATCH(x)
Definition: format.h:105
int divmod_assign(const bigint &divisor)
Definition: format-inl.h:586
void operator>>=(int shift)
Definition: format-inl.h:355
#define FMT_TRY
Definition: format.h:104
uint128_wrapper & operator+=(uint64_t n) FMT_NOEXCEPT
Definition: format-inl.h:811
int floor_log2_pow10(int e) FMT_NOEXCEPT
Definition: format-inl.h:906
FMT_FUNC void format_system_error(detail::buffer< char > &out, int error_code, const char *message) FMT_NOEXCEPT
Definition: format-inl.h:2542
GLint first
Definition: glcorearb.h:405
FMT_FUNC void vprint(std::FILE *f, string_view format_str, format_args args)
Definition: format-inl.h:2598
FMT_FUNC void format_error_code(detail::buffer< char > &out, int error_code, string_view message) FMT_NOEXCEPT
Definition: format-inl.h:56
bool operator==(fp x, fp y)
Definition: format-inl.h:255
void
Definition: png.h:1083
FMT_INLINE decimal_fp< T > shorter_interval_case(int exponent) FMT_NOEXCEPT
Definition: format-inl.h:2034
typename std::conditional< B, T, F >::type conditional_t
Definition: core.h:322
OIIO_UTIL_API bool copy(string_view from, string_view to, std::string &err)
static FMT_CONSTEXPR_DECL const uint64_t implicit_bit
Definition: format-inl.h:192
static carrier_uint compute_mul(carrier_uint u, const cache_entry_type &cache) FMT_NOEXCEPT
Definition: format-inl.h:1076
auto system_error(int error_code, format_string< T...> fmt, T &&...args) -> std::system_error
Definition: format.h:2240
static carrier_uint compute_round_up_for_shorter_interval_case(const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
Definition: format-inl.h:1877
void operator+=(uint64_t n)
Definition: format-inl.h:351
const GLfloat * c
Definition: glew.h:16631
uint32_t small_division_by_pow10(uint32_t n) FMT_NOEXCEPT
Definition: format-inl.h:1016
uint64_t umul96_lower64(uint32_t x, uint64_t y) FMT_NOEXCEPT
Definition: format-inl.h:892
static carrier_uint compute_left_endpoint_for_shorter_interval_case(const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
Definition: format-inl.h:1095
significand_type f
Definition: format-inl.h:184
GLuint GLuint stream
Definition: glcorearb.h:1832
conditional_t< std::is_same< T, char >::value, appender, std::back_insert_iterator< buffer< T >>> buffer_appender
Definition: core.h:956
static FMT_CONSTEXPR_DECL const int double_significand_size
Definition: format-inl.h:190
bool binary32
Definition: core.h:2534
FMT_INLINE digits::result grisu_gen_digits(fp value, uint64_t error, int &exp, Handler &handler)
Definition: format-inl.h:641
static carrier_uint compute_round_up_for_shorter_interval_case(const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
Definition: format-inl.h:1109
constexpr uint64_t high() const FMT_NOEXCEPT
Definition: format-inl.h:808
void assign_pow10(int exp)
Definition: format-inl.h:522
ImageBuf OIIO_API min(Image_or_Const A, Image_or_Const B, ROI roi={}, int nthreads=0)
#define FMT_CONSTEXPR_DECL
Definition: core.h:99
conditional_t< num_bits< T >()<=32 &&!FMT_REDUCE_INT_INSTANTIATIONS, uint32_t, conditional_t< num_bits< T >()<=64, uint64_t, uint128_t >> uint32_or_64_or_128_t
Definition: format.h:847
T mod_inv
Definition: format-inl.h:949
void fallback_format(Double d, int num_digits, bool binary32, buffer< char > &buf, int &exp10)
Definition: format-inl.h:2218
int floor_log10_pow2(int e) FMT_NOEXCEPT
Definition: format-inl.h:898
FMT_FUNC std::string vformat(string_view fmt, format_args args)
Definition: format-inl.h:2562
void vformat_to(buffer< Char > &buf, basic_string_view< Char > fmt, basic_format_args< FMT_BUFFER_CONTEXT(type_identity_t< Char >)> args, detail::locale_ref loc={})
GLdouble GLdouble t
Definition: glew.h:1403
GLuint buffer
Definition: glcorearb.h:660
void fwrite_fully(const void *ptr, size_t size, size_t count, FILE *stream)
Definition: format-inl.h:89
constexpr const_pointer data() const noexcept
Definition: string_view.h:170
void push_back(const T &value)
Definition: core.h:831
#define FMT_END_NAMESPACE
Definition: core.h:229
FMT_FUNC int count_digits< 4 >(detail::fallback_uintptr n)
Definition: format-inl.h:140
fp operator*(fp x, fp y)
Definition: format-inl.h:275
#define FMT_THROW(x)
Definition: format.h:93
bigint & operator*=(Int value)
Definition: format-inl.h:475
significand_type significand
Definition: format.h:1209
basic_string_view< char > string_view
Definition: core.h:522
GLint GLenum GLint x
Definition: glcorearb.h:409
#define FMT_INLINE
Definition: core.h:208
decimal_fp< T > to_decimal(T x) FMT_NOEXCEPT
Definition: format-inl.h:2080
GLsizeiptr size
Definition: glcorearb.h:664
constexpr size_type size() const noexcept
Definition: string_view.h:150
void operator=(const bigint &)=delete
T max_quotient
Definition: format-inl.h:950
void try_reserve(size_t new_capacity)
Definition: core.h:827
fp get_cached_power(int min_exponent, int &pow10_exponent)
Definition: format-inl.h:279
INT32 * numerator
Definition: wglew.h:1180
CompareResults OIIO_API compare(const ImageBuf &A, const ImageBuf &B, float failthresh, float warnthresh, ROI roi={}, int nthreads=0)
static bool compute_mul_parity(carrier_uint two_f, const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
Definition: format-inl.h:1854
FMT_API auto decimal_point_impl(locale_ref loc) -> Char
Definition: format-inl.h:113
GLuint64EXT * result
Definition: glew.h:14311
static uint32_t compute_delta(const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
Definition: format-inl.h:1081
Definition: core.h:760
~format_error() FMT_NOEXCEPT FMT_OVERRIDE FMT_MSC_DEFAULT
GLint GLenum GLboolean normalized
Definition: glcorearb.h:872
INT32 INT32 * denominator
Definition: wglew.h:1180
int floor_log10_pow2_minus_log10_4_over_3(int e) FMT_NOEXCEPT
Definition: format-inl.h:916
GLint GLuint mask
Definition: glcorearb.h:124
bool is_center_integer(typename float_info< T >::carrier_uint two_f, int exponent, int minus_k) FMT_NOEXCEPT
Definition: format-inl.h:1907
friend int add_compare(const bigint &lhs1, const bigint &lhs2, const bigint &rhs)
Definition: format-inl.h:498
#define FMT_FUNC
Definition: format.h:2824
FMT_FUNC void report_system_error(int error_code, const char *message) FMT_NOEXCEPT
Definition: format-inl.h:2557
GLboolean GLboolean GLboolean GLboolean a
Definition: glcorearb.h:1222
GLuint GLuint end
Definition: glcorearb.h:475
GLsizei const GLchar *const * string
Definition: glcorearb.h:814
FMT_FUNC void print(std::FILE *f, string_view text)
Definition: format-inl.h:2579
#define FMT_SNPRINTF
Definition: format-inl.h:44
friend int compare(const bigint &lhs, const bigint &rhs)
Definition: format-inl.h:481
static uint128_wrapper get_cached_power(int k) FMT_NOEXCEPT
Definition: format-inl.h:1123
static carrier_uint compute_mul(carrier_uint u, const cache_entry_type &cache) FMT_NOEXCEPT
Definition: format-inl.h:1844
basic_memory_buffer< char > memory_buffer
Definition: format.h:736
static uint32_t compute_delta(cache_entry_type const &cache, int beta_minus_1) FMT_NOEXCEPT
Definition: format-inl.h:1849
round_direction
Definition: format-inl.h:600
uint64_t umul128_upper64(uint64_t x, uint64_t y) FMT_NOEXCEPT
Definition: format-inl.h:857
#define FMT_API
Definition: core.h:263
GLfloat GLfloat p
Definition: glew.h:16656
auto capacity() const FMT_NOEXCEPT-> size_t
Definition: core.h:805
typedef int(WINAPI *PFNWGLRELEASEPBUFFERDCARBPROC)(HPBUFFERARB hPbuffer
digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder, uint64_t error, int, bool integral)
Definition: format-inl.h:745
void try_resize(size_t count)
Definition: core.h:818
GLint GLsizei count
Definition: glcorearb.h:405
bool use_grisu
Definition: core.h:2535
IMATH_HOSTDEVICE constexpr int sign(T a) IMATH_NOEXCEPT
Definition: ImathFun.h:33
bool check_divisibility_and_divide_by_pow5(uint32_t &n) FMT_NOEXCEPT
Definition: format-inl.h:999
round_direction get_round_direction(uint64_t divisor, uint64_t remainder, uint64_t error)
Definition: format-inl.h:606
void assign(uint64_t n)
Definition: format-inl.h:448
std::wstring OIIO_UTIL_API utf8_to_utf16(string_view utf8str) noexcept
bigint(uint64_t n)
Definition: format-inl.h:434
constexpr uint128_wrapper(uint64_t high, uint64_t low) FMT_NOEXCEPT
Definition: format-inl.h:804
static const uint64_t log10_2_significand
Definition: format.h:859
auto fprintf(std::FILE *f, const S &fmt, const T &...args) -> int
Definition: printf.h:602
void assign(const bigint &other)
Definition: format-inl.h:440
bool assign(Float d)
Definition: format-inl.h:206
int format_float(T value, int precision, float_specs specs, buffer< char > &buf)
Definition: format-inl.h:2335
GLdouble n
Definition: glcorearb.h:2008
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glcorearb.h:2540
GLenum GLint GLint * precision
Definition: glcorearb.h:1925
constexpr auto begin() const FMT_NOEXCEPT-> iterator
Definition: core.h:649
GLint GLint GLsizei GLint GLenum format
Definition: glcorearb.h:108
void(*)(detail::buffer< char > &, int, const char *) format_func
Definition: format.h:2210
GLenum func
Definition: glcorearb.h:783
FMT_NOINLINE bigint & operator<<=(int shift)
Definition: format-inl.h:460
bool divisible_by_power_of_2(uint64_t x, int exp) FMT_NOEXCEPT
Definition: format-inl.h:937
GLuint divisor
Definition: glcorearb.h:1670
static carrier_uint compute_left_endpoint_for_shorter_interval_case(const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
Definition: format-inl.h:1863
#define FMT_CONSTEXPR
Definition: core.h:98
uint64_t divide_by_10_to_kappa_plus_1(uint64_t n) FMT_NOEXCEPT
Definition: format-inl.h:1032
int snprintf_float(T value, int precision, float_specs specs, buffer< char > &buf)
Definition: format-inl.h:2398
auto bit_cast(const Source &source) -> Dest
Definition: format.h:261
typename basic_string_view< Char >::iterator iterator
Definition: core.h:638
int num_bigits() const
Definition: format-inl.h:458
std::string lower(string_view a)
Return an all-upper case version of a (locale-independent).
Definition: strutil.h:395
constexpr uint64_t low() const FMT_NOEXCEPT
Definition: format-inl.h:809
constexpr locale_ref()
Definition: core.h:1545
GLuint index
Definition: glcorearb.h:786
uint64_t umul192_upper64(uint64_t x, uint128_wrapper y) FMT_NOEXCEPT
Definition: format-inl.h:870
uint128_t
Definition: core.h:396
OutputIt iterator
Definition: core.h:1604
FMT_CONSTEXPR format_parse_context::iterator parse(format_parse_context &ctx)
Definition: format-inl.h:2503
FMT_CONSTEXPR auto is_negative(T value) -> bool
Definition: format.h:826
auto ptr(T p) -> const void *
Definition: format.h:2448
ImageBuf OIIO_API max(Image_or_Const A, Image_or_Const B, ROI roi={}, int nthreads=0)
constexpr auto exponent_mask() -> typename dragonbox::float_info< T >::carrier_uint
Definition: format.h:1218
auto thousands_sep(locale_ref loc) -> thousands_sep_result< Char >
Definition: format.h:1006
GA_API const UT_StringHolder N
static uint64_t get_cached_power(int k) FMT_NOEXCEPT
Definition: format-inl.h:1043
FMT_INLINE auto format_to(OutputIt out, format_string< T...> fmt, T &&...args) -> OutputIt
Definition: core.h:2917
GLsizei const GLfloat * value
Definition: glcorearb.h:824
uint128_wrapper umul128(uint64_t x, uint64_t y) FMT_NOEXCEPT
Definition: format-inl.h:829
GLfloat f
Definition: glcorearb.h:1926
FMT_FUNC void report_error(format_func func, int error_code, const char *message) FMT_NOEXCEPT
Definition: format-inl.h:79
**If you just want to fire and args
Definition: thread.h:609
bool is_endpoint_integer(typename float_info< T >::carrier_uint two_f, int exponent, int minus_k) FMT_NOEXCEPT
Definition: format-inl.h:1896
fp normalize(fp value)
Definition: format-inl.h:240
static bool compute_mul_parity(carrier_uint two_f, const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
Definition: format-inl.h:1086
void resize(size_t count)
Definition: format.h:698
#define FMT_NOEXCEPT
Definition: core.h:153
fp(Double d)
Definition: format-inl.h:202
INT64 INT64 INT64 remainder
Definition: wglew.h:1182
uint64_t power_of_10_64(int exp)
Definition: format-inl.h:630
FMT_CONSTEXPR20 auto count_digits(uint64_t n) -> int
Definition: format.h:919
bool is_left_endpoint_integer_shorter_interval(int exponent) FMT_NOEXCEPT
Definition: format-inl.h:1888
Definition: core.h:1131
bool assign(Float)
Definition: format-inl.h:233
Definition: format-inl.h:948
bool showpoint
Definition: core.h:2536
float_info< double >::carrier_uint carrier_uint
Definition: format-inl.h:1120
GLintptr offset
Definition: glcorearb.h:665
FMT_FUNC std::system_error vsystem_error(int error_code, string_view format_str, format_args args)
Definition: format-inl.h:132
#define FMT_ASSERT(condition, message)
Definition: core.h:365
#define FMT_BEGIN_NAMESPACE
Definition: core.h:234
void align(const bigint &other)
Definition: format-inl.h:573
#define const
Definition: zconf.h:214
IMATH_HOSTDEVICE void intermediate(const Quat< T > &q0, const Quat< T > &q1, const Quat< T > &q2, const Quat< T > &q3, Quat< T > &qa, Quat< T > &qb) IMATH_NOEXCEPT
#define FMT_POWERS_OF_10(factor)
Definition: format.h:851
FMT_CONSTEXPR auto out() -> iterator
Definition: core.h:1636
auto size() const FMT_NOEXCEPT-> size_t
Definition: core.h:802
GLboolean r
Definition: glcorearb.h:1222
FMT_CONSTEXPR void for_each_codepoint(string_view s, F f)
Definition: format.h:484
void write(T &out, bool v)
Definition: ImfXdr.h:287
GLfloat GLfloat GLfloat alpha
Definition: glcorearb.h:112
fp(uint64_t f_val, int e_val)
Definition: format-inl.h:198
bool divisible_by_power_of_5(uint64_t x, int exp) FMT_NOEXCEPT
Definition: format-inl.h:965
GLdouble s
Definition: glew.h:1395
std::integral_constant< bool, B > bool_constant
Definition: core.h:323
#define FMT_NOINLINE
Definition: format.h:69
float_format format
Definition: core.h:2530
auto get() const -> Locale
uint64_t multiply(uint64_t lhs, uint64_t rhs)
Definition: format-inl.h:258
GLint y
Definition: glcorearb.h:103
uint64_t umul192_middle64(uint64_t x, uint128_wrapper y) FMT_NOEXCEPT
Definition: format-inl.h:884
format_context::iterator format(const detail::bigint &n, format_context &ctx)
Definition: format-inl.h:2508
Definition: format.h:895
FMT_FUNC void assert_fail(const char *file, int line, const char *message)
Definition: format-inl.h:34
static FMT_CONSTEXPR_DECL const int significand_size
Definition: format-inl.h:194
bool upper
Definition: core.h:2532
digits::result on_start(uint64_t divisor, uint64_t remainder, uint64_t error, int &exp)
Definition: format-inl.h:728
PcpNodeRef_ChildrenIterator begin(const PcpNodeRef::child_const_range &r)
Support for range-based for loops for PcpNodeRef children ranges.
Definition: node.h:450