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 <cerrno> // errno
13 #include <climits>
14 #include <cmath>
15 #include <exception>
16 
17 #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
18 # include <locale>
19 #endif
20 
21 #ifdef _WIN32
22 # include <io.h> // _isatty
23 #endif
24 
25 #include "format.h"
26 
28 namespace detail {
29 
30 FMT_FUNC void assert_fail(const char* file, int line, const char* message) {
31  // Use unchecked std::fprintf to avoid triggering another assertion when
32  // writing to stderr fails
33  std::fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message);
34  // Chosen instead of std::abort to satisfy Clang in CUDA mode during device
35  // code pass.
36  std::terminate();
37 }
38 
39 FMT_FUNC void throw_format_error(const char* message) {
40  FMT_THROW(format_error(message));
41 }
42 
44  string_view message) noexcept {
45  // Report error code making sure that the output fits into
46  // inline_buffer_size to avoid dynamic memory allocation and potential
47  // bad_alloc.
48  out.try_resize(0);
49  static const char SEP[] = ": ";
50  static const char ERROR_STR[] = "error ";
51  // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
52  size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
53  auto abs_value = static_cast<uint32_or_64_or_128_t<int>>(error_code);
54  if (detail::is_negative(error_code)) {
55  abs_value = 0 - abs_value;
56  ++error_code_size;
57  }
58  error_code_size += detail::to_unsigned(detail::count_digits(abs_value));
59  auto it = buffer_appender<char>(out);
60  if (message.size() <= inline_buffer_size - error_code_size)
61  format_to(it, FMT_STRING("{}{}"), message, SEP);
62  format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code);
63  FMT_ASSERT(out.size() <= inline_buffer_size, "");
64 }
65 
66 FMT_FUNC void report_error(format_func func, int error_code,
67  const char* message) noexcept {
68  memory_buffer full_message;
69  func(full_message, error_code, message);
70  // Don't use fwrite_fully because the latter may throw.
71  if (std::fwrite(full_message.data(), full_message.size(), 1, stderr) > 0)
72  std::fputc('\n', stderr);
73 }
74 
75 // A wrapper around fwrite that throws on error.
76 inline void fwrite_fully(const void* ptr, size_t size, size_t count,
77  FILE* stream) {
78  size_t written = std::fwrite(ptr, size, count, stream);
79  if (written < count)
80  FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
81 }
82 
83 #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
84 template <typename Locale>
85 locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
87 }
88 
89 template <typename Locale> Locale locale_ref::get() const {
91  return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
92 }
93 
94 template <typename Char>
96  auto& facet = std::use_facet<std::numpunct<Char>>(loc.get<std::locale>());
97  auto grouping = facet.grouping();
98  auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep();
99  return {std::move(grouping), thousands_sep};
100 }
101 template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref loc) {
102  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
103  .decimal_point();
104 }
105 #else
106 template <typename Char>
108  return {"\03", FMT_STATIC_THOUSANDS_SEPARATOR};
109 }
110 template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref) {
111  return '.';
112 }
113 #endif
114 
116  const format_specs<>& specs, locale_ref loc) -> bool {
117 #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
118  auto locale = loc.get<std::locale>();
119  // We cannot use the num_put<char> facet because it may produce output in
120  // a wrong encoding.
121  using facet = format_facet<std::locale>;
122  if (std::has_facet<facet>(locale))
123  return std::use_facet<facet>(locale).put(out, value, specs);
124  return facet(locale).put(out, value, specs);
125 #endif
126  return false;
127 }
128 } // namespace detail
129 
130 template <typename Locale> typename Locale::id format_facet<Locale>::id;
131 
132 #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
133 template <typename Locale> format_facet<Locale>::format_facet(Locale& loc) {
134  auto& numpunct = std::use_facet<std::numpunct<char>>(loc);
135  grouping_ = numpunct.grouping();
136  if (!grouping_.empty()) separator_ = std::string(1, numpunct.thousands_sep());
137 }
138 
139 template <>
141  appender out, loc_value val, const format_specs<>& specs) const -> bool {
142  return val.visit(
143  detail::loc_writer<>{out, specs, separator_, grouping_, decimal_point_});
144 }
145 #endif
146 
148  format_args args) {
149  auto ec = std::error_code(error_code, std::generic_category());
150  return std::system_error(ec, vformat(fmt, args));
151 }
152 
153 namespace detail {
154 
155 template <typename F> inline bool operator==(basic_fp<F> x, basic_fp<F> y) {
156  return x.f == y.f && x.e == y.e;
157 }
158 
159 // Compilers should be able to optimize this into the ror instruction.
160 FMT_CONSTEXPR inline uint32_t rotr(uint32_t n, uint32_t r) noexcept {
161  r &= 31;
162  return (n >> r) | (n << (32 - r));
163 }
164 FMT_CONSTEXPR inline uint64_t rotr(uint64_t n, uint32_t r) noexcept {
165  r &= 63;
166  return (n >> r) | (n << (64 - r));
167 }
168 
169 // Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox.
170 namespace dragonbox {
171 // Computes upper 64 bits of multiplication of a 32-bit unsigned integer and a
172 // 64-bit unsigned integer.
173 inline uint64_t umul96_upper64(uint32_t x, uint64_t y) noexcept {
174  return umul128_upper64(static_cast<uint64_t>(x) << 32, y);
175 }
176 
177 // Computes lower 128 bits of multiplication of a 64-bit unsigned integer and a
178 // 128-bit unsigned integer.
180  uint128_fallback y) noexcept {
181  uint64_t high = x * y.high();
182  uint128_fallback high_low = umul128(x, y.low());
183  return {high + high_low.high(), high_low.low()};
184 }
185 
186 // Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a
187 // 64-bit unsigned integer.
188 inline uint64_t umul96_lower64(uint32_t x, uint64_t y) noexcept {
189  return x * y;
190 }
191 
192 // Various fast log computations.
193 inline int floor_log10_pow2_minus_log10_4_over_3(int e) noexcept {
194  FMT_ASSERT(e <= 2936 && e >= -2985, "too large exponent");
195  return (e * 631305 - 261663) >> 21;
196 }
197 
198 FMT_INLINE_VARIABLE constexpr struct {
199  uint32_t divisor;
201 } div_small_pow10_infos[] = {{10, 16}, {100, 16}};
202 
203 // Replaces n by floor(n / pow(10, N)) returning true if and only if n is
204 // divisible by pow(10, N).
205 // Precondition: n <= pow(10, N + 1).
206 template <int N>
207 bool check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept {
208  // The numbers below are chosen such that:
209  // 1. floor(n/d) = floor(nm / 2^k) where d=10 or d=100,
210  // 2. nm mod 2^k < m if and only if n is divisible by d,
211  // where m is magic_number, k is shift_amount
212  // and d is divisor.
213  //
214  // Item 1 is a common technique of replacing division by a constant with
215  // multiplication, see e.g. "Division by Invariant Integers Using
216  // Multiplication" by Granlund and Montgomery (1994). magic_number (m) is set
217  // to ceil(2^k/d) for large enough k.
218  // The idea for item 2 originates from Schubfach.
219  constexpr auto info = div_small_pow10_infos[N - 1];
220  FMT_ASSERT(n <= info.divisor * 10, "n is too large");
221  constexpr uint32_t magic_number =
222  (1u << info.shift_amount) / info.divisor + 1;
223  n *= magic_number;
224  const uint32_t comparison_mask = (1u << info.shift_amount) - 1;
225  bool result = (n & comparison_mask) < magic_number;
226  n >>= info.shift_amount;
227  return result;
228 }
229 
230 // Computes floor(n / pow(10, N)) for small n and N.
231 // Precondition: n <= pow(10, N + 1).
232 template <int N> uint32_t small_division_by_pow10(uint32_t n) noexcept {
233  constexpr auto info = div_small_pow10_infos[N - 1];
234  FMT_ASSERT(n <= info.divisor * 10, "n is too large");
235  constexpr uint32_t magic_number =
236  (1u << info.shift_amount) / info.divisor + 1;
237  return (n * magic_number) >> info.shift_amount;
238 }
239 
240 // Computes floor(n / 10^(kappa + 1)) (float)
241 inline uint32_t divide_by_10_to_kappa_plus_1(uint32_t n) noexcept {
242  // 1374389535 = ceil(2^37/100)
243  return static_cast<uint32_t>((static_cast<uint64_t>(n) * 1374389535) >> 37);
244 }
245 // Computes floor(n / 10^(kappa + 1)) (double)
246 inline uint64_t divide_by_10_to_kappa_plus_1(uint64_t n) noexcept {
247  // 2361183241434822607 = ceil(2^(64+7)/1000)
248  return umul128_upper64(n, 2361183241434822607ull) >> 7;
249 }
250 
251 // Various subroutines using pow10 cache
252 template <typename T> struct cache_accessor;
253 
254 template <> struct cache_accessor<float> {
255  using carrier_uint = float_info<float>::carrier_uint;
256  using cache_entry_type = uint64_t;
257 
258  static uint64_t get_cached_power(int k) noexcept {
259  FMT_ASSERT(k >= float_info<float>::min_k && k <= float_info<float>::max_k,
260  "k is out of range");
261  static constexpr const uint64_t pow10_significands[] = {
262  0x81ceb32c4b43fcf5, 0xa2425ff75e14fc32, 0xcad2f7f5359a3b3f,
263  0xfd87b5f28300ca0e, 0x9e74d1b791e07e49, 0xc612062576589ddb,
264  0xf79687aed3eec552, 0x9abe14cd44753b53, 0xc16d9a0095928a28,
265  0xf1c90080baf72cb2, 0x971da05074da7bef, 0xbce5086492111aeb,
266  0xec1e4a7db69561a6, 0x9392ee8e921d5d08, 0xb877aa3236a4b44a,
267  0xe69594bec44de15c, 0x901d7cf73ab0acda, 0xb424dc35095cd810,
268  0xe12e13424bb40e14, 0x8cbccc096f5088cc, 0xafebff0bcb24aaff,
269  0xdbe6fecebdedd5bf, 0x89705f4136b4a598, 0xabcc77118461cefd,
270  0xd6bf94d5e57a42bd, 0x8637bd05af6c69b6, 0xa7c5ac471b478424,
271  0xd1b71758e219652c, 0x83126e978d4fdf3c, 0xa3d70a3d70a3d70b,
272  0xcccccccccccccccd, 0x8000000000000000, 0xa000000000000000,
273  0xc800000000000000, 0xfa00000000000000, 0x9c40000000000000,
274  0xc350000000000000, 0xf424000000000000, 0x9896800000000000,
275  0xbebc200000000000, 0xee6b280000000000, 0x9502f90000000000,
276  0xba43b74000000000, 0xe8d4a51000000000, 0x9184e72a00000000,
277  0xb5e620f480000000, 0xe35fa931a0000000, 0x8e1bc9bf04000000,
278  0xb1a2bc2ec5000000, 0xde0b6b3a76400000, 0x8ac7230489e80000,
279  0xad78ebc5ac620000, 0xd8d726b7177a8000, 0x878678326eac9000,
280  0xa968163f0a57b400, 0xd3c21bcecceda100, 0x84595161401484a0,
281  0xa56fa5b99019a5c8, 0xcecb8f27f4200f3a, 0x813f3978f8940985,
282  0xa18f07d736b90be6, 0xc9f2c9cd04674edf, 0xfc6f7c4045812297,
283  0x9dc5ada82b70b59e, 0xc5371912364ce306, 0xf684df56c3e01bc7,
284  0x9a130b963a6c115d, 0xc097ce7bc90715b4, 0xf0bdc21abb48db21,
285  0x96769950b50d88f5, 0xbc143fa4e250eb32, 0xeb194f8e1ae525fe,
286  0x92efd1b8d0cf37bf, 0xb7abc627050305ae, 0xe596b7b0c643c71a,
287  0x8f7e32ce7bea5c70, 0xb35dbf821ae4f38c, 0xe0352f62a19e306f};
288  return pow10_significands[k - float_info<float>::min_k];
289  }
290 
291  struct compute_mul_result {
294  };
295  struct compute_mul_parity_result {
296  bool parity;
298  };
299 
300  static compute_mul_result compute_mul(
301  carrier_uint u, const cache_entry_type& cache) noexcept {
302  auto r = umul96_upper64(u, cache);
303  return {static_cast<carrier_uint>(r >> 32),
304  static_cast<carrier_uint>(r) == 0};
305  }
306 
307  static uint32_t compute_delta(const cache_entry_type& cache,
308  int beta) noexcept {
309  return static_cast<uint32_t>(cache >> (64 - 1 - beta));
310  }
311 
312  static compute_mul_parity_result compute_mul_parity(
313  carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept {
314  FMT_ASSERT(beta >= 1, "");
315  FMT_ASSERT(beta < 64, "");
316 
317  auto r = umul96_lower64(two_f, cache);
318  return {((r >> (64 - beta)) & 1) != 0,
319  static_cast<uint32_t>(r >> (32 - beta)) == 0};
320  }
321 
323  const cache_entry_type& cache, int beta) noexcept {
324  return static_cast<carrier_uint>(
325  (cache - (cache >> (num_significand_bits<float>() + 2))) >>
326  (64 - num_significand_bits<float>() - 1 - beta));
327  }
328 
330  const cache_entry_type& cache, int beta) noexcept {
331  return static_cast<carrier_uint>(
332  (cache + (cache >> (num_significand_bits<float>() + 1))) >>
333  (64 - num_significand_bits<float>() - 1 - beta));
334  }
335 
337  const cache_entry_type& cache, int beta) noexcept {
338  return (static_cast<carrier_uint>(
339  cache >> (64 - num_significand_bits<float>() - 2 - beta)) +
340  1) /
341  2;
342  }
343 };
344 
345 template <> struct cache_accessor<double> {
346  using carrier_uint = float_info<double>::carrier_uint;
348 
349  static uint128_fallback get_cached_power(int k) noexcept {
350  FMT_ASSERT(k >= float_info<double>::min_k && k <= float_info<double>::max_k,
351  "k is out of range");
352 
353  static constexpr const uint128_fallback pow10_significands[] = {
354 #if FMT_USE_FULL_CACHE_DRAGONBOX
355  {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
356  {0x9faacf3df73609b1, 0x77b191618c54e9ad},
357  {0xc795830d75038c1d, 0xd59df5b9ef6a2418},
358  {0xf97ae3d0d2446f25, 0x4b0573286b44ad1e},
359  {0x9becce62836ac577, 0x4ee367f9430aec33},
360  {0xc2e801fb244576d5, 0x229c41f793cda740},
361  {0xf3a20279ed56d48a, 0x6b43527578c11110},
362  {0x9845418c345644d6, 0x830a13896b78aaaa},
363  {0xbe5691ef416bd60c, 0x23cc986bc656d554},
364  {0xedec366b11c6cb8f, 0x2cbfbe86b7ec8aa9},
365  {0x94b3a202eb1c3f39, 0x7bf7d71432f3d6aa},
366  {0xb9e08a83a5e34f07, 0xdaf5ccd93fb0cc54},
367  {0xe858ad248f5c22c9, 0xd1b3400f8f9cff69},
368  {0x91376c36d99995be, 0x23100809b9c21fa2},
369  {0xb58547448ffffb2d, 0xabd40a0c2832a78b},
370  {0xe2e69915b3fff9f9, 0x16c90c8f323f516d},
371  {0x8dd01fad907ffc3b, 0xae3da7d97f6792e4},
372  {0xb1442798f49ffb4a, 0x99cd11cfdf41779d},
373  {0xdd95317f31c7fa1d, 0x40405643d711d584},
374  {0x8a7d3eef7f1cfc52, 0x482835ea666b2573},
375  {0xad1c8eab5ee43b66, 0xda3243650005eed0},
376  {0xd863b256369d4a40, 0x90bed43e40076a83},
377  {0x873e4f75e2224e68, 0x5a7744a6e804a292},
378  {0xa90de3535aaae202, 0x711515d0a205cb37},
379  {0xd3515c2831559a83, 0x0d5a5b44ca873e04},
380  {0x8412d9991ed58091, 0xe858790afe9486c3},
381  {0xa5178fff668ae0b6, 0x626e974dbe39a873},
382  {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
383  {0x80fa687f881c7f8e, 0x7ce66634bc9d0b9a},
384  {0xa139029f6a239f72, 0x1c1fffc1ebc44e81},
385  {0xc987434744ac874e, 0xa327ffb266b56221},
386  {0xfbe9141915d7a922, 0x4bf1ff9f0062baa9},
387  {0x9d71ac8fada6c9b5, 0x6f773fc3603db4aa},
388  {0xc4ce17b399107c22, 0xcb550fb4384d21d4},
389  {0xf6019da07f549b2b, 0x7e2a53a146606a49},
390  {0x99c102844f94e0fb, 0x2eda7444cbfc426e},
391  {0xc0314325637a1939, 0xfa911155fefb5309},
392  {0xf03d93eebc589f88, 0x793555ab7eba27cb},
393  {0x96267c7535b763b5, 0x4bc1558b2f3458df},
394  {0xbbb01b9283253ca2, 0x9eb1aaedfb016f17},
395  {0xea9c227723ee8bcb, 0x465e15a979c1cadd},
396  {0x92a1958a7675175f, 0x0bfacd89ec191eca},
397  {0xb749faed14125d36, 0xcef980ec671f667c},
398  {0xe51c79a85916f484, 0x82b7e12780e7401b},
399  {0x8f31cc0937ae58d2, 0xd1b2ecb8b0908811},
400  {0xb2fe3f0b8599ef07, 0x861fa7e6dcb4aa16},
401  {0xdfbdcece67006ac9, 0x67a791e093e1d49b},
402  {0x8bd6a141006042bd, 0xe0c8bb2c5c6d24e1},
403  {0xaecc49914078536d, 0x58fae9f773886e19},
404  {0xda7f5bf590966848, 0xaf39a475506a899f},
405  {0x888f99797a5e012d, 0x6d8406c952429604},
406  {0xaab37fd7d8f58178, 0xc8e5087ba6d33b84},
407  {0xd5605fcdcf32e1d6, 0xfb1e4a9a90880a65},
408  {0x855c3be0a17fcd26, 0x5cf2eea09a550680},
409  {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},
410  {0xd0601d8efc57b08b, 0xf13b94daf124da27},
411  {0x823c12795db6ce57, 0x76c53d08d6b70859},
412  {0xa2cb1717b52481ed, 0x54768c4b0c64ca6f},
413  {0xcb7ddcdda26da268, 0xa9942f5dcf7dfd0a},
414  {0xfe5d54150b090b02, 0xd3f93b35435d7c4d},
415  {0x9efa548d26e5a6e1, 0xc47bc5014a1a6db0},
416  {0xc6b8e9b0709f109a, 0x359ab6419ca1091c},
417  {0xf867241c8cc6d4c0, 0xc30163d203c94b63},
418  {0x9b407691d7fc44f8, 0x79e0de63425dcf1e},
419  {0xc21094364dfb5636, 0x985915fc12f542e5},
420  {0xf294b943e17a2bc4, 0x3e6f5b7b17b2939e},
421  {0x979cf3ca6cec5b5a, 0xa705992ceecf9c43},
422  {0xbd8430bd08277231, 0x50c6ff782a838354},
423  {0xece53cec4a314ebd, 0xa4f8bf5635246429},
424  {0x940f4613ae5ed136, 0x871b7795e136be9a},
425  {0xb913179899f68584, 0x28e2557b59846e40},
426  {0xe757dd7ec07426e5, 0x331aeada2fe589d0},
427  {0x9096ea6f3848984f, 0x3ff0d2c85def7622},
428  {0xb4bca50b065abe63, 0x0fed077a756b53aa},
429  {0xe1ebce4dc7f16dfb, 0xd3e8495912c62895},
430  {0x8d3360f09cf6e4bd, 0x64712dd7abbbd95d},
431  {0xb080392cc4349dec, 0xbd8d794d96aacfb4},
432  {0xdca04777f541c567, 0xecf0d7a0fc5583a1},
433  {0x89e42caaf9491b60, 0xf41686c49db57245},
434  {0xac5d37d5b79b6239, 0x311c2875c522ced6},
435  {0xd77485cb25823ac7, 0x7d633293366b828c},
436  {0x86a8d39ef77164bc, 0xae5dff9c02033198},
437  {0xa8530886b54dbdeb, 0xd9f57f830283fdfd},
438  {0xd267caa862a12d66, 0xd072df63c324fd7c},
439  {0x8380dea93da4bc60, 0x4247cb9e59f71e6e},
440  {0xa46116538d0deb78, 0x52d9be85f074e609},
441  {0xcd795be870516656, 0x67902e276c921f8c},
442  {0x806bd9714632dff6, 0x00ba1cd8a3db53b7},
443  {0xa086cfcd97bf97f3, 0x80e8a40eccd228a5},
444  {0xc8a883c0fdaf7df0, 0x6122cd128006b2ce},
445  {0xfad2a4b13d1b5d6c, 0x796b805720085f82},
446  {0x9cc3a6eec6311a63, 0xcbe3303674053bb1},
447  {0xc3f490aa77bd60fc, 0xbedbfc4411068a9d},
448  {0xf4f1b4d515acb93b, 0xee92fb5515482d45},
449  {0x991711052d8bf3c5, 0x751bdd152d4d1c4b},
450  {0xbf5cd54678eef0b6, 0xd262d45a78a0635e},
451  {0xef340a98172aace4, 0x86fb897116c87c35},
452  {0x9580869f0e7aac0e, 0xd45d35e6ae3d4da1},
453  {0xbae0a846d2195712, 0x8974836059cca10a},
454  {0xe998d258869facd7, 0x2bd1a438703fc94c},
455  {0x91ff83775423cc06, 0x7b6306a34627ddd0},
456  {0xb67f6455292cbf08, 0x1a3bc84c17b1d543},
457  {0xe41f3d6a7377eeca, 0x20caba5f1d9e4a94},
458  {0x8e938662882af53e, 0x547eb47b7282ee9d},
459  {0xb23867fb2a35b28d, 0xe99e619a4f23aa44},
460  {0xdec681f9f4c31f31, 0x6405fa00e2ec94d5},
461  {0x8b3c113c38f9f37e, 0xde83bc408dd3dd05},
462  {0xae0b158b4738705e, 0x9624ab50b148d446},
463  {0xd98ddaee19068c76, 0x3badd624dd9b0958},
464  {0x87f8a8d4cfa417c9, 0xe54ca5d70a80e5d7},
465  {0xa9f6d30a038d1dbc, 0x5e9fcf4ccd211f4d},
466  {0xd47487cc8470652b, 0x7647c32000696720},
467  {0x84c8d4dfd2c63f3b, 0x29ecd9f40041e074},
468  {0xa5fb0a17c777cf09, 0xf468107100525891},
469  {0xcf79cc9db955c2cc, 0x7182148d4066eeb5},
470  {0x81ac1fe293d599bf, 0xc6f14cd848405531},
471  {0xa21727db38cb002f, 0xb8ada00e5a506a7d},
472  {0xca9cf1d206fdc03b, 0xa6d90811f0e4851d},
473  {0xfd442e4688bd304a, 0x908f4a166d1da664},
474  {0x9e4a9cec15763e2e, 0x9a598e4e043287ff},
475  {0xc5dd44271ad3cdba, 0x40eff1e1853f29fe},
476  {0xf7549530e188c128, 0xd12bee59e68ef47d},
477  {0x9a94dd3e8cf578b9, 0x82bb74f8301958cf},
478  {0xc13a148e3032d6e7, 0xe36a52363c1faf02},
479  {0xf18899b1bc3f8ca1, 0xdc44e6c3cb279ac2},
480  {0x96f5600f15a7b7e5, 0x29ab103a5ef8c0ba},
481  {0xbcb2b812db11a5de, 0x7415d448f6b6f0e8},
482  {0xebdf661791d60f56, 0x111b495b3464ad22},
483  {0x936b9fcebb25c995, 0xcab10dd900beec35},
484  {0xb84687c269ef3bfb, 0x3d5d514f40eea743},
485  {0xe65829b3046b0afa, 0x0cb4a5a3112a5113},
486  {0x8ff71a0fe2c2e6dc, 0x47f0e785eaba72ac},
487  {0xb3f4e093db73a093, 0x59ed216765690f57},
488  {0xe0f218b8d25088b8, 0x306869c13ec3532d},
489  {0x8c974f7383725573, 0x1e414218c73a13fc},
490  {0xafbd2350644eeacf, 0xe5d1929ef90898fb},
491  {0xdbac6c247d62a583, 0xdf45f746b74abf3a},
492  {0x894bc396ce5da772, 0x6b8bba8c328eb784},
493  {0xab9eb47c81f5114f, 0x066ea92f3f326565},
494  {0xd686619ba27255a2, 0xc80a537b0efefebe},
495  {0x8613fd0145877585, 0xbd06742ce95f5f37},
496  {0xa798fc4196e952e7, 0x2c48113823b73705},
497  {0xd17f3b51fca3a7a0, 0xf75a15862ca504c6},
498  {0x82ef85133de648c4, 0x9a984d73dbe722fc},
499  {0xa3ab66580d5fdaf5, 0xc13e60d0d2e0ebbb},
500  {0xcc963fee10b7d1b3, 0x318df905079926a9},
501  {0xffbbcfe994e5c61f, 0xfdf17746497f7053},
502  {0x9fd561f1fd0f9bd3, 0xfeb6ea8bedefa634},
503  {0xc7caba6e7c5382c8, 0xfe64a52ee96b8fc1},
504  {0xf9bd690a1b68637b, 0x3dfdce7aa3c673b1},
505  {0x9c1661a651213e2d, 0x06bea10ca65c084f},
506  {0xc31bfa0fe5698db8, 0x486e494fcff30a63},
507  {0xf3e2f893dec3f126, 0x5a89dba3c3efccfb},
508  {0x986ddb5c6b3a76b7, 0xf89629465a75e01d},
509  {0xbe89523386091465, 0xf6bbb397f1135824},
510  {0xee2ba6c0678b597f, 0x746aa07ded582e2d},
511  {0x94db483840b717ef, 0xa8c2a44eb4571cdd},
512  {0xba121a4650e4ddeb, 0x92f34d62616ce414},
513  {0xe896a0d7e51e1566, 0x77b020baf9c81d18},
514  {0x915e2486ef32cd60, 0x0ace1474dc1d122f},
515  {0xb5b5ada8aaff80b8, 0x0d819992132456bb},
516  {0xe3231912d5bf60e6, 0x10e1fff697ed6c6a},
517  {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},
518  {0xb1736b96b6fd83b3, 0xbd308ff8a6b17cb3},
519  {0xddd0467c64bce4a0, 0xac7cb3f6d05ddbdf},
520  {0x8aa22c0dbef60ee4, 0x6bcdf07a423aa96c},
521  {0xad4ab7112eb3929d, 0x86c16c98d2c953c7},
522  {0xd89d64d57a607744, 0xe871c7bf077ba8b8},
523  {0x87625f056c7c4a8b, 0x11471cd764ad4973},
524  {0xa93af6c6c79b5d2d, 0xd598e40d3dd89bd0},
525  {0xd389b47879823479, 0x4aff1d108d4ec2c4},
526  {0x843610cb4bf160cb, 0xcedf722a585139bb},
527  {0xa54394fe1eedb8fe, 0xc2974eb4ee658829},
528  {0xce947a3da6a9273e, 0x733d226229feea33},
529  {0x811ccc668829b887, 0x0806357d5a3f5260},
530  {0xa163ff802a3426a8, 0xca07c2dcb0cf26f8},
531  {0xc9bcff6034c13052, 0xfc89b393dd02f0b6},
532  {0xfc2c3f3841f17c67, 0xbbac2078d443ace3},
533  {0x9d9ba7832936edc0, 0xd54b944b84aa4c0e},
534  {0xc5029163f384a931, 0x0a9e795e65d4df12},
535  {0xf64335bcf065d37d, 0x4d4617b5ff4a16d6},
536  {0x99ea0196163fa42e, 0x504bced1bf8e4e46},
537  {0xc06481fb9bcf8d39, 0xe45ec2862f71e1d7},
538  {0xf07da27a82c37088, 0x5d767327bb4e5a4d},
539  {0x964e858c91ba2655, 0x3a6a07f8d510f870},
540  {0xbbe226efb628afea, 0x890489f70a55368c},
541  {0xeadab0aba3b2dbe5, 0x2b45ac74ccea842f},
542  {0x92c8ae6b464fc96f, 0x3b0b8bc90012929e},
543  {0xb77ada0617e3bbcb, 0x09ce6ebb40173745},
544  {0xe55990879ddcaabd, 0xcc420a6a101d0516},
545  {0x8f57fa54c2a9eab6, 0x9fa946824a12232e},
546  {0xb32df8e9f3546564, 0x47939822dc96abfa},
547  {0xdff9772470297ebd, 0x59787e2b93bc56f8},
548  {0x8bfbea76c619ef36, 0x57eb4edb3c55b65b},
549  {0xaefae51477a06b03, 0xede622920b6b23f2},
550  {0xdab99e59958885c4, 0xe95fab368e45ecee},
551  {0x88b402f7fd75539b, 0x11dbcb0218ebb415},
552  {0xaae103b5fcd2a881, 0xd652bdc29f26a11a},
553  {0xd59944a37c0752a2, 0x4be76d3346f04960},
554  {0x857fcae62d8493a5, 0x6f70a4400c562ddc},
555  {0xa6dfbd9fb8e5b88e, 0xcb4ccd500f6bb953},
556  {0xd097ad07a71f26b2, 0x7e2000a41346a7a8},
557  {0x825ecc24c873782f, 0x8ed400668c0c28c9},
558  {0xa2f67f2dfa90563b, 0x728900802f0f32fb},
559  {0xcbb41ef979346bca, 0x4f2b40a03ad2ffba},
560  {0xfea126b7d78186bc, 0xe2f610c84987bfa9},
561  {0x9f24b832e6b0f436, 0x0dd9ca7d2df4d7ca},
562  {0xc6ede63fa05d3143, 0x91503d1c79720dbc},
563  {0xf8a95fcf88747d94, 0x75a44c6397ce912b},
564  {0x9b69dbe1b548ce7c, 0xc986afbe3ee11abb},
565  {0xc24452da229b021b, 0xfbe85badce996169},
566  {0xf2d56790ab41c2a2, 0xfae27299423fb9c4},
567  {0x97c560ba6b0919a5, 0xdccd879fc967d41b},
568  {0xbdb6b8e905cb600f, 0x5400e987bbc1c921},
569  {0xed246723473e3813, 0x290123e9aab23b69},
570  {0x9436c0760c86e30b, 0xf9a0b6720aaf6522},
571  {0xb94470938fa89bce, 0xf808e40e8d5b3e6a},
572  {0xe7958cb87392c2c2, 0xb60b1d1230b20e05},
573  {0x90bd77f3483bb9b9, 0xb1c6f22b5e6f48c3},
574  {0xb4ecd5f01a4aa828, 0x1e38aeb6360b1af4},
575  {0xe2280b6c20dd5232, 0x25c6da63c38de1b1},
576  {0x8d590723948a535f, 0x579c487e5a38ad0f},
577  {0xb0af48ec79ace837, 0x2d835a9df0c6d852},
578  {0xdcdb1b2798182244, 0xf8e431456cf88e66},
579  {0x8a08f0f8bf0f156b, 0x1b8e9ecb641b5900},
580  {0xac8b2d36eed2dac5, 0xe272467e3d222f40},
581  {0xd7adf884aa879177, 0x5b0ed81dcc6abb10},
582  {0x86ccbb52ea94baea, 0x98e947129fc2b4ea},
583  {0xa87fea27a539e9a5, 0x3f2398d747b36225},
584  {0xd29fe4b18e88640e, 0x8eec7f0d19a03aae},
585  {0x83a3eeeef9153e89, 0x1953cf68300424ad},
586  {0xa48ceaaab75a8e2b, 0x5fa8c3423c052dd8},
587  {0xcdb02555653131b6, 0x3792f412cb06794e},
588  {0x808e17555f3ebf11, 0xe2bbd88bbee40bd1},
589  {0xa0b19d2ab70e6ed6, 0x5b6aceaeae9d0ec5},
590  {0xc8de047564d20a8b, 0xf245825a5a445276},
591  {0xfb158592be068d2e, 0xeed6e2f0f0d56713},
592  {0x9ced737bb6c4183d, 0x55464dd69685606c},
593  {0xc428d05aa4751e4c, 0xaa97e14c3c26b887},
594  {0xf53304714d9265df, 0xd53dd99f4b3066a9},
595  {0x993fe2c6d07b7fab, 0xe546a8038efe402a},
596  {0xbf8fdb78849a5f96, 0xde98520472bdd034},
597  {0xef73d256a5c0f77c, 0x963e66858f6d4441},
598  {0x95a8637627989aad, 0xdde7001379a44aa9},
599  {0xbb127c53b17ec159, 0x5560c018580d5d53},
600  {0xe9d71b689dde71af, 0xaab8f01e6e10b4a7},
601  {0x9226712162ab070d, 0xcab3961304ca70e9},
602  {0xb6b00d69bb55c8d1, 0x3d607b97c5fd0d23},
603  {0xe45c10c42a2b3b05, 0x8cb89a7db77c506b},
604  {0x8eb98a7a9a5b04e3, 0x77f3608e92adb243},
605  {0xb267ed1940f1c61c, 0x55f038b237591ed4},
606  {0xdf01e85f912e37a3, 0x6b6c46dec52f6689},
607  {0x8b61313bbabce2c6, 0x2323ac4b3b3da016},
608  {0xae397d8aa96c1b77, 0xabec975e0a0d081b},
609  {0xd9c7dced53c72255, 0x96e7bd358c904a22},
610  {0x881cea14545c7575, 0x7e50d64177da2e55},
611  {0xaa242499697392d2, 0xdde50bd1d5d0b9ea},
612  {0xd4ad2dbfc3d07787, 0x955e4ec64b44e865},
613  {0x84ec3c97da624ab4, 0xbd5af13bef0b113f},
614  {0xa6274bbdd0fadd61, 0xecb1ad8aeacdd58f},
615  {0xcfb11ead453994ba, 0x67de18eda5814af3},
616  {0x81ceb32c4b43fcf4, 0x80eacf948770ced8},
617  {0xa2425ff75e14fc31, 0xa1258379a94d028e},
618  {0xcad2f7f5359a3b3e, 0x096ee45813a04331},
619  {0xfd87b5f28300ca0d, 0x8bca9d6e188853fd},
620  {0x9e74d1b791e07e48, 0x775ea264cf55347e},
621  {0xc612062576589dda, 0x95364afe032a819e},
622  {0xf79687aed3eec551, 0x3a83ddbd83f52205},
623  {0x9abe14cd44753b52, 0xc4926a9672793543},
624  {0xc16d9a0095928a27, 0x75b7053c0f178294},
625  {0xf1c90080baf72cb1, 0x5324c68b12dd6339},
626  {0x971da05074da7bee, 0xd3f6fc16ebca5e04},
627  {0xbce5086492111aea, 0x88f4bb1ca6bcf585},
628  {0xec1e4a7db69561a5, 0x2b31e9e3d06c32e6},
629  {0x9392ee8e921d5d07, 0x3aff322e62439fd0},
630  {0xb877aa3236a4b449, 0x09befeb9fad487c3},
631  {0xe69594bec44de15b, 0x4c2ebe687989a9b4},
632  {0x901d7cf73ab0acd9, 0x0f9d37014bf60a11},
633  {0xb424dc35095cd80f, 0x538484c19ef38c95},
634  {0xe12e13424bb40e13, 0x2865a5f206b06fba},
635  {0x8cbccc096f5088cb, 0xf93f87b7442e45d4},
636  {0xafebff0bcb24aafe, 0xf78f69a51539d749},
637  {0xdbe6fecebdedd5be, 0xb573440e5a884d1c},
638  {0x89705f4136b4a597, 0x31680a88f8953031},
639  {0xabcc77118461cefc, 0xfdc20d2b36ba7c3e},
640  {0xd6bf94d5e57a42bc, 0x3d32907604691b4d},
641  {0x8637bd05af6c69b5, 0xa63f9a49c2c1b110},
642  {0xa7c5ac471b478423, 0x0fcf80dc33721d54},
643  {0xd1b71758e219652b, 0xd3c36113404ea4a9},
644  {0x83126e978d4fdf3b, 0x645a1cac083126ea},
645  {0xa3d70a3d70a3d70a, 0x3d70a3d70a3d70a4},
646  {0xcccccccccccccccc, 0xcccccccccccccccd},
647  {0x8000000000000000, 0x0000000000000000},
648  {0xa000000000000000, 0x0000000000000000},
649  {0xc800000000000000, 0x0000000000000000},
650  {0xfa00000000000000, 0x0000000000000000},
651  {0x9c40000000000000, 0x0000000000000000},
652  {0xc350000000000000, 0x0000000000000000},
653  {0xf424000000000000, 0x0000000000000000},
654  {0x9896800000000000, 0x0000000000000000},
655  {0xbebc200000000000, 0x0000000000000000},
656  {0xee6b280000000000, 0x0000000000000000},
657  {0x9502f90000000000, 0x0000000000000000},
658  {0xba43b74000000000, 0x0000000000000000},
659  {0xe8d4a51000000000, 0x0000000000000000},
660  {0x9184e72a00000000, 0x0000000000000000},
661  {0xb5e620f480000000, 0x0000000000000000},
662  {0xe35fa931a0000000, 0x0000000000000000},
663  {0x8e1bc9bf04000000, 0x0000000000000000},
664  {0xb1a2bc2ec5000000, 0x0000000000000000},
665  {0xde0b6b3a76400000, 0x0000000000000000},
666  {0x8ac7230489e80000, 0x0000000000000000},
667  {0xad78ebc5ac620000, 0x0000000000000000},
668  {0xd8d726b7177a8000, 0x0000000000000000},
669  {0x878678326eac9000, 0x0000000000000000},
670  {0xa968163f0a57b400, 0x0000000000000000},
671  {0xd3c21bcecceda100, 0x0000000000000000},
672  {0x84595161401484a0, 0x0000000000000000},
673  {0xa56fa5b99019a5c8, 0x0000000000000000},
674  {0xcecb8f27f4200f3a, 0x0000000000000000},
675  {0x813f3978f8940984, 0x4000000000000000},
676  {0xa18f07d736b90be5, 0x5000000000000000},
677  {0xc9f2c9cd04674ede, 0xa400000000000000},
678  {0xfc6f7c4045812296, 0x4d00000000000000},
679  {0x9dc5ada82b70b59d, 0xf020000000000000},
680  {0xc5371912364ce305, 0x6c28000000000000},
681  {0xf684df56c3e01bc6, 0xc732000000000000},
682  {0x9a130b963a6c115c, 0x3c7f400000000000},
683  {0xc097ce7bc90715b3, 0x4b9f100000000000},
684  {0xf0bdc21abb48db20, 0x1e86d40000000000},
685  {0x96769950b50d88f4, 0x1314448000000000},
686  {0xbc143fa4e250eb31, 0x17d955a000000000},
687  {0xeb194f8e1ae525fd, 0x5dcfab0800000000},
688  {0x92efd1b8d0cf37be, 0x5aa1cae500000000},
689  {0xb7abc627050305ad, 0xf14a3d9e40000000},
690  {0xe596b7b0c643c719, 0x6d9ccd05d0000000},
691  {0x8f7e32ce7bea5c6f, 0xe4820023a2000000},
692  {0xb35dbf821ae4f38b, 0xdda2802c8a800000},
693  {0xe0352f62a19e306e, 0xd50b2037ad200000},
694  {0x8c213d9da502de45, 0x4526f422cc340000},
695  {0xaf298d050e4395d6, 0x9670b12b7f410000},
696  {0xdaf3f04651d47b4c, 0x3c0cdd765f114000},
697  {0x88d8762bf324cd0f, 0xa5880a69fb6ac800},
698  {0xab0e93b6efee0053, 0x8eea0d047a457a00},
699  {0xd5d238a4abe98068, 0x72a4904598d6d880},
700  {0x85a36366eb71f041, 0x47a6da2b7f864750},
701  {0xa70c3c40a64e6c51, 0x999090b65f67d924},
702  {0xd0cf4b50cfe20765, 0xfff4b4e3f741cf6d},
703  {0x82818f1281ed449f, 0xbff8f10e7a8921a5},
704  {0xa321f2d7226895c7, 0xaff72d52192b6a0e},
705  {0xcbea6f8ceb02bb39, 0x9bf4f8a69f764491},
706  {0xfee50b7025c36a08, 0x02f236d04753d5b5},
707  {0x9f4f2726179a2245, 0x01d762422c946591},
708  {0xc722f0ef9d80aad6, 0x424d3ad2b7b97ef6},
709  {0xf8ebad2b84e0d58b, 0xd2e0898765a7deb3},
710  {0x9b934c3b330c8577, 0x63cc55f49f88eb30},
711  {0xc2781f49ffcfa6d5, 0x3cbf6b71c76b25fc},
712  {0xf316271c7fc3908a, 0x8bef464e3945ef7b},
713  {0x97edd871cfda3a56, 0x97758bf0e3cbb5ad},
714  {0xbde94e8e43d0c8ec, 0x3d52eeed1cbea318},
715  {0xed63a231d4c4fb27, 0x4ca7aaa863ee4bde},
716  {0x945e455f24fb1cf8, 0x8fe8caa93e74ef6b},
717  {0xb975d6b6ee39e436, 0xb3e2fd538e122b45},
718  {0xe7d34c64a9c85d44, 0x60dbbca87196b617},
719  {0x90e40fbeea1d3a4a, 0xbc8955e946fe31ce},
720  {0xb51d13aea4a488dd, 0x6babab6398bdbe42},
721  {0xe264589a4dcdab14, 0xc696963c7eed2dd2},
722  {0x8d7eb76070a08aec, 0xfc1e1de5cf543ca3},
723  {0xb0de65388cc8ada8, 0x3b25a55f43294bcc},
724  {0xdd15fe86affad912, 0x49ef0eb713f39ebf},
725  {0x8a2dbf142dfcc7ab, 0x6e3569326c784338},
726  {0xacb92ed9397bf996, 0x49c2c37f07965405},
727  {0xd7e77a8f87daf7fb, 0xdc33745ec97be907},
728  {0x86f0ac99b4e8dafd, 0x69a028bb3ded71a4},
729  {0xa8acd7c0222311bc, 0xc40832ea0d68ce0d},
730  {0xd2d80db02aabd62b, 0xf50a3fa490c30191},
731  {0x83c7088e1aab65db, 0x792667c6da79e0fb},
732  {0xa4b8cab1a1563f52, 0x577001b891185939},
733  {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87},
734  {0x80b05e5ac60b6178, 0x544f8158315b05b5},
735  {0xa0dc75f1778e39d6, 0x696361ae3db1c722},
736  {0xc913936dd571c84c, 0x03bc3a19cd1e38ea},
737  {0xfb5878494ace3a5f, 0x04ab48a04065c724},
738  {0x9d174b2dcec0e47b, 0x62eb0d64283f9c77},
739  {0xc45d1df942711d9a, 0x3ba5d0bd324f8395},
740  {0xf5746577930d6500, 0xca8f44ec7ee3647a},
741  {0x9968bf6abbe85f20, 0x7e998b13cf4e1ecc},
742  {0xbfc2ef456ae276e8, 0x9e3fedd8c321a67f},
743  {0xefb3ab16c59b14a2, 0xc5cfe94ef3ea101f},
744  {0x95d04aee3b80ece5, 0xbba1f1d158724a13},
745  {0xbb445da9ca61281f, 0x2a8a6e45ae8edc98},
746  {0xea1575143cf97226, 0xf52d09d71a3293be},
747  {0x924d692ca61be758, 0x593c2626705f9c57},
748  {0xb6e0c377cfa2e12e, 0x6f8b2fb00c77836d},
749  {0xe498f455c38b997a, 0x0b6dfb9c0f956448},
750  {0x8edf98b59a373fec, 0x4724bd4189bd5ead},
751  {0xb2977ee300c50fe7, 0x58edec91ec2cb658},
752  {0xdf3d5e9bc0f653e1, 0x2f2967b66737e3ee},
753  {0x8b865b215899f46c, 0xbd79e0d20082ee75},
754  {0xae67f1e9aec07187, 0xecd8590680a3aa12},
755  {0xda01ee641a708de9, 0xe80e6f4820cc9496},
756  {0x884134fe908658b2, 0x3109058d147fdcde},
757  {0xaa51823e34a7eede, 0xbd4b46f0599fd416},
758  {0xd4e5e2cdc1d1ea96, 0x6c9e18ac7007c91b},
759  {0x850fadc09923329e, 0x03e2cf6bc604ddb1},
760  {0xa6539930bf6bff45, 0x84db8346b786151d},
761  {0xcfe87f7cef46ff16, 0xe612641865679a64},
762  {0x81f14fae158c5f6e, 0x4fcb7e8f3f60c07f},
763  {0xa26da3999aef7749, 0xe3be5e330f38f09e},
764  {0xcb090c8001ab551c, 0x5cadf5bfd3072cc6},
765  {0xfdcb4fa002162a63, 0x73d9732fc7c8f7f7},
766  {0x9e9f11c4014dda7e, 0x2867e7fddcdd9afb},
767  {0xc646d63501a1511d, 0xb281e1fd541501b9},
768  {0xf7d88bc24209a565, 0x1f225a7ca91a4227},
769  {0x9ae757596946075f, 0x3375788de9b06959},
770  {0xc1a12d2fc3978937, 0x0052d6b1641c83af},
771  {0xf209787bb47d6b84, 0xc0678c5dbd23a49b},
772  {0x9745eb4d50ce6332, 0xf840b7ba963646e1},
773  {0xbd176620a501fbff, 0xb650e5a93bc3d899},
774  {0xec5d3fa8ce427aff, 0xa3e51f138ab4cebf},
775  {0x93ba47c980e98cdf, 0xc66f336c36b10138},
776  {0xb8a8d9bbe123f017, 0xb80b0047445d4185},
777  {0xe6d3102ad96cec1d, 0xa60dc059157491e6},
778  {0x9043ea1ac7e41392, 0x87c89837ad68db30},
779  {0xb454e4a179dd1877, 0x29babe4598c311fc},
780  {0xe16a1dc9d8545e94, 0xf4296dd6fef3d67b},
781  {0x8ce2529e2734bb1d, 0x1899e4a65f58660d},
782  {0xb01ae745b101e9e4, 0x5ec05dcff72e7f90},
783  {0xdc21a1171d42645d, 0x76707543f4fa1f74},
784  {0x899504ae72497eba, 0x6a06494a791c53a9},
785  {0xabfa45da0edbde69, 0x0487db9d17636893},
786  {0xd6f8d7509292d603, 0x45a9d2845d3c42b7},
787  {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3},
788  {0xa7f26836f282b732, 0x8e6cac7768d7141f},
789  {0xd1ef0244af2364ff, 0x3207d795430cd927},
790  {0x8335616aed761f1f, 0x7f44e6bd49e807b9},
791  {0xa402b9c5a8d3a6e7, 0x5f16206c9c6209a7},
792  {0xcd036837130890a1, 0x36dba887c37a8c10},
793  {0x802221226be55a64, 0xc2494954da2c978a},
794  {0xa02aa96b06deb0fd, 0xf2db9baa10b7bd6d},
795  {0xc83553c5c8965d3d, 0x6f92829494e5acc8},
796  {0xfa42a8b73abbf48c, 0xcb772339ba1f17fa},
797  {0x9c69a97284b578d7, 0xff2a760414536efc},
798  {0xc38413cf25e2d70d, 0xfef5138519684abb},
799  {0xf46518c2ef5b8cd1, 0x7eb258665fc25d6a},
800  {0x98bf2f79d5993802, 0xef2f773ffbd97a62},
801  {0xbeeefb584aff8603, 0xaafb550ffacfd8fb},
802  {0xeeaaba2e5dbf6784, 0x95ba2a53f983cf39},
803  {0x952ab45cfa97a0b2, 0xdd945a747bf26184},
804  {0xba756174393d88df, 0x94f971119aeef9e5},
805  {0xe912b9d1478ceb17, 0x7a37cd5601aab85e},
806  {0x91abb422ccb812ee, 0xac62e055c10ab33b},
807  {0xb616a12b7fe617aa, 0x577b986b314d600a},
808  {0xe39c49765fdf9d94, 0xed5a7e85fda0b80c},
809  {0x8e41ade9fbebc27d, 0x14588f13be847308},
810  {0xb1d219647ae6b31c, 0x596eb2d8ae258fc9},
811  {0xde469fbd99a05fe3, 0x6fca5f8ed9aef3bc},
812  {0x8aec23d680043bee, 0x25de7bb9480d5855},
813  {0xada72ccc20054ae9, 0xaf561aa79a10ae6b},
814  {0xd910f7ff28069da4, 0x1b2ba1518094da05},
815  {0x87aa9aff79042286, 0x90fb44d2f05d0843},
816  {0xa99541bf57452b28, 0x353a1607ac744a54},
817  {0xd3fa922f2d1675f2, 0x42889b8997915ce9},
818  {0x847c9b5d7c2e09b7, 0x69956135febada12},
819  {0xa59bc234db398c25, 0x43fab9837e699096},
820  {0xcf02b2c21207ef2e, 0x94f967e45e03f4bc},
821  {0x8161afb94b44f57d, 0x1d1be0eebac278f6},
822  {0xa1ba1ba79e1632dc, 0x6462d92a69731733},
823  {0xca28a291859bbf93, 0x7d7b8f7503cfdcff},
824  {0xfcb2cb35e702af78, 0x5cda735244c3d43f},
825  {0x9defbf01b061adab, 0x3a0888136afa64a8},
826  {0xc56baec21c7a1916, 0x088aaa1845b8fdd1},
827  {0xf6c69a72a3989f5b, 0x8aad549e57273d46},
828  {0x9a3c2087a63f6399, 0x36ac54e2f678864c},
829  {0xc0cb28a98fcf3c7f, 0x84576a1bb416a7de},
830  {0xf0fdf2d3f3c30b9f, 0x656d44a2a11c51d6},
831  {0x969eb7c47859e743, 0x9f644ae5a4b1b326},
832  {0xbc4665b596706114, 0x873d5d9f0dde1fef},
833  {0xeb57ff22fc0c7959, 0xa90cb506d155a7eb},
834  {0x9316ff75dd87cbd8, 0x09a7f12442d588f3},
835  {0xb7dcbf5354e9bece, 0x0c11ed6d538aeb30},
836  {0xe5d3ef282a242e81, 0x8f1668c8a86da5fb},
837  {0x8fa475791a569d10, 0xf96e017d694487bd},
838  {0xb38d92d760ec4455, 0x37c981dcc395a9ad},
839  {0xe070f78d3927556a, 0x85bbe253f47b1418},
840  {0x8c469ab843b89562, 0x93956d7478ccec8f},
841  {0xaf58416654a6babb, 0x387ac8d1970027b3},
842  {0xdb2e51bfe9d0696a, 0x06997b05fcc0319f},
843  {0x88fcf317f22241e2, 0x441fece3bdf81f04},
844  {0xab3c2fddeeaad25a, 0xd527e81cad7626c4},
845  {0xd60b3bd56a5586f1, 0x8a71e223d8d3b075},
846  {0x85c7056562757456, 0xf6872d5667844e4a},
847  {0xa738c6bebb12d16c, 0xb428f8ac016561dc},
848  {0xd106f86e69d785c7, 0xe13336d701beba53},
849  {0x82a45b450226b39c, 0xecc0024661173474},
850  {0xa34d721642b06084, 0x27f002d7f95d0191},
851  {0xcc20ce9bd35c78a5, 0x31ec038df7b441f5},
852  {0xff290242c83396ce, 0x7e67047175a15272},
853  {0x9f79a169bd203e41, 0x0f0062c6e984d387},
854  {0xc75809c42c684dd1, 0x52c07b78a3e60869},
855  {0xf92e0c3537826145, 0xa7709a56ccdf8a83},
856  {0x9bbcc7a142b17ccb, 0x88a66076400bb692},
857  {0xc2abf989935ddbfe, 0x6acff893d00ea436},
858  {0xf356f7ebf83552fe, 0x0583f6b8c4124d44},
859  {0x98165af37b2153de, 0xc3727a337a8b704b},
860  {0xbe1bf1b059e9a8d6, 0x744f18c0592e4c5d},
861  {0xeda2ee1c7064130c, 0x1162def06f79df74},
862  {0x9485d4d1c63e8be7, 0x8addcb5645ac2ba9},
863  {0xb9a74a0637ce2ee1, 0x6d953e2bd7173693},
864  {0xe8111c87c5c1ba99, 0xc8fa8db6ccdd0438},
865  {0x910ab1d4db9914a0, 0x1d9c9892400a22a3},
866  {0xb54d5e4a127f59c8, 0x2503beb6d00cab4c},
867  {0xe2a0b5dc971f303a, 0x2e44ae64840fd61e},
868  {0x8da471a9de737e24, 0x5ceaecfed289e5d3},
869  {0xb10d8e1456105dad, 0x7425a83e872c5f48},
870  {0xdd50f1996b947518, 0xd12f124e28f7771a},
871  {0x8a5296ffe33cc92f, 0x82bd6b70d99aaa70},
872  {0xace73cbfdc0bfb7b, 0x636cc64d1001550c},
873  {0xd8210befd30efa5a, 0x3c47f7e05401aa4f},
874  {0x8714a775e3e95c78, 0x65acfaec34810a72},
875  {0xa8d9d1535ce3b396, 0x7f1839a741a14d0e},
876  {0xd31045a8341ca07c, 0x1ede48111209a051},
877  {0x83ea2b892091e44d, 0x934aed0aab460433},
878  {0xa4e4b66b68b65d60, 0xf81da84d56178540},
879  {0xce1de40642e3f4b9, 0x36251260ab9d668f},
880  {0x80d2ae83e9ce78f3, 0xc1d72b7c6b42601a},
881  {0xa1075a24e4421730, 0xb24cf65b8612f820},
882  {0xc94930ae1d529cfc, 0xdee033f26797b628},
883  {0xfb9b7cd9a4a7443c, 0x169840ef017da3b2},
884  {0x9d412e0806e88aa5, 0x8e1f289560ee864f},
885  {0xc491798a08a2ad4e, 0xf1a6f2bab92a27e3},
886  {0xf5b5d7ec8acb58a2, 0xae10af696774b1dc},
887  {0x9991a6f3d6bf1765, 0xacca6da1e0a8ef2a},
888  {0xbff610b0cc6edd3f, 0x17fd090a58d32af4},
889  {0xeff394dcff8a948e, 0xddfc4b4cef07f5b1},
890  {0x95f83d0a1fb69cd9, 0x4abdaf101564f98f},
891  {0xbb764c4ca7a4440f, 0x9d6d1ad41abe37f2},
892  {0xea53df5fd18d5513, 0x84c86189216dc5ee},
893  {0x92746b9be2f8552c, 0x32fd3cf5b4e49bb5},
894  {0xb7118682dbb66a77, 0x3fbc8c33221dc2a2},
895  {0xe4d5e82392a40515, 0x0fabaf3feaa5334b},
896  {0x8f05b1163ba6832d, 0x29cb4d87f2a7400f},
897  {0xb2c71d5bca9023f8, 0x743e20e9ef511013},
898  {0xdf78e4b2bd342cf6, 0x914da9246b255417},
899  {0x8bab8eefb6409c1a, 0x1ad089b6c2f7548f},
900  {0xae9672aba3d0c320, 0xa184ac2473b529b2},
901  {0xda3c0f568cc4f3e8, 0xc9e5d72d90a2741f},
902  {0x8865899617fb1871, 0x7e2fa67c7a658893},
903  {0xaa7eebfb9df9de8d, 0xddbb901b98feeab8},
904  {0xd51ea6fa85785631, 0x552a74227f3ea566},
905  {0x8533285c936b35de, 0xd53a88958f872760},
906  {0xa67ff273b8460356, 0x8a892abaf368f138},
907  {0xd01fef10a657842c, 0x2d2b7569b0432d86},
908  {0x8213f56a67f6b29b, 0x9c3b29620e29fc74},
909  {0xa298f2c501f45f42, 0x8349f3ba91b47b90},
910  {0xcb3f2f7642717713, 0x241c70a936219a74},
911  {0xfe0efb53d30dd4d7, 0xed238cd383aa0111},
912  {0x9ec95d1463e8a506, 0xf4363804324a40ab},
913  {0xc67bb4597ce2ce48, 0xb143c6053edcd0d6},
914  {0xf81aa16fdc1b81da, 0xdd94b7868e94050b},
915  {0x9b10a4e5e9913128, 0xca7cf2b4191c8327},
916  {0xc1d4ce1f63f57d72, 0xfd1c2f611f63a3f1},
917  {0xf24a01a73cf2dccf, 0xbc633b39673c8ced},
918  {0x976e41088617ca01, 0xd5be0503e085d814},
919  {0xbd49d14aa79dbc82, 0x4b2d8644d8a74e19},
920  {0xec9c459d51852ba2, 0xddf8e7d60ed1219f},
921  {0x93e1ab8252f33b45, 0xcabb90e5c942b504},
922  {0xb8da1662e7b00a17, 0x3d6a751f3b936244},
923  {0xe7109bfba19c0c9d, 0x0cc512670a783ad5},
924  {0x906a617d450187e2, 0x27fb2b80668b24c6},
925  {0xb484f9dc9641e9da, 0xb1f9f660802dedf7},
926  {0xe1a63853bbd26451, 0x5e7873f8a0396974},
927  {0x8d07e33455637eb2, 0xdb0b487b6423e1e9},
928  {0xb049dc016abc5e5f, 0x91ce1a9a3d2cda63},
929  {0xdc5c5301c56b75f7, 0x7641a140cc7810fc},
930  {0x89b9b3e11b6329ba, 0xa9e904c87fcb0a9e},
931  {0xac2820d9623bf429, 0x546345fa9fbdcd45},
932  {0xd732290fbacaf133, 0xa97c177947ad4096},
933  {0x867f59a9d4bed6c0, 0x49ed8eabcccc485e},
934  {0xa81f301449ee8c70, 0x5c68f256bfff5a75},
935  {0xd226fc195c6a2f8c, 0x73832eec6fff3112},
936  {0x83585d8fd9c25db7, 0xc831fd53c5ff7eac},
937  {0xa42e74f3d032f525, 0xba3e7ca8b77f5e56},
938  {0xcd3a1230c43fb26f, 0x28ce1bd2e55f35ec},
939  {0x80444b5e7aa7cf85, 0x7980d163cf5b81b4},
940  {0xa0555e361951c366, 0xd7e105bcc3326220},
941  {0xc86ab5c39fa63440, 0x8dd9472bf3fefaa8},
942  {0xfa856334878fc150, 0xb14f98f6f0feb952},
943  {0x9c935e00d4b9d8d2, 0x6ed1bf9a569f33d4},
944  {0xc3b8358109e84f07, 0x0a862f80ec4700c9},
945  {0xf4a642e14c6262c8, 0xcd27bb612758c0fb},
946  {0x98e7e9cccfbd7dbd, 0x8038d51cb897789d},
947  {0xbf21e44003acdd2c, 0xe0470a63e6bd56c4},
948  {0xeeea5d5004981478, 0x1858ccfce06cac75},
949  {0x95527a5202df0ccb, 0x0f37801e0c43ebc9},
950  {0xbaa718e68396cffd, 0xd30560258f54e6bb},
951  {0xe950df20247c83fd, 0x47c6b82ef32a206a},
952  {0x91d28b7416cdd27e, 0x4cdc331d57fa5442},
953  {0xb6472e511c81471d, 0xe0133fe4adf8e953},
954  {0xe3d8f9e563a198e5, 0x58180fddd97723a7},
955  {0x8e679c2f5e44ff8f, 0x570f09eaa7ea7649},
956  {0xb201833b35d63f73, 0x2cd2cc6551e513db},
957  {0xde81e40a034bcf4f, 0xf8077f7ea65e58d2},
958  {0x8b112e86420f6191, 0xfb04afaf27faf783},
959  {0xadd57a27d29339f6, 0x79c5db9af1f9b564},
960  {0xd94ad8b1c7380874, 0x18375281ae7822bd},
961  {0x87cec76f1c830548, 0x8f2293910d0b15b6},
962  {0xa9c2794ae3a3c69a, 0xb2eb3875504ddb23},
963  {0xd433179d9c8cb841, 0x5fa60692a46151ec},
964  {0x849feec281d7f328, 0xdbc7c41ba6bcd334},
965  {0xa5c7ea73224deff3, 0x12b9b522906c0801},
966  {0xcf39e50feae16bef, 0xd768226b34870a01},
967  {0x81842f29f2cce375, 0xe6a1158300d46641},
968  {0xa1e53af46f801c53, 0x60495ae3c1097fd1},
969  {0xca5e89b18b602368, 0x385bb19cb14bdfc5},
970  {0xfcf62c1dee382c42, 0x46729e03dd9ed7b6},
971  {0x9e19db92b4e31ba9, 0x6c07a2c26a8346d2},
972  {0xc5a05277621be293, 0xc7098b7305241886},
973  {0xf70867153aa2db38, 0xb8cbee4fc66d1ea8},
974  {0x9a65406d44a5c903, 0x737f74f1dc043329},
975  {0xc0fe908895cf3b44, 0x505f522e53053ff3},
976  {0xf13e34aabb430a15, 0x647726b9e7c68ff0},
977  {0x96c6e0eab509e64d, 0x5eca783430dc19f6},
978  {0xbc789925624c5fe0, 0xb67d16413d132073},
979  {0xeb96bf6ebadf77d8, 0xe41c5bd18c57e890},
980  {0x933e37a534cbaae7, 0x8e91b962f7b6f15a},
981  {0xb80dc58e81fe95a1, 0x723627bbb5a4adb1},
982  {0xe61136f2227e3b09, 0xcec3b1aaa30dd91d},
983  {0x8fcac257558ee4e6, 0x213a4f0aa5e8a7b2},
984  {0xb3bd72ed2af29e1f, 0xa988e2cd4f62d19e},
985  {0xe0accfa875af45a7, 0x93eb1b80a33b8606},
986  {0x8c6c01c9498d8b88, 0xbc72f130660533c4},
987  {0xaf87023b9bf0ee6a, 0xeb8fad7c7f8680b5},
988  { 0xdb68c2ca82ed2a05,
989  0xa67398db9f6820e2 }
990 #else
991  {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
992  {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
993  {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},
994  {0x86a8d39ef77164bc, 0xae5dff9c02033198},
995  {0xd98ddaee19068c76, 0x3badd624dd9b0958},
996  {0xafbd2350644eeacf, 0xe5d1929ef90898fb},
997  {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},
998  {0xe55990879ddcaabd, 0xcc420a6a101d0516},
999  {0xb94470938fa89bce, 0xf808e40e8d5b3e6a},
1000  {0x95a8637627989aad, 0xdde7001379a44aa9},
1001  {0xf1c90080baf72cb1, 0x5324c68b12dd6339},
1002  {0xc350000000000000, 0x0000000000000000},
1003  {0x9dc5ada82b70b59d, 0xf020000000000000},
1004  {0xfee50b7025c36a08, 0x02f236d04753d5b5},
1005  {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87},
1006  {0xa6539930bf6bff45, 0x84db8346b786151d},
1007  {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3},
1008  {0xd910f7ff28069da4, 0x1b2ba1518094da05},
1009  {0xaf58416654a6babb, 0x387ac8d1970027b3},
1010  {0x8da471a9de737e24, 0x5ceaecfed289e5d3},
1011  {0xe4d5e82392a40515, 0x0fabaf3feaa5334b},
1012  {0xb8da1662e7b00a17, 0x3d6a751f3b936244},
1013  {0x95527a5202df0ccb, 0x0f37801e0c43ebc9},
1014  {0xf13e34aabb430a15, 0x647726b9e7c68ff0}
1015 #endif
1016  };
1017 
1018 #if FMT_USE_FULL_CACHE_DRAGONBOX
1019  return pow10_significands[k - float_info<double>::min_k];
1020 #else
1021  static constexpr const uint64_t powers_of_5_64[] = {
1022  0x0000000000000001, 0x0000000000000005, 0x0000000000000019,
1023  0x000000000000007d, 0x0000000000000271, 0x0000000000000c35,
1024  0x0000000000003d09, 0x000000000001312d, 0x000000000005f5e1,
1025  0x00000000001dcd65, 0x00000000009502f9, 0x0000000002e90edd,
1026  0x000000000e8d4a51, 0x0000000048c27395, 0x000000016bcc41e9,
1027  0x000000071afd498d, 0x0000002386f26fc1, 0x000000b1a2bc2ec5,
1028  0x000003782dace9d9, 0x00001158e460913d, 0x000056bc75e2d631,
1029  0x0001b1ae4d6e2ef5, 0x000878678326eac9, 0x002a5a058fc295ed,
1030  0x00d3c21bcecceda1, 0x0422ca8b0a00a425, 0x14adf4b7320334b9};
1031 
1032  static const int compression_ratio = 27;
1033 
1034  // Compute base index.
1035  int cache_index = (k - float_info<double>::min_k) / compression_ratio;
1036  int kb = cache_index * compression_ratio + float_info<double>::min_k;
1037  int offset = k - kb;
1038 
1039  // Get base cache.
1040  uint128_fallback base_cache = pow10_significands[cache_index];
1041  if (offset == 0) return base_cache;
1042 
1043  // Compute the required amount of bit-shift.
1044  int alpha = floor_log2_pow10(kb + offset) - floor_log2_pow10(kb) - offset;
1045  FMT_ASSERT(alpha > 0 && alpha < 64, "shifting error detected");
1046 
1047  // Try to recover the real cache.
1048  uint64_t pow5 = powers_of_5_64[offset];
1049  uint128_fallback recovered_cache = umul128(base_cache.high(), pow5);
1050  uint128_fallback middle_low = umul128(base_cache.low(), pow5);
1051 
1052  recovered_cache += middle_low.high();
1053 
1054  uint64_t high_to_middle = recovered_cache.high() << (64 - alpha);
1055  uint64_t middle_to_low = recovered_cache.low() << (64 - alpha);
1056 
1057  recovered_cache =
1058  uint128_fallback{(recovered_cache.low() >> alpha) | high_to_middle,
1059  ((middle_low.low() >> alpha) | middle_to_low)};
1060  FMT_ASSERT(recovered_cache.low() + 1 != 0, "");
1061  return {recovered_cache.high(), recovered_cache.low() + 1};
1062 #endif
1063  }
1064 
1065  struct compute_mul_result {
1068  };
1069  struct compute_mul_parity_result {
1070  bool parity;
1072  };
1073 
1074  static compute_mul_result compute_mul(
1075  carrier_uint u, const cache_entry_type& cache) noexcept {
1076  auto r = umul192_upper128(u, cache);
1077  return {r.high(), r.low() == 0};
1078  }
1079 
1080  static uint32_t compute_delta(cache_entry_type const& cache,
1081  int beta) noexcept {
1082  return static_cast<uint32_t>(cache.high() >> (64 - 1 - beta));
1083  }
1084 
1085  static compute_mul_parity_result compute_mul_parity(
1086  carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept {
1087  FMT_ASSERT(beta >= 1, "");
1088  FMT_ASSERT(beta < 64, "");
1089 
1090  auto r = umul192_lower128(two_f, cache);
1091  return {((r.high() >> (64 - beta)) & 1) != 0,
1092  ((r.high() << beta) | (r.low() >> (64 - beta))) == 0};
1093  }
1094 
1096  const cache_entry_type& cache, int beta) noexcept {
1097  return (cache.high() -
1098  (cache.high() >> (num_significand_bits<double>() + 2))) >>
1099  (64 - num_significand_bits<double>() - 1 - beta);
1100  }
1101 
1103  const cache_entry_type& cache, int beta) noexcept {
1104  return (cache.high() +
1105  (cache.high() >> (num_significand_bits<double>() + 1))) >>
1106  (64 - num_significand_bits<double>() - 1 - beta);
1107  }
1108 
1110  const cache_entry_type& cache, int beta) noexcept {
1111  return ((cache.high() >> (64 - num_significand_bits<double>() - 2 - beta)) +
1112  1) /
1113  2;
1114  }
1115 };
1116 
1117 FMT_FUNC uint128_fallback get_cached_power(int k) noexcept {
1119 }
1120 
1121 // Various integer checks
1122 template <typename T>
1123 bool is_left_endpoint_integer_shorter_interval(int exponent) noexcept {
1124  const int case_shorter_interval_left_endpoint_lower_threshold = 2;
1125  const int case_shorter_interval_left_endpoint_upper_threshold = 3;
1126  return exponent >= case_shorter_interval_left_endpoint_lower_threshold &&
1127  exponent <= case_shorter_interval_left_endpoint_upper_threshold;
1128 }
1129 
1130 // Remove trailing zeros from n and return the number of zeros removed (float)
1131 FMT_INLINE int remove_trailing_zeros(uint32_t& n) noexcept {
1132  FMT_ASSERT(n != 0, "");
1133  // Modular inverse of 5 (mod 2^32): (mod_inv_5 * 5) mod 2^32 = 1.
1134  // See https://github.com/fmtlib/fmt/issues/3163 for more details.
1135  const uint32_t mod_inv_5 = 0xcccccccd;
1136  // Casts are needed to workaround a bug in MSVC 19.22 and older.
1137  const uint32_t mod_inv_25 =
1138  static_cast<uint32_t>(uint64_t(mod_inv_5) * mod_inv_5);
1139 
1140  int s = 0;
1141  while (true) {
1142  auto q = rotr(n * mod_inv_25, 2);
1143  if (q > max_value<uint32_t>() / 100) break;
1144  n = q;
1145  s += 2;
1146  }
1147  auto q = rotr(n * mod_inv_5, 1);
1148  if (q <= max_value<uint32_t>() / 10) {
1149  n = q;
1150  s |= 1;
1151  }
1152  return s;
1153 }
1154 
1155 // Removes trailing zeros and returns the number of zeros removed (double)
1156 FMT_INLINE int remove_trailing_zeros(uint64_t& n) noexcept {
1157  FMT_ASSERT(n != 0, "");
1158 
1159  // This magic number is ceil(2^90 / 10^8).
1160  constexpr uint64_t magic_number = 12379400392853802749ull;
1161  auto nm = umul128(n, magic_number);
1162 
1163  // Is n is divisible by 10^8?
1164  if ((nm.high() & ((1ull << (90 - 64)) - 1)) == 0 && nm.low() < magic_number) {
1165  // If yes, work with the quotient.
1166  auto n32 = static_cast<uint32_t>(nm.high() >> (90 - 64));
1167 
1168  const uint32_t mod_inv_5 = 0xcccccccd;
1169  const uint32_t mod_inv_25 = mod_inv_5 * mod_inv_5;
1170 
1171  int s = 8;
1172  while (true) {
1173  auto q = rotr(n32 * mod_inv_25, 2);
1174  if (q > max_value<uint32_t>() / 100) break;
1175  n32 = q;
1176  s += 2;
1177  }
1178  auto q = rotr(n32 * mod_inv_5, 1);
1179  if (q <= max_value<uint32_t>() / 10) {
1180  n32 = q;
1181  s |= 1;
1182  }
1183 
1184  n = n32;
1185  return s;
1186  }
1187 
1188  // If n is not divisible by 10^8, work with n itself.
1189  const uint64_t mod_inv_5 = 0xcccccccccccccccd;
1190  const uint64_t mod_inv_25 = mod_inv_5 * mod_inv_5;
1191 
1192  int s = 0;
1193  while (true) {
1194  auto q = rotr(n * mod_inv_25, 2);
1195  if (q > max_value<uint64_t>() / 100) break;
1196  n = q;
1197  s += 2;
1198  }
1199  auto q = rotr(n * mod_inv_5, 1);
1200  if (q <= max_value<uint64_t>() / 10) {
1201  n = q;
1202  s |= 1;
1203  }
1204 
1205  return s;
1206 }
1207 
1208 // The main algorithm for shorter interval case
1209 template <typename T>
1210 FMT_INLINE decimal_fp<T> shorter_interval_case(int exponent) noexcept {
1211  decimal_fp<T> ret_value;
1212  // Compute k and beta
1213  const int minus_k = floor_log10_pow2_minus_log10_4_over_3(exponent);
1214  const int beta = exponent + floor_log2_pow10(-minus_k);
1215 
1216  // Compute xi and zi
1217  using cache_entry_type = typename cache_accessor<T>::cache_entry_type;
1218  const cache_entry_type cache = cache_accessor<T>::get_cached_power(-minus_k);
1219 
1221  cache, beta);
1223  cache, beta);
1224 
1225  // If the left endpoint is not an integer, increase it
1226  if (!is_left_endpoint_integer_shorter_interval<T>(exponent)) ++xi;
1227 
1228  // Try bigger divisor
1229  ret_value.significand = zi / 10;
1230 
1231  // If succeed, remove trailing zeros if necessary and return
1232  if (ret_value.significand * 10 >= xi) {
1233  ret_value.exponent = minus_k + 1;
1234  ret_value.exponent += remove_trailing_zeros(ret_value.significand);
1235  return ret_value;
1236  }
1237 
1238  // Otherwise, compute the round-up of y
1239  ret_value.significand =
1241  beta);
1242  ret_value.exponent = minus_k;
1243 
1244  // When tie occurs, choose one of them according to the rule
1245  if (exponent >= float_info<T>::shorter_interval_tie_lower_threshold &&
1246  exponent <= float_info<T>::shorter_interval_tie_upper_threshold) {
1247  ret_value.significand = ret_value.significand % 2 == 0
1248  ? ret_value.significand
1249  : ret_value.significand - 1;
1250  } else if (ret_value.significand < xi) {
1251  ++ret_value.significand;
1252  }
1253  return ret_value;
1254 }
1255 
1256 template <typename T> decimal_fp<T> to_decimal(T x) noexcept {
1257  // Step 1: integer promotion & Schubfach multiplier calculation.
1258 
1259  using carrier_uint = typename float_info<T>::carrier_uint;
1260  using cache_entry_type = typename cache_accessor<T>::cache_entry_type;
1261  auto br = bit_cast<carrier_uint>(x);
1262 
1263  // Extract significand bits and exponent bits.
1264  const carrier_uint significand_mask =
1265  (static_cast<carrier_uint>(1) << num_significand_bits<T>()) - 1;
1266  carrier_uint significand = (br & significand_mask);
1267  int exponent =
1268  static_cast<int>((br & exponent_mask<T>()) >> num_significand_bits<T>());
1269 
1270  if (exponent != 0) { // Check if normal.
1271  exponent -= exponent_bias<T>() + num_significand_bits<T>();
1272 
1273  // Shorter interval case; proceed like Schubfach.
1274  // In fact, when exponent == 1 and significand == 0, the interval is
1275  // regular. However, it can be shown that the end-results are anyway same.
1276  if (significand == 0) return shorter_interval_case<T>(exponent);
1277 
1278  significand |= (static_cast<carrier_uint>(1) << num_significand_bits<T>());
1279  } else {
1280  // Subnormal case; the interval is always regular.
1281  if (significand == 0) return {0, 0};
1282  exponent =
1283  std::numeric_limits<T>::min_exponent - num_significand_bits<T>() - 1;
1284  }
1285 
1286  const bool include_left_endpoint = (significand % 2 == 0);
1287  const bool include_right_endpoint = include_left_endpoint;
1288 
1289  // Compute k and beta.
1290  const int minus_k = floor_log10_pow2(exponent) - float_info<T>::kappa;
1291  const cache_entry_type cache = cache_accessor<T>::get_cached_power(-minus_k);
1292  const int beta = exponent + floor_log2_pow10(-minus_k);
1293 
1294  // Compute zi and deltai.
1295  // 10^kappa <= deltai < 10^(kappa + 1)
1296  const uint32_t deltai = cache_accessor<T>::compute_delta(cache, beta);
1297  const carrier_uint two_fc = significand << 1;
1298 
1299  // For the case of binary32, the result of integer check is not correct for
1300  // 29711844 * 2^-82
1301  // = 6.1442653300000000008655037797566933477355632930994033813476... * 10^-18
1302  // and 29711844 * 2^-81
1303  // = 1.2288530660000000001731007559513386695471126586198806762695... * 10^-17,
1304  // and they are the unique counterexamples. However, since 29711844 is even,
1305  // this does not cause any problem for the endpoints calculations; it can only
1306  // cause a problem when we need to perform integer check for the center.
1307  // Fortunately, with these inputs, that branch is never executed, so we are
1308  // fine.
1309  const typename cache_accessor<T>::compute_mul_result z_mul =
1310  cache_accessor<T>::compute_mul((two_fc | 1) << beta, cache);
1311 
1312  // Step 2: Try larger divisor; remove trailing zeros if necessary.
1313 
1314  // Using an upper bound on zi, we might be able to optimize the division
1315  // better than the compiler; we are computing zi / big_divisor here.
1316  decimal_fp<T> ret_value;
1317  ret_value.significand = divide_by_10_to_kappa_plus_1(z_mul.result);
1318  uint32_t r = static_cast<uint32_t>(z_mul.result - float_info<T>::big_divisor *
1319  ret_value.significand);
1320 
1321  if (r < deltai) {
1322  // Exclude the right endpoint if necessary.
1323  if (r == 0 && (z_mul.is_integer & !include_right_endpoint)) {
1324  --ret_value.significand;
1326  goto small_divisor_case_label;
1327  }
1328  } else if (r > deltai) {
1329  goto small_divisor_case_label;
1330  } else {
1331  // r == deltai; compare fractional parts.
1332  const typename cache_accessor<T>::compute_mul_parity_result x_mul =
1333  cache_accessor<T>::compute_mul_parity(two_fc - 1, cache, beta);
1334 
1335  if (!(x_mul.parity | (x_mul.is_integer & include_left_endpoint)))
1336  goto small_divisor_case_label;
1337  }
1338  ret_value.exponent = minus_k + float_info<T>::kappa + 1;
1339 
1340  // We may need to remove trailing zeros.
1341  ret_value.exponent += remove_trailing_zeros(ret_value.significand);
1342  return ret_value;
1343 
1344  // Step 3: Find the significand with the smaller divisor.
1345 
1346 small_divisor_case_label:
1347  ret_value.significand *= 10;
1348  ret_value.exponent = minus_k + float_info<T>::kappa;
1349 
1350  uint32_t dist = r - (deltai / 2) + (float_info<T>::small_divisor / 2);
1351  const bool approx_y_parity =
1352  ((dist ^ (float_info<T>::small_divisor / 2)) & 1) != 0;
1353 
1354  // Is dist divisible by 10^kappa?
1355  const bool divisible_by_small_divisor =
1356  check_divisibility_and_divide_by_pow10<float_info<T>::kappa>(dist);
1357 
1358  // Add dist / 10^kappa to the significand.
1359  ret_value.significand += dist;
1360 
1361  if (!divisible_by_small_divisor) return ret_value;
1362 
1363  // Check z^(f) >= epsilon^(f).
1364  // We have either yi == zi - epsiloni or yi == (zi - epsiloni) - 1,
1365  // where yi == zi - epsiloni if and only if z^(f) >= epsilon^(f).
1366  // Since there are only 2 possibilities, we only need to care about the
1367  // parity. Also, zi and r should have the same parity since the divisor
1368  // is an even number.
1369  const auto y_mul = cache_accessor<T>::compute_mul_parity(two_fc, cache, beta);
1370 
1371  // If z^(f) >= epsilon^(f), we might have a tie when z^(f) == epsilon^(f),
1372  // or equivalently, when y is an integer.
1373  if (y_mul.parity != approx_y_parity)
1374  --ret_value.significand;
1375  else if (y_mul.is_integer & (ret_value.significand % 2 != 0))
1376  --ret_value.significand;
1377  return ret_value;
1378 }
1379 } // namespace dragonbox
1380 } // namespace detail
1381 
1382 template <> struct formatter<detail::bigint> {
1385  return ctx.begin();
1386  }
1387 
1388  auto format(const detail::bigint& n, format_context& ctx) const
1390  auto out = ctx.out();
1391  bool first = true;
1392  for (auto i = n.bigits_.size(); i > 0; --i) {
1393  auto value = n.bigits_[i - 1u];
1394  if (first) {
1395  out = format_to(out, FMT_STRING("{:x}"), value);
1396  first = false;
1397  continue;
1398  }
1399  out = format_to(out, FMT_STRING("{:08x}"), value);
1400  }
1401  if (n.exp_ > 0)
1402  out = format_to(out, FMT_STRING("p{}"),
1403  n.exp_ * detail::bigint::bigit_bits);
1404  return out;
1405  }
1406 };
1407 
1409  for_each_codepoint(s, [this](uint32_t cp, string_view) {
1410  if (cp == invalid_code_point) FMT_THROW(std::runtime_error("invalid utf8"));
1411  if (cp <= 0xFFFF) {
1412  buffer_.push_back(static_cast<wchar_t>(cp));
1413  } else {
1414  cp -= 0x10000;
1415  buffer_.push_back(static_cast<wchar_t>(0xD800 + (cp >> 10)));
1416  buffer_.push_back(static_cast<wchar_t>(0xDC00 + (cp & 0x3FF)));
1417  }
1418  return true;
1419  });
1420  buffer_.push_back(0);
1421 }
1422 
1424  const char* message) noexcept {
1425  FMT_TRY {
1426  auto ec = std::error_code(error_code, std::generic_category());
1427  write(std::back_inserter(out), std::system_error(ec, message).what());
1428  return;
1429  }
1430  FMT_CATCH(...) {}
1431  format_error_code(out, error_code, message);
1432 }
1433 
1434 FMT_FUNC void report_system_error(int error_code,
1435  const char* message) noexcept {
1437 }
1438 
1440  // Don't optimize the "{}" case to keep the binary size small and because it
1441  // can be better optimized in fmt::format anyway.
1442  auto buffer = memory_buffer();
1443  detail::vformat_to(buffer, fmt, args);
1444  return to_string(buffer);
1445 }
1446 
1447 namespace detail {
1448 #ifndef _WIN32
1449 FMT_FUNC bool write_console(std::FILE*, string_view) { return false; }
1450 #else
1452 extern "C" __declspec(dllimport) int __stdcall WriteConsoleW( //
1453  void*, const void*, dword, dword*, void*);
1454 
1455 FMT_FUNC bool write_console(std::FILE* f, string_view text) {
1456  auto fd = _fileno(f);
1457  if (!_isatty(fd)) return false;
1458  auto u16 = utf8_to_utf16(text);
1459  auto written = dword();
1460  return WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)), u16.c_str(),
1461  static_cast<uint32_t>(u16.size()), &written, nullptr);
1462 }
1463 
1464 // Print assuming legacy (non-Unicode) encoding.
1465 FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args) {
1466  auto buffer = memory_buffer();
1469  fwrite_fully(buffer.data(), 1, buffer.size(), f);
1470 }
1471 #endif
1472 
1473 FMT_FUNC void print(std::FILE* f, string_view text) {
1474  if (!write_console(f, text)) fwrite_fully(text.data(), 1, text.size(), f);
1475 }
1476 } // namespace detail
1477 
1478 FMT_FUNC void vprint(std::FILE* f, string_view fmt, format_args args) {
1479  auto buffer = memory_buffer();
1480  detail::vformat_to(buffer, fmt, args);
1481  detail::print(f, {buffer.data(), buffer.size()});
1482 }
1483 
1485  vprint(stdout, fmt, args);
1486 }
1487 
1488 namespace detail {
1489 
1490 struct singleton {
1491  unsigned char upper;
1492  unsigned char lower_count;
1493 };
1494 
1495 inline auto is_printable(uint16_t x, const singleton* singletons,
1496  size_t singletons_size,
1497  const unsigned char* singleton_lowers,
1498  const unsigned char* normal, size_t normal_size)
1499  -> bool {
1500  auto upper = x >> 8;
1501  auto lower_start = 0;
1502  for (size_t i = 0; i < singletons_size; ++i) {
1503  auto s = singletons[i];
1504  auto lower_end = lower_start + s.lower_count;
1505  if (upper < s.upper) break;
1506  if (upper == s.upper) {
1507  for (auto j = lower_start; j < lower_end; ++j) {
1508  if (singleton_lowers[j] == (x & 0xff)) return false;
1509  }
1510  }
1511  lower_start = lower_end;
1512  }
1513 
1514  auto xsigned = static_cast<int>(x);
1515  auto current = true;
1516  for (size_t i = 0; i < normal_size; ++i) {
1517  auto v = static_cast<int>(normal[i]);
1518  auto len = (v & 0x80) != 0 ? (v & 0x7f) << 8 | normal[++i] : v;
1519  xsigned -= len;
1520  if (xsigned < 0) break;
1521  current = !current;
1522  }
1523  return current;
1524 }
1525 
1526 // This code is generated by support/printable.py.
1527 FMT_FUNC auto is_printable(uint32_t cp) -> bool {
1528  static constexpr singleton singletons0[] = {
1529  {0x00, 1}, {0x03, 5}, {0x05, 6}, {0x06, 3}, {0x07, 6}, {0x08, 8},
1530  {0x09, 17}, {0x0a, 28}, {0x0b, 25}, {0x0c, 20}, {0x0d, 16}, {0x0e, 13},
1531  {0x0f, 4}, {0x10, 3}, {0x12, 18}, {0x13, 9}, {0x16, 1}, {0x17, 5},
1532  {0x18, 2}, {0x19, 3}, {0x1a, 7}, {0x1c, 2}, {0x1d, 1}, {0x1f, 22},
1533  {0x20, 3}, {0x2b, 3}, {0x2c, 2}, {0x2d, 11}, {0x2e, 1}, {0x30, 3},
1534  {0x31, 2}, {0x32, 1}, {0xa7, 2}, {0xa9, 2}, {0xaa, 4}, {0xab, 8},
1535  {0xfa, 2}, {0xfb, 5}, {0xfd, 4}, {0xfe, 3}, {0xff, 9},
1536  };
1537  static constexpr unsigned char singletons0_lower[] = {
1538  0xad, 0x78, 0x79, 0x8b, 0x8d, 0xa2, 0x30, 0x57, 0x58, 0x8b, 0x8c, 0x90,
1539  0x1c, 0x1d, 0xdd, 0x0e, 0x0f, 0x4b, 0x4c, 0xfb, 0xfc, 0x2e, 0x2f, 0x3f,
1540  0x5c, 0x5d, 0x5f, 0xb5, 0xe2, 0x84, 0x8d, 0x8e, 0x91, 0x92, 0xa9, 0xb1,
1541  0xba, 0xbb, 0xc5, 0xc6, 0xc9, 0xca, 0xde, 0xe4, 0xe5, 0xff, 0x00, 0x04,
1542  0x11, 0x12, 0x29, 0x31, 0x34, 0x37, 0x3a, 0x3b, 0x3d, 0x49, 0x4a, 0x5d,
1543  0x84, 0x8e, 0x92, 0xa9, 0xb1, 0xb4, 0xba, 0xbb, 0xc6, 0xca, 0xce, 0xcf,
1544  0xe4, 0xe5, 0x00, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a,
1545  0x3b, 0x45, 0x46, 0x49, 0x4a, 0x5e, 0x64, 0x65, 0x84, 0x91, 0x9b, 0x9d,
1546  0xc9, 0xce, 0xcf, 0x0d, 0x11, 0x29, 0x45, 0x49, 0x57, 0x64, 0x65, 0x8d,
1547  0x91, 0xa9, 0xb4, 0xba, 0xbb, 0xc5, 0xc9, 0xdf, 0xe4, 0xe5, 0xf0, 0x0d,
1548  0x11, 0x45, 0x49, 0x64, 0x65, 0x80, 0x84, 0xb2, 0xbc, 0xbe, 0xbf, 0xd5,
1549  0xd7, 0xf0, 0xf1, 0x83, 0x85, 0x8b, 0xa4, 0xa6, 0xbe, 0xbf, 0xc5, 0xc7,
1550  0xce, 0xcf, 0xda, 0xdb, 0x48, 0x98, 0xbd, 0xcd, 0xc6, 0xce, 0xcf, 0x49,
1551  0x4e, 0x4f, 0x57, 0x59, 0x5e, 0x5f, 0x89, 0x8e, 0x8f, 0xb1, 0xb6, 0xb7,
1552  0xbf, 0xc1, 0xc6, 0xc7, 0xd7, 0x11, 0x16, 0x17, 0x5b, 0x5c, 0xf6, 0xf7,
1553  0xfe, 0xff, 0x80, 0x0d, 0x6d, 0x71, 0xde, 0xdf, 0x0e, 0x0f, 0x1f, 0x6e,
1554  0x6f, 0x1c, 0x1d, 0x5f, 0x7d, 0x7e, 0xae, 0xaf, 0xbb, 0xbc, 0xfa, 0x16,
1555  0x17, 0x1e, 0x1f, 0x46, 0x47, 0x4e, 0x4f, 0x58, 0x5a, 0x5c, 0x5e, 0x7e,
1556  0x7f, 0xb5, 0xc5, 0xd4, 0xd5, 0xdc, 0xf0, 0xf1, 0xf5, 0x72, 0x73, 0x8f,
1557  0x74, 0x75, 0x96, 0x2f, 0x5f, 0x26, 0x2e, 0x2f, 0xa7, 0xaf, 0xb7, 0xbf,
1558  0xc7, 0xcf, 0xd7, 0xdf, 0x9a, 0x40, 0x97, 0x98, 0x30, 0x8f, 0x1f, 0xc0,
1559  0xc1, 0xce, 0xff, 0x4e, 0x4f, 0x5a, 0x5b, 0x07, 0x08, 0x0f, 0x10, 0x27,
1560  0x2f, 0xee, 0xef, 0x6e, 0x6f, 0x37, 0x3d, 0x3f, 0x42, 0x45, 0x90, 0x91,
1561  0xfe, 0xff, 0x53, 0x67, 0x75, 0xc8, 0xc9, 0xd0, 0xd1, 0xd8, 0xd9, 0xe7,
1562  0xfe, 0xff,
1563  };
1564  static constexpr singleton singletons1[] = {
1565  {0x00, 6}, {0x01, 1}, {0x03, 1}, {0x04, 2}, {0x08, 8}, {0x09, 2},
1566  {0x0a, 5}, {0x0b, 2}, {0x0e, 4}, {0x10, 1}, {0x11, 2}, {0x12, 5},
1567  {0x13, 17}, {0x14, 1}, {0x15, 2}, {0x17, 2}, {0x19, 13}, {0x1c, 5},
1568  {0x1d, 8}, {0x24, 1}, {0x6a, 3}, {0x6b, 2}, {0xbc, 2}, {0xd1, 2},
1569  {0xd4, 12}, {0xd5, 9}, {0xd6, 2}, {0xd7, 2}, {0xda, 1}, {0xe0, 5},
1570  {0xe1, 2}, {0xe8, 2}, {0xee, 32}, {0xf0, 4}, {0xf8, 2}, {0xf9, 2},
1571  {0xfa, 2}, {0xfb, 1},
1572  };
1573  static constexpr unsigned char singletons1_lower[] = {
1574  0x0c, 0x27, 0x3b, 0x3e, 0x4e, 0x4f, 0x8f, 0x9e, 0x9e, 0x9f, 0x06, 0x07,
1575  0x09, 0x36, 0x3d, 0x3e, 0x56, 0xf3, 0xd0, 0xd1, 0x04, 0x14, 0x18, 0x36,
1576  0x37, 0x56, 0x57, 0x7f, 0xaa, 0xae, 0xaf, 0xbd, 0x35, 0xe0, 0x12, 0x87,
1577  0x89, 0x8e, 0x9e, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a,
1578  0x45, 0x46, 0x49, 0x4a, 0x4e, 0x4f, 0x64, 0x65, 0x5c, 0xb6, 0xb7, 0x1b,
1579  0x1c, 0x07, 0x08, 0x0a, 0x0b, 0x14, 0x17, 0x36, 0x39, 0x3a, 0xa8, 0xa9,
1580  0xd8, 0xd9, 0x09, 0x37, 0x90, 0x91, 0xa8, 0x07, 0x0a, 0x3b, 0x3e, 0x66,
1581  0x69, 0x8f, 0x92, 0x6f, 0x5f, 0xee, 0xef, 0x5a, 0x62, 0x9a, 0x9b, 0x27,
1582  0x28, 0x55, 0x9d, 0xa0, 0xa1, 0xa3, 0xa4, 0xa7, 0xa8, 0xad, 0xba, 0xbc,
1583  0xc4, 0x06, 0x0b, 0x0c, 0x15, 0x1d, 0x3a, 0x3f, 0x45, 0x51, 0xa6, 0xa7,
1584  0xcc, 0xcd, 0xa0, 0x07, 0x19, 0x1a, 0x22, 0x25, 0x3e, 0x3f, 0xc5, 0xc6,
1585  0x04, 0x20, 0x23, 0x25, 0x26, 0x28, 0x33, 0x38, 0x3a, 0x48, 0x4a, 0x4c,
1586  0x50, 0x53, 0x55, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x63, 0x65, 0x66,
1587  0x6b, 0x73, 0x78, 0x7d, 0x7f, 0x8a, 0xa4, 0xaa, 0xaf, 0xb0, 0xc0, 0xd0,
1588  0xae, 0xaf, 0x79, 0xcc, 0x6e, 0x6f, 0x93,
1589  };
1590  static constexpr unsigned char normal0[] = {
1591  0x00, 0x20, 0x5f, 0x22, 0x82, 0xdf, 0x04, 0x82, 0x44, 0x08, 0x1b, 0x04,
1592  0x06, 0x11, 0x81, 0xac, 0x0e, 0x80, 0xab, 0x35, 0x28, 0x0b, 0x80, 0xe0,
1593  0x03, 0x19, 0x08, 0x01, 0x04, 0x2f, 0x04, 0x34, 0x04, 0x07, 0x03, 0x01,
1594  0x07, 0x06, 0x07, 0x11, 0x0a, 0x50, 0x0f, 0x12, 0x07, 0x55, 0x07, 0x03,
1595  0x04, 0x1c, 0x0a, 0x09, 0x03, 0x08, 0x03, 0x07, 0x03, 0x02, 0x03, 0x03,
1596  0x03, 0x0c, 0x04, 0x05, 0x03, 0x0b, 0x06, 0x01, 0x0e, 0x15, 0x05, 0x3a,
1597  0x03, 0x11, 0x07, 0x06, 0x05, 0x10, 0x07, 0x57, 0x07, 0x02, 0x07, 0x15,
1598  0x0d, 0x50, 0x04, 0x43, 0x03, 0x2d, 0x03, 0x01, 0x04, 0x11, 0x06, 0x0f,
1599  0x0c, 0x3a, 0x04, 0x1d, 0x25, 0x5f, 0x20, 0x6d, 0x04, 0x6a, 0x25, 0x80,
1600  0xc8, 0x05, 0x82, 0xb0, 0x03, 0x1a, 0x06, 0x82, 0xfd, 0x03, 0x59, 0x07,
1601  0x15, 0x0b, 0x17, 0x09, 0x14, 0x0c, 0x14, 0x0c, 0x6a, 0x06, 0x0a, 0x06,
1602  0x1a, 0x06, 0x59, 0x07, 0x2b, 0x05, 0x46, 0x0a, 0x2c, 0x04, 0x0c, 0x04,
1603  0x01, 0x03, 0x31, 0x0b, 0x2c, 0x04, 0x1a, 0x06, 0x0b, 0x03, 0x80, 0xac,
1604  0x06, 0x0a, 0x06, 0x21, 0x3f, 0x4c, 0x04, 0x2d, 0x03, 0x74, 0x08, 0x3c,
1605  0x03, 0x0f, 0x03, 0x3c, 0x07, 0x38, 0x08, 0x2b, 0x05, 0x82, 0xff, 0x11,
1606  0x18, 0x08, 0x2f, 0x11, 0x2d, 0x03, 0x20, 0x10, 0x21, 0x0f, 0x80, 0x8c,
1607  0x04, 0x82, 0x97, 0x19, 0x0b, 0x15, 0x88, 0x94, 0x05, 0x2f, 0x05, 0x3b,
1608  0x07, 0x02, 0x0e, 0x18, 0x09, 0x80, 0xb3, 0x2d, 0x74, 0x0c, 0x80, 0xd6,
1609  0x1a, 0x0c, 0x05, 0x80, 0xff, 0x05, 0x80, 0xdf, 0x0c, 0xee, 0x0d, 0x03,
1610  0x84, 0x8d, 0x03, 0x37, 0x09, 0x81, 0x5c, 0x14, 0x80, 0xb8, 0x08, 0x80,
1611  0xcb, 0x2a, 0x38, 0x03, 0x0a, 0x06, 0x38, 0x08, 0x46, 0x08, 0x0c, 0x06,
1612  0x74, 0x0b, 0x1e, 0x03, 0x5a, 0x04, 0x59, 0x09, 0x80, 0x83, 0x18, 0x1c,
1613  0x0a, 0x16, 0x09, 0x4c, 0x04, 0x80, 0x8a, 0x06, 0xab, 0xa4, 0x0c, 0x17,
1614  0x04, 0x31, 0xa1, 0x04, 0x81, 0xda, 0x26, 0x07, 0x0c, 0x05, 0x05, 0x80,
1615  0xa5, 0x11, 0x81, 0x6d, 0x10, 0x78, 0x28, 0x2a, 0x06, 0x4c, 0x04, 0x80,
1616  0x8d, 0x04, 0x80, 0xbe, 0x03, 0x1b, 0x03, 0x0f, 0x0d,
1617  };
1618  static constexpr unsigned char normal1[] = {
1619  0x5e, 0x22, 0x7b, 0x05, 0x03, 0x04, 0x2d, 0x03, 0x66, 0x03, 0x01, 0x2f,
1620  0x2e, 0x80, 0x82, 0x1d, 0x03, 0x31, 0x0f, 0x1c, 0x04, 0x24, 0x09, 0x1e,
1621  0x05, 0x2b, 0x05, 0x44, 0x04, 0x0e, 0x2a, 0x80, 0xaa, 0x06, 0x24, 0x04,
1622  0x24, 0x04, 0x28, 0x08, 0x34, 0x0b, 0x01, 0x80, 0x90, 0x81, 0x37, 0x09,
1623  0x16, 0x0a, 0x08, 0x80, 0x98, 0x39, 0x03, 0x63, 0x08, 0x09, 0x30, 0x16,
1624  0x05, 0x21, 0x03, 0x1b, 0x05, 0x01, 0x40, 0x38, 0x04, 0x4b, 0x05, 0x2f,
1625  0x04, 0x0a, 0x07, 0x09, 0x07, 0x40, 0x20, 0x27, 0x04, 0x0c, 0x09, 0x36,
1626  0x03, 0x3a, 0x05, 0x1a, 0x07, 0x04, 0x0c, 0x07, 0x50, 0x49, 0x37, 0x33,
1627  0x0d, 0x33, 0x07, 0x2e, 0x08, 0x0a, 0x81, 0x26, 0x52, 0x4e, 0x28, 0x08,
1628  0x2a, 0x56, 0x1c, 0x14, 0x17, 0x09, 0x4e, 0x04, 0x1e, 0x0f, 0x43, 0x0e,
1629  0x19, 0x07, 0x0a, 0x06, 0x48, 0x08, 0x27, 0x09, 0x75, 0x0b, 0x3f, 0x41,
1630  0x2a, 0x06, 0x3b, 0x05, 0x0a, 0x06, 0x51, 0x06, 0x01, 0x05, 0x10, 0x03,
1631  0x05, 0x80, 0x8b, 0x62, 0x1e, 0x48, 0x08, 0x0a, 0x80, 0xa6, 0x5e, 0x22,
1632  0x45, 0x0b, 0x0a, 0x06, 0x0d, 0x13, 0x39, 0x07, 0x0a, 0x36, 0x2c, 0x04,
1633  0x10, 0x80, 0xc0, 0x3c, 0x64, 0x53, 0x0c, 0x48, 0x09, 0x0a, 0x46, 0x45,
1634  0x1b, 0x48, 0x08, 0x53, 0x1d, 0x39, 0x81, 0x07, 0x46, 0x0a, 0x1d, 0x03,
1635  0x47, 0x49, 0x37, 0x03, 0x0e, 0x08, 0x0a, 0x06, 0x39, 0x07, 0x0a, 0x81,
1636  0x36, 0x19, 0x80, 0xb7, 0x01, 0x0f, 0x32, 0x0d, 0x83, 0x9b, 0x66, 0x75,
1637  0x0b, 0x80, 0xc4, 0x8a, 0xbc, 0x84, 0x2f, 0x8f, 0xd1, 0x82, 0x47, 0xa1,
1638  0xb9, 0x82, 0x39, 0x07, 0x2a, 0x04, 0x02, 0x60, 0x26, 0x0a, 0x46, 0x0a,
1639  0x28, 0x05, 0x13, 0x82, 0xb0, 0x5b, 0x65, 0x4b, 0x04, 0x39, 0x07, 0x11,
1640  0x40, 0x05, 0x0b, 0x02, 0x0e, 0x97, 0xf8, 0x08, 0x84, 0xd6, 0x2a, 0x09,
1641  0xa2, 0xf7, 0x81, 0x1f, 0x31, 0x03, 0x11, 0x04, 0x08, 0x81, 0x8c, 0x89,
1642  0x04, 0x6b, 0x05, 0x0d, 0x03, 0x09, 0x07, 0x10, 0x93, 0x60, 0x80, 0xf6,
1643  0x0a, 0x73, 0x08, 0x6e, 0x17, 0x46, 0x80, 0x9a, 0x14, 0x0c, 0x57, 0x09,
1644  0x19, 0x80, 0x87, 0x81, 0x47, 0x03, 0x85, 0x42, 0x0f, 0x15, 0x85, 0x50,
1645  0x2b, 0x80, 0xd5, 0x2d, 0x03, 0x1a, 0x04, 0x02, 0x81, 0x70, 0x3a, 0x05,
1646  0x01, 0x85, 0x00, 0x80, 0xd7, 0x29, 0x4c, 0x04, 0x0a, 0x04, 0x02, 0x83,
1647  0x11, 0x44, 0x4c, 0x3d, 0x80, 0xc2, 0x3c, 0x06, 0x01, 0x04, 0x55, 0x05,
1648  0x1b, 0x34, 0x02, 0x81, 0x0e, 0x2c, 0x04, 0x64, 0x0c, 0x56, 0x0a, 0x80,
1649  0xae, 0x38, 0x1d, 0x0d, 0x2c, 0x04, 0x09, 0x07, 0x02, 0x0e, 0x06, 0x80,
1650  0x9a, 0x83, 0xd8, 0x08, 0x0d, 0x03, 0x0d, 0x03, 0x74, 0x0c, 0x59, 0x07,
1651  0x0c, 0x14, 0x0c, 0x04, 0x38, 0x08, 0x0a, 0x06, 0x28, 0x08, 0x22, 0x4e,
1652  0x81, 0x54, 0x0c, 0x15, 0x03, 0x03, 0x05, 0x07, 0x09, 0x19, 0x07, 0x07,
1653  0x09, 0x03, 0x0d, 0x07, 0x29, 0x80, 0xcb, 0x25, 0x0a, 0x84, 0x06,
1654  };
1655  auto lower = static_cast<uint16_t>(cp);
1656  if (cp < 0x10000) {
1657  return is_printable(lower, singletons0,
1658  sizeof(singletons0) / sizeof(*singletons0),
1659  singletons0_lower, normal0, sizeof(normal0));
1660  }
1661  if (cp < 0x20000) {
1662  return is_printable(lower, singletons1,
1663  sizeof(singletons1) / sizeof(*singletons1),
1664  singletons1_lower, normal1, sizeof(normal1));
1665  }
1666  if (0x2a6de <= cp && cp < 0x2a700) return false;
1667  if (0x2b735 <= cp && cp < 0x2b740) return false;
1668  if (0x2b81e <= cp && cp < 0x2b820) return false;
1669  if (0x2cea2 <= cp && cp < 0x2ceb0) return false;
1670  if (0x2ebe1 <= cp && cp < 0x2f800) return false;
1671  if (0x2fa1e <= cp && cp < 0x30000) return false;
1672  if (0x3134b <= cp && cp < 0xe0100) return false;
1673  if (0xe01f0 <= cp && cp < 0x110000) return false;
1674  return cp < 0x110000;
1675 }
1676 
1677 } // namespace detail
1678 
1680 
1681 #endif // FMT_FORMAT_INL_H_
GLuint GLuint stream
Definition: glcorearb.h:1832
#define FMT_STRING(s)
Definition: format.h:1993
bool operator==(basic_fp< F > x, basic_fp< F > y)
Definition: format-inl.h:155
FMT_NORETURN FMT_API void throw_format_error(const char *message)
Definition: format-inl.h:39
static compute_mul_result compute_mul(carrier_uint u, const cache_entry_type &cache) noexcept
Definition: format-inl.h:300
GLint first
Definition: glcorearb.h:405
GLuint GLsizei const GLchar * message
Definition: glcorearb.h:2543
FMT_INLINE int remove_trailing_zeros(uint32_t &n) noexcept
Definition: format-inl.h:1131
typedef int(APIENTRYP RE_PFNGLXSWAPINTERVALSGIPROC)(int)
GA_API const UT_StringHolder dist
std::string upper(string_view a)
Return an all-upper case version of a (locale-independent).
Definition: strutil.h:500
float_info< float >::carrier_uint carrier_uint
Definition: format-inl.h:255
auto to_string(const T &value) -> std::string
Definition: format.h:4527
static carrier_uint compute_round_up_for_shorter_interval_case(const cache_entry_type &cache, int beta) noexcept
Definition: format-inl.h:1109
#define FMT_CATCH(x)
Definition: format.h:132
auto format(const detail::bigint &n, format_context &ctx) const -> format_context::iterator
Definition: format-inl.h:1388
#define FMT_TRY
Definition: format.h:131
FMT_CONSTEXPR auto data() noexcept-> T *
Definition: core.h:907
format_facet(Locale &loc)
Definition: format-inl.h:133
uint32_t divisor
Definition: format-inl.h:199
static carrier_uint compute_left_endpoint_for_shorter_interval_case(const cache_entry_type &cache, int beta) noexcept
Definition: format-inl.h:322
static uint32_t compute_delta(cache_entry_type const &cache, int beta) noexcept
Definition: format-inl.h:1080
typename std::conditional< B, T, F >::type conditional_t
Definition: core.h:266
const GLdouble * v
Definition: glcorearb.h:837
virtual auto do_put(appender out, loc_value val, const format_specs<> &specs) const -> bool
static uint128_fallback get_cached_power(int k) noexcept
Definition: format-inl.h:349
GLsizei const GLfloat * value
Definition: glcorearb.h:824
FMT_INLINE decimal_fp< T > shorter_interval_case(int exponent) noexcept
Definition: format-inl.h:1210
auto system_error(int error_code, format_string< T...> fmt, T &&...args) -> std::system_error
Definition: format.h:4205
conditional_t< std::is_same< T, char >::value, appender, std::back_insert_iterator< buffer< T >>> buffer_appender
Definition: core.h:1105
int e
Definition: format.h:1653
bool is_left_endpoint_integer_shorter_interval(int exponent) noexcept
Definition: format-inl.h:1123
void vformat_to(buffer< Char > &buf, basic_string_view< Char > fmt, typename vformat_args< Char >::type args, locale_ref loc={})
GLdouble s
Definition: glad.h:3009
FMT_CONSTEXPR auto to_unsigned(Int value) -> typename std::make_unsigned< Int >::type
Definition: core.h:374
FMT_FUNC void vprint(std::FILE *f, string_view fmt, format_args args)
Definition: format-inl.h:1478
static carrier_uint compute_round_up_for_shorter_interval_case(const cache_entry_type &cache, int beta) noexcept
Definition: format-inl.h:336
unsigned char lower_count
Definition: format-inl.h:1492
uint32_t small_division_by_pow10(uint32_t n) noexcept
Definition: format-inl.h:232
auto is_printable(uint16_t x, const singleton *singletons, size_t singletons_size, const unsigned char *singleton_lowers, const unsigned char *normal, size_t normal_size) -> bool
Definition: format-inl.h:1495
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:1158
uint128_fallback umul128(uint64_t x, uint64_t y) noexcept
Definition: format.h:1484
GLint y
Definition: glcorearb.h:103
**But if you need a result
Definition: thread.h:622
FMT_FUNC std::string vformat(string_view fmt, format_args args)
Definition: format-inl.h:1439
GLdouble GLdouble GLdouble q
Definition: glad.h:2445
FMT_CONSTEXPR uint32_t rotr(uint32_t n, uint32_t r) noexcept
Definition: format-inl.h:160
GLuint buffer
Definition: glcorearb.h:660
void fwrite_fully(const void *ptr, size_t size, size_t count, FILE *stream)
Definition: format-inl.h:76
constexpr uint64_t high() const noexcept
Definition: format.h:371
#define FMT_END_NAMESPACE
Definition: core.h:179
FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result< Char >
Definition: format-inl.h:95
#define FMT_THROW(x)
Definition: format.h:120
bool check_divisibility_and_divide_by_pow10(uint32_t &n) noexcept
Definition: format-inl.h:207
significand_type significand
Definition: format.h:1593
#define FMT_INLINE
Definition: core.h:161
uint64_t umul96_upper64(uint32_t x, uint64_t y) noexcept
Definition: format-inl.h:173
FMT_API void vprint_mojibake(std::FILE *, string_view, format_args)
Definition: core.h:2687
uint32_t divide_by_10_to_kappa_plus_1(uint32_t n) noexcept
Definition: format-inl.h:241
GLdouble n
Definition: glcorearb.h:2008
GLfloat f
Definition: glcorearb.h:1926
static carrier_uint compute_right_endpoint_for_shorter_interval_case(const cache_entry_type &cache, int beta) noexcept
Definition: format-inl.h:1102
GLintptr offset
Definition: glcorearb.h:665
const Char * iterator
Definition: core.h:662
uint128_fallback umul192_upper128(uint64_t x, uint128_fallback y) noexcept
Definition: format.h:1540
#define FMT_INLINE_VARIABLE
Definition: core.h:250
#define FMT_FUNC
Definition: format.h:4732
constexpr FMT_INLINE locale_ref()
Definition: core.h:1654
FMT_FUNC void print(std::FILE *f, string_view text)
Definition: format-inl.h:1473
FMT_FUNC std::system_error vsystem_error(int error_code, string_view fmt, format_args args)
Definition: format-inl.h:147
auto put(appender out, loc_value val, const format_specs<> &specs) const -> bool
Definition: format.h:1125
FMT_FUNC auto write_loc(appender out, loc_value value, const format_specs<> &specs, locale_ref loc) -> bool
Definition: format-inl.h:115
basic_memory_buffer< char > memory_buffer
Definition: format.h:1036
static compute_mul_parity_result compute_mul_parity(carrier_uint two_f, const cache_entry_type &cache, int beta) noexcept
Definition: format-inl.h:1085
int floor_log10_pow2(int e) noexcept
Definition: format.h:1515
#define FMT_API
Definition: core.h:204
static compute_mul_result compute_mul(carrier_uint u, const cache_entry_type &cache) noexcept
Definition: format-inl.h:1074
GLuint id
Definition: glcorearb.h:655
GLfloat GLfloat GLfloat alpha
Definition: glcorearb.h:112
FMT_FUNC void format_error_code(detail::buffer< char > &out, int error_code, string_view message) noexcept
Definition: format-inl.h:43
unsigned char upper
Definition: format-inl.h:1491
constexpr auto size() const noexcept-> size_t
Definition: core.h:901
std::wstring OIIO_UTIL_API utf8_to_utf16(string_view utf8str) noexcept
static uint32_t compute_delta(const cache_entry_type &cache, int beta) noexcept
Definition: format-inl.h:307
GLint GLenum GLint x
Definition: glcorearb.h:409
auto fprintf(std::FILE *f, const S &fmt, const T &...args) -> int
Definition: printf.h:646
auto get() const -> Locale
uint64_t umul96_lower64(uint32_t x, uint64_t y) noexcept
Definition: format-inl.h:188
FMT_INLINE_VARIABLE constexpr struct detail::dragonbox::@196 div_small_pow10_infos[]
FMT_BEGIN_DETAIL_NAMESPACE constexpr auto is_negative(T value) -> bool
Definition: format.h:1136
constexpr auto size() const noexcept-> size_t
Definition: core.h:443
GLint j
Definition: glad.h:2733
FMT_FUNC void format_system_error(detail::buffer< char > &out, int error_code, const char *message) noexcept
Definition: format-inl.h:1423
GLsizeiptr size
Definition: glcorearb.h:664
void(*)(detail::buffer< char > &, int, const char *) format_func
Definition: format.h:4175
IMATH_NAMESPACE::V2f IMATH_NAMESPACE::Box2i std::string this attribute is obsolete as of OpenEXR v3 float
GLenum func
Definition: glcorearb.h:783
uint128_fallback umul192_lower128(uint64_t x, uint128_fallback y) noexcept
Definition: format-inl.h:179
#define FMT_CONSTEXPR
Definition: core.h:104
FMT_CONSTEXPR20 auto bit_cast(const From &from) -> To
Definition: format.h:336
std::string lower(string_view a)
Return an all-upper case version of a (locale-independent).
Definition: strutil.h:493
OutputIt iterator
Definition: core.h:1730
auto ptr(T p) -> const void *
Definition: format.h:4331
GLuint GLfloat * val
Definition: glcorearb.h:1608
FMT_CONSTEXPR fp get_cached_power(int min_exponent, int &pow10_exponent)
Definition: format.h:1825
auto thousands_sep(locale_ref loc) -> thousands_sep_result< Char >
Definition: format.h:1303
constexpr FMT_INLINE_VARIABLE uint32_t invalid_code_point
Definition: format.h:709
GA_API const UT_StringHolder N
FMT_INLINE auto format_to(OutputIt out, format_string< T...> fmt, T &&...args) -> OutputIt
Definition: core.h:2843
**If you just want to fire and args
Definition: thread.h:618
constexpr auto data() const noexcept-> const Char *
Definition: core.h:440
auto write(OutputIt out, const std::tm &time, const std::locale &loc, char format, char modifier=0) -> OutputIt
Definition: chrono.h:419
FMT_FUNC uint128_fallback get_cached_power(int k) noexcept
Definition: format-inl.h:1117
FMT_CONSTEXPR20 auto count_digits(uint64_t n) -> int
Definition: format.h:1228
float_info< double >::carrier_uint carrier_uint
Definition: format-inl.h:346
#define FMT_ASSERT(condition, message)
Definition: core.h:336
uint64_t umul128_upper64(uint64_t x, uint64_t y) noexcept
Definition: format.h:1527
static uint64_t get_cached_power(int k) noexcept
Definition: format-inl.h:258
GLboolean r
Definition: glcorearb.h:1222
#define FMT_BEGIN_NAMESPACE
Definition: core.h:176
FMT_FUNC void report_system_error(int error_code, const char *message) noexcept
Definition: format-inl.h:1434
static carrier_uint compute_right_endpoint_for_shorter_interval_case(const cache_entry_type &cache, int beta) noexcept
Definition: format-inl.h:329
FMT_CONSTEXPR void for_each_codepoint(string_view s, F f)
Definition: format.h:714
FMT_FUNC bool write_console(std::FILE *, string_view)
Definition: format-inl.h:1449
int floor_log2_pow10(int e) noexcept
Definition: format.h:1521
FMT_FUNC void report_error(format_func func, int error_code, const char *message) noexcept
Definition: format-inl.h:66
static compute_mul_parity_result compute_mul_parity(carrier_uint two_f, const cache_entry_type &cache, int beta) noexcept
Definition: format-inl.h:312
decimal_fp< T > to_decimal(T x) noexcept
Definition: format-inl.h:1256
GLuint64 GLenum GLint fd
Definition: RE_OGL.h:262
FMT_CONSTEXPR auto parse(format_parse_context &ctx) -> format_parse_context::iterator
Definition: format-inl.h:1383
GLint GLsizei count
Definition: glcorearb.h:405
FMT_NORETURN FMT_API void assert_fail(const char *file, int line, const char *message)
Definition: format-inl.h:30
int floor_log10_pow2_minus_log10_4_over_3(int e) noexcept
Definition: format-inl.h:193
FMT_FUNC Char decimal_point_impl(locale_ref loc)
Definition: format-inl.h:101
static carrier_uint compute_left_endpoint_for_shorter_interval_case(const cache_entry_type &cache, int beta) noexcept
Definition: format-inl.h:1095
constexpr uint64_t low() const noexcept
Definition: format.h:372