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