8 #ifndef FMT_FORMAT_INL_H_
9 #define FMT_FORMAT_INL_H_
20 #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
32 inline fmt::detail::null<>
strerror_r(
int,
char*, ...) {
return {}; }
33 inline fmt::detail::null<>
strerror_s(
char*,
size_t, ...) {
return {}; }
41 std::fprintf(stderr,
"%s:%d: assertion failed: %s", file, line, message);
48 # define FMT_SNPRINTF snprintf
50 inline int fmt_snprintf(
char*
buffer,
size_t size,
const char*
format, ...) {
52 va_start(args, format);
53 int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
57 # define FMT_SNPRINTF fmt_snprintf
80 void operator=(
const dispatcher&) {}
85 return result == -1 ? errno :
result;
92 if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
101 return fallback(
strerror_s(buffer_, buffer_size_, error_code_));
106 int fallback(
int result) {
108 return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? ERANGE
116 buffer_ = strerror(error_code_);
122 dispatcher(
int err_code,
char*&
buf,
size_t buf_size)
123 : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
125 int run() {
return handle(
strerror_r(error_code_, buffer_, buffer_size_)); }
127 return dispatcher(error_code,
buffer, buffer_size).run();
136 static const char SEP[] =
": ";
137 static const char ERROR_STR[] =
"error ";
139 size_t error_code_size =
sizeof(SEP) +
sizeof(ERROR_STR) - 2;
142 abs_value = 0 - abs_value;
149 format_to(it,
"{}{}", ERROR_STR, error_code);
158 (
void)std::fwrite(full_message.
data(), full_message.
size(), 1, stderr);
159 std::fputc(
'\n', stderr);
165 size_t written = std::fwrite(ptr, size, count, stream);
170 #if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
173 template <
typename Locale>
180 return locale_ ? *
static_cast<const std::locale*
>(locale_) : std::locale();
184 return std::use_facet<std::numpunct<Char>>(loc.
get<std::locale>()).grouping();
187 return std::use_facet<std::numpunct<Char>>(loc.
get<std::locale>())
191 return std::use_facet<std::numpunct<Char>>(loc.
get<std::locale>())
196 template <
typename Char>
201 return FMT_STATIC_THOUSANDS_SEPARATOR;
213 error_code_ = err_code;
216 std::runtime_error& base = *
this;
217 base = std::runtime_error(
to_string(buffer));
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;
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'}};
250 template <
typename T>
251 const char basic_data<T>::hex_digits[] =
"0123456789abcdef";
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, \
258 template <
typename T>
259 const uint64_t basic_data<T>::powers_of_10_64[] = {
261 10000000000000000000ULL};
263 template <
typename T>
264 const uint32_t basic_data<T>::zero_or_powers_of_10_32[] = {0,
266 template <
typename T>
267 const uint64_t basic_data<T>::zero_or_powers_of_10_64[] = {
269 10000000000000000000ULL};
271 template <
typename T>
272 const uint32_t basic_data<T>::zero_or_powers_of_10_32_new[] = {
275 template <
typename T>
276 const uint64_t basic_data<T>::zero_or_powers_of_10_64_new[] = {
278 10000000000000000000ULL};
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,
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};
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}};
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}};
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};
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}
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}
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};
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};
1066 template <
typename T>
1067 const char basic_data<T>::foreground_color[] =
"\x1b[38;2;";
1068 template <
typename T>
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};
1078 template <
typename T>
struct bits {
1080 static_cast<int>(
sizeof(
T) * std::numeric_limits<unsigned char>::digits);
1097 using significand_type = uint64_t;
1099 template <
typename Float>
1101 sizeof(
Float) ==
sizeof(uint32_t)>;
1111 std::numeric_limits<double>::digits - 1;
1118 fp(uint64_t f_val,
int e_val) :
f(f_val),
e(e_val) {}
1122 template <
typename Double>
explicit fp(Double d) {
assign(d); }
1128 using limits = std::numeric_limits<Float>;
1129 const int float_significand_size = limits::digits - 1;
1130 const int exponent_size =
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;
1140 static_cast<int>((u &
exponent_mask) >> float_significand_size);
1143 bool is_predecessor_closer = f == 0 && biased_e > 1;
1145 f += float_implicit_bit;
1148 e = biased_e - exponent_bias - float_significand_size;
1149 return is_predecessor_closer;
1163 while ((value.
f & shifted_implicit_bit) == 0) {
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;
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;
1190 uint64_t mid = (bd >> 32) + (ad & mask) + (bc &
mask) + (1U << 31);
1191 return ac + (ad >> 32) + (bc >> 32) + (mid >> 32);
1200 const int shift = 32;
1202 int index =
static_cast<int>(
1204 ((int64_t(1) << shift) - 1))
1208 const int first_dec_exp = -348;
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;
1224 explicit operator uint32_t()
const {
return static_cast<uint32_t
>(
lower); }
1231 assert(shift == 32);
1233 lower = (upper << 32) | (lower >> 32);
1242 using bigit = uint32_t;
1243 using double_bigit = uint64_t;
1244 enum { bigits_capacity = 32 };
1249 bigit& operator[](
int index) {
return bigits_[
to_unsigned(index)]; }
1255 void subtract_bigits(
int index, bigit other, bigit& borrow) {
1256 auto result =
static_cast<double_bigit
>((*this)[
index]) - other - borrow;
1258 borrow =
static_cast<bigit
>(
result >> (bigit_bits * 2 - 1));
1261 void remove_leading_zeros() {
1263 while (num_bigits > 0 && (*
this)[
num_bigits] == 0) --num_bigits;
1268 void subtract_aligned(
const bigint& other) {
1269 FMT_ASSERT(other.exp_ >= exp_,
"unaligned bigints");
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();
1280 const double_bigit wide_value =
value;
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);
1287 if (carry != 0) bigits_.
push_back(carry);
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);
1298 bigits_[i] * upper + (result >> bigit_bits) + (carry >> bigit_bits);
1299 bigits_[i] =
static_cast<bigit
>(
result);
1301 while (carry != 0) {
1303 carry >>= bigit_bits;
1324 size_t num_bigits = 0;
1326 bigits_[num_bigits++] = n & ~bigit(0);
1329 bigits_.
resize(num_bigits);
1337 exp_ += shift / bigit_bits;
1338 shift %= bigit_bits;
1339 if (shift == 0)
return *
this;
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;
1346 if (carry != 0) bigits_.
push_back(carry);
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;
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;
1368 if (i != j)
return i > j ? 1 : -1;
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;
1382 double_bigit borrow = 0;
1384 for (
int i = num_rhs_bigits - 1; i >= min_exp; --i) {
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;
1393 return borrow != 0 ? -1 : 0;
1399 if (exp == 0)
return assign(1);
1402 while (exp >= bitmask) bitmask <<= 1;
1408 while (bitmask != 0) {
1410 if ((exp & bitmask) != 0) *
this *= 5;
1418 int num_bigits =
static_cast<int>(bigits_.
size());
1422 auto sum = accumulator_t();
1423 for (
int bigit_index = 0; bigit_index <
num_bigits; ++bigit_index) {
1426 for (
int i = 0, j = bigit_index; j >= 0; ++i, --j) {
1428 sum +=
static_cast<double_bigit
>(n[i]) * n[j];
1430 (*this)[bigit_index] =
static_cast<bigit
>(sum);
1434 for (
int bigit_index = num_bigits; bigit_index < num_result_bigits;
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);
1441 --num_result_bigits;
1442 remove_leading_zeros();
1449 int exp_difference = exp_ - other.exp_;
1450 if (exp_difference <= 0)
return;
1451 int num_bigits =
static_cast<int>(bigits_.
size());
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;
1463 if (
compare(*
this, divisor) < 0)
return 0;
1464 FMT_ASSERT(divisor.bigits_[divisor.bigits_.
size() - 1u] != 0,
"");
1468 subtract_aligned(divisor);
1470 }
while (
compare(*
this, divisor) >= 0);
1487 if (remainder <= divisor - remainder && error * 2 <= divisor - remainder * 2)
1490 if (remainder >= error &&
1491 remainder - error >= divisor - (remainder - error)) {
1508 template <
typename Handler>
1510 int& exp, Handler& handler) {
1511 const fp one(1ULL << -value.
e, value.
e);
1515 auto integral =
static_cast<uint32_t
>(value.
f >> -one.
e);
1519 uint64_t fractional = value.
f & (one.
f - 1);
1523 value.
f / 10, error * 10, exp);
1528 auto divmod_integral = [&](uint32_t
divisor) {
1536 divmod_integral(1000000000);
1539 divmod_integral(100000000);
1542 divmod_integral(10000000);
1545 divmod_integral(1000000);
1548 divmod_integral(100000);
1551 divmod_integral(10000);
1554 divmod_integral(1000);
1557 divmod_integral(100);
1560 divmod_integral(10);
1567 FMT_ASSERT(
false,
"invalid number of digits");
1570 auto remainder = (
static_cast<uint64_t
>(integral) << -one.
e) + fractional;
1571 result = handler.on_digit(static_cast<char>(
'0' + digit),
1580 char digit =
static_cast<char>(
'0' + (fractional >> -one.
e));
1581 fractional &= one.
f - 1;
1583 result = handler.on_digit(digit, one.
f, fractional, error, exp,
false);
1614 uint64_t
error,
int,
bool integral) {
1623 if (error >= divisor || error >= divisor - error)
return digits::error;
1631 for (
int i =
size - 1; i > 0 &&
buf[i] >
'9'; --i) {
1647 namespace dragonbox {
1652 return static_cast<uint128_t>(
x) * static_cast<uint128_t>(
y);
1653 #elif defined(_MSC_VER) && defined(_M_X64)
1658 const uint64_t mask = (uint64_t(1) << 32) - uint64_t(1);
1660 uint64_t
a =
x >> 32;
1662 uint64_t
c =
y >> 32;
1663 uint64_t d =
y &
mask;
1665 uint64_t ac = a *
c;
1666 uint64_t bc = b *
c;
1667 uint64_t ad = a * d;
1668 uint64_t bd = b * d;
1672 return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32),
1673 (intermediate << 32) + (bd &
mask)};
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);
1709 uint64_t g01 =
x *
y.high();
1723 FMT_ASSERT(e <= 1700 && e >= -1700,
"too large exponent");
1724 const int shift = 22;
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)))) >>
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;
1745 (64 - shift_amount)) -
1746 static_cast<int>(log10_4_over_3_fractional_digits >>
1747 (64 - shift_amount))) >>
1755 #ifdef FMT_BUILTIN_CTZ
1756 return FMT_BUILTIN_CTZ(
x) >= exp;
1758 return exp < num_bits<uint32_t>() &&
x == ((
x >> exp) << exp);
1764 #ifdef FMT_BUILTIN_CTZLL
1765 return FMT_BUILTIN_CTZLL(
x) >= exp;
1767 return exp < num_bits<uint64_t>() &&
x == ((
x >> exp) << exp);
1788 static constexpr
struct {
1789 uint32_t magic_number;
1790 int bits_for_comparison;
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;
1805 static constexpr
struct {
1806 uint32_t magic_number;
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;
1833 "k is out of range");
1844 return static_cast<uint32_t
>(cache >> (64 - 1 - beta_minus_1));
1853 return ((
umul96_lower64(two_f, cache) >> (64 - beta_minus_1)) & 1) != 0;
1872 return (static_cast<carrier_uint>(
1886 "k is out of range");
1888 #if FMT_USE_FULL_CACHE_DRAGONBOX
1892 static const int compression_ratio = 27;
1902 if (offset == 0)
return base_cache;
1906 FMT_ASSERT(alpha > 0 && alpha < 64,
"shifting error detected");
1912 umul128(base_cache.
low() - (kb < 0 ? 1u : 0u), pow5);
1914 recovered_cache += middle_low.
high();
1916 uint64_t high_to_middle = recovered_cache.
high() << (64 -
alpha);
1917 uint64_t middle_to_low = recovered_cache.
low() << (64 -
alpha);
1921 ((middle_low.low() >>
alpha) | middle_to_low)};
1923 if (kb < 0) recovered_cache += 1;
1926 int error_idx = (k - float_info<double>::min_k) / 16;
1928 ((k - float_info<double>::min_k) % 16) * 2) &
1933 return {recovered_cache.
high(), recovered_cache.
low() + error};
1944 return static_cast<uint32_t
>(cache.high() >> (64 - 1 - beta_minus_1));
1958 return (cache.high() -
1965 return (cache.high() +
1972 return ((cache.high() >>
1984 T>::case_shorter_interval_left_endpoint_lower_threshold &&
2014 #ifdef FMT_BUILTIN_CTZ
2015 int t = FMT_BUILTIN_CTZ(n);
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;
2028 for (; s < t - 1; s += 2) {
2029 if (n * mod_inv2 > max_quotient2)
break;
2032 if (s < t && n * mod_inv1 <= max_quotient1) {
2042 #ifdef FMT_BUILTIN_CTZLL
2043 int t = FMT_BUILTIN_CTZLL(n);
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;
2060 auto quotient_candidate = n * mod_inv8;
2062 if (quotient_candidate <= max_quotient8) {
2063 auto quotient =
static_cast<uint32_t
>(quotient_candidate >> 8);
2066 for (; s <
t; ++
s) {
2067 if (quotient * mod_inv1 > max_quotient1)
break;
2068 quotient *= mod_inv1;
2070 quotient >>= (s - 8);
2077 auto quotient =
static_cast<uint32_t
>(n / 100000000);
2078 auto remainder =
static_cast<uint32_t
>(n - 100000000 * quotient);
2080 if (t == 0 ||
remainder * mod_inv1 > max_quotient1) {
2085 if (t == 1 ||
remainder * mod_inv1 > max_quotient1) {
2086 n = (
remainder >> 1) + quotient * 10000000ull;
2091 if (t == 2 ||
remainder * mod_inv1 > max_quotient1) {
2092 n = (
remainder >> 2) + quotient * 1000000ull;
2097 if (t == 3 ||
remainder * mod_inv1 > max_quotient1) {
2098 n = (
remainder >> 3) + quotient * 100000ull;
2103 if (t == 4 ||
remainder * mod_inv1 > max_quotient1) {
2104 n = (
remainder >> 4) + quotient * 10000ull;
2109 if (t == 5 ||
remainder * mod_inv1 > max_quotient1) {
2110 n = (
remainder >> 5) + quotient * 1000ull;
2115 if (t == 6 ||
remainder * mod_inv1 > max_quotient1) {
2116 n = (
remainder >> 6) + quotient * 100ull;
2121 n = (
remainder >> 7) + quotient * 10ull;
2139 cache, beta_minus_1);
2141 cache, beta_minus_1);
2144 if (!is_left_endpoint_integer_shorter_interval<T>(exponent)) ++xi;
2159 cache, beta_minus_1);
2174 template <
typename T>
2183 const carrier_uint significand_mask =
2185 carrier_uint significand = (br & significand_mask);
2186 int exponent =
static_cast<int>((br & exponent_mask<T>()) >>
2189 if (exponent != 0) {
2193 if (significand == 0)
return shorter_interval_case<T>(exponent);
2196 (
static_cast<carrier_uint
>(1) << float_info<T>::significand_bits);
2199 if (significand == 0)
return {0, 0};
2203 const bool include_left_endpoint = (significand % 2 == 0);
2204 const bool include_right_endpoint = include_left_endpoint;
2214 const carrier_uint two_fc = significand << 1;
2215 const carrier_uint two_fr = two_fc | 1;
2216 const carrier_uint zi =
2229 goto small_divisor_case_label;
2230 }
else if (r < deltai) {
2232 if (r == 0 && !include_right_endpoint &&
2233 is_endpoint_integer<T>(two_fr, exponent, minus_k)) {
2236 goto small_divisor_case_label;
2242 const carrier_uint two_fl = two_fc - 1;
2243 if ((!include_left_endpoint ||
2244 !is_endpoint_integer<T>(two_fl, exponent, minus_k)) &&
2246 goto small_divisor_case_label;
2257 small_divisor_case_label:
2259 ret_value.
exponent = minus_k + float_info<T>::kappa;
2261 const uint32_t mask = (1u << float_info<T>::kappa) - 1;
2265 if ((
dist & mask) == 0) {
2266 const bool approx_y_parity =
2268 dist >>= float_info<T>::kappa;
2286 if (is_center_integer<T>(two_fc, exponent, minus_k)) {
2303 small_division_by_pow10<float_info<T>::kappa>(
dist);
2312 template <
typename Double>
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;
2330 numerator.
assign(significand);
2331 numerator <<= value.
e;
2336 upper_store <<= value.
e + 1;
2337 upper = &upper_store;
2340 denominator <<= shift;
2341 }
else if (exp10 < 0) {
2345 upper_store.
assign(numerator);
2347 upper = &upper_store;
2349 numerator *= significand;
2351 denominator <<= shift - value.
e;
2353 numerator.
assign(significand);
2355 denominator <<= shift - value.
e;
2358 upper_store.
assign(1ULL << 1);
2359 upper = &upper_store;
2363 if (num_digits < 0) {
2365 if (!upper) upper = &
lower;
2366 bool even = (value.
f & 1) == 0;
2371 bool low =
compare(numerator, lower) - even < 0;
2373 bool high = add_compare(numerator, *upper, denominator) + even > 0;
2374 data[num_digits++] =
static_cast<char>(
'0' + digit);
2377 ++data[num_digits - 1];
2379 int result = add_compare(numerator, numerator, denominator);
2381 if (result > 0 || (result == 0 && (digit % 2) != 0))
2382 ++data[num_digits - 1];
2385 exp10 -= num_digits - 1;
2390 if (upper != &lower) *upper *= 10;
2394 exp10 -= num_digits - 1;
2395 if (num_digits == 0) {
2398 buf[0] = add_compare(numerator, numerator, denominator) > 0 ?
'1' :
'0';
2402 for (
int i = 0; i < num_digits - 1; ++i) {
2404 buf[i] =
static_cast<char>(
'0' + digit);
2408 auto result = add_compare(numerator, numerator, denominator);
2411 const auto overflow =
'0' + 10;
2412 buf[num_digits - 1] = overflow;
2414 for (
int i = num_digits - 1; i > 0 && buf[i] == overflow; --i) {
2418 if (buf[0] == overflow) {
2426 buf[num_digits - 1] =
static_cast<char>(
'0' + digit);
2429 template <
typename T>
2436 if (precision <= 0 || !fixed) {
2447 if (precision < 0) {
2452 return dec.exponent;
2456 return dec.exponent;
2462 const int min_exp = -60;
2463 int cached_exp10 = 0;
2467 normalized = normalized * cached_pow;
2470 const int max_double_digits = 767;
2471 if (precision > max_double_digits) precision = max_double_digits;
2474 exp += handler.size - cached_exp10 - 1;
2477 exp += handler.exp10;
2482 auto num_digits = buf.
size();
2483 while (num_digits > 0 && buf[num_digits - 1] ==
'0') {
2492 template <
typename T>
2503 precision = (precision >= 0 ? precision : 6) - 1;
2506 enum { max_format_size = 7 };
2507 char format[max_format_size];
2508 char* format_ptr =
format;
2509 *format_ptr++ =
'%';
2511 if (precision >= 0) {
2512 *format_ptr++ =
'.';
2513 *format_ptr++ =
'*';
2515 if (std::is_same<T, long double>()) *format_ptr++ =
'L';
2518 : (specs.
upper ?
'A' :
'a');
2527 if (precision > 100000)
2528 throw std::runtime_error(
2529 "fuzz mode - avoid large allocation inside snprintf");
2534 int result = precision >= 0
2535 ? snprintf_ptr(begin, capacity, format, precision, value)
2536 : snprintf_ptr(begin, capacity, format, value);
2544 if (
size >= capacity) {
2548 auto is_digit = [](
char c) {
return c >=
'0' &&
c <=
'9'; };
2550 if (precision == 0) {
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));
2562 return -fraction_size;
2572 }
while (*exp_pos !=
'e');
2573 char sign = exp_pos[1];
2574 assert(sign ==
'+' || sign ==
'-');
2576 auto p = exp_pos + 2;
2578 assert(is_digit(*
p));
2579 exp = exp * 10 + (*
p++ -
'0');
2581 if (sign ==
'-') exp = -exp;
2582 int fraction_size = 0;
2583 if (exp_pos != begin + 1) {
2585 auto fraction_end = exp_pos - 1;
2586 while (*fraction_end ==
'0') --fraction_end;
2588 fraction_size =
static_cast<int>(fraction_end - begin - 1);
2589 std::memmove(begin + 1, begin + 2,
to_unsigned(fraction_size));
2592 return exp - fraction_size;
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};
2620 const char* next = buf +
len;
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;
2632 *e = (*c < mins[
len]) << 6;
2633 *e |= ((*c >> 11) == 0x1b) << 7;
2634 *e |= (*c > 0x10FFFF) << 8;
2635 *e |= (
s[1] & 0xc0) >> 2;
2636 *e |= (
s[2] & 0xc0) >> 4;
2652 h.
format(parse_ctx, format_ctx);
2665 auto out = ctx.
out();
2667 for (
auto i = n.bigits_.
size(); i > 0; --i) {
2668 auto value = n.bigits_[i - 1u];
2677 out =
format_to(out,
"p{}", n.exp_ * detail::bigint::bigit_bits);
2683 auto transcode = [
this](
const char*
p) {
2684 auto cp = uint32_t();
2689 buffer_.push_back(static_cast<wchar_t>(cp));
2692 buffer_.push_back(static_cast<wchar_t>(0xD800 + (cp >> 10)));
2693 buffer_.push_back(static_cast<wchar_t>(0xDC00 + (cp & 0x3FF)));
2698 const size_t block_size = 4;
2699 if (s.
size() >= block_size) {
2700 for (
auto end =
p + s.
size() - block_size + 1;
p <
end;)
p = transcode(
p);
2702 if (
auto num_chars_left = s.
data() + s.
size() -
p) {
2703 char buf[2 * block_size - 1] = {};
2708 }
while (
p - buf < num_chars_left);
2710 buffer_.push_back(0);
2719 char* system_message = &buf[0];
2727 if (result != ERANGE)
2759 extern "C" __declspec(dllimport)
int __stdcall WriteConsoleW(
2760 void*,
const void*, dword, dword*,
void*);
2769 auto fd = _fileno(f);
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)) {
2796 vprint(stdout, format_str, args);
2801 #endif // FMT_FORMAT_INL_H_
FMT_FUNC Char decimal_point_impl(locale_ref loc)
GLuint GLsizei const GLchar * message
GA_API const UT_StringHolder dist
GLboolean GLboolean GLboolean b
bool equal2(const Char *lhs, const char *rhs)
static carrier_uint compute_right_endpoint_for_shorter_interval_case(const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
std::string upper(string_view a)
Return an all-upper case version of a (locale-independent).
uint32_t umul96_upper32(uint32_t x, uint64_t y) FMT_NOEXCEPT
float_info< float >::carrier_uint carrier_uint
static carrier_uint compute_right_endpoint_for_shorter_interval_case(const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
int divmod_assign(const bigint &divisor)
void operator>>=(int shift)
void intermediate(const Quat< T > &q0, const Quat< T > &q1, const Quat< T > &q2, const Quat< T > &q3, Quat< T > &qa, Quat< T > &qb)
int floor_log2_pow10(int e) FMT_NOEXCEPT
bool operator==(fp x, fp y)
const wchar_t * c_str() const
void try_reserve(size_t new_capacity)
typename std::conditional< B, T, F >::type conditional_t
bool divisible_by_power_of_2(uint32_t x, int exp) FMT_NOEXCEPT
FMT_CONSTEXPR int code_point_length(const Char *begin)
static FMT_CONSTEXPR_DECL const uint64_t implicit_bit
static carrier_uint compute_mul(carrier_uint u, const cache_entry_type &cache) FMT_NOEXCEPT
FMT_FUNC void report_error(format_func func, int error_code, string_view message) FMT_NOEXCEPT
FMT_ALWAYS_INLINE int remove_trailing_zeros(uint32_t &n) FMT_NOEXCEPT
static carrier_uint compute_round_up_for_shorter_interval_case(const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
void operator+=(uint64_t n)
void try_resize(size_t count)
uint32_t small_division_by_pow10(uint32_t n) FMT_NOEXCEPT
uint64_t umul96_lower64(uint32_t x, uint64_t y) FMT_NOEXCEPT
static carrier_uint compute_left_endpoint_for_shorter_interval_case(const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
uint32_t divide_by_10_to_kappa_plus_1(uint32_t n) FMT_NOEXCEPT
uint64_t low() const FMT_NOEXCEPT
auto format_to(OutputIt out, const S &format_str, Args &&...args) -> typename std::enable_if< enable, OutputIt >::type
static FMT_CONSTEXPR_DECL const int double_significand_size
size_t size() const FMT_NOEXCEPT
std::string operator()(basic_format_arg< format_context >::handle h) const
static carrier_uint compute_round_up_for_shorter_interval_case(const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
void assign_pow10(int exp)
#define FMT_CONSTEXPR_DECL
void fallback_format(Double d, int num_digits, bool binary32, buffer< char > &buf, int &exp10)
int floor_log10_pow2(int e) FMT_NOEXCEPT
FMT_SAFEBUFFERS decimal_fp< T > to_decimal(T x) FMT_NOEXCEPT
constexpr dragonbox::float_info< T >::carrier_uint exponent_mask()
void vprint_mojibake(std::FILE *, basic_string_view< Char >, const Args &)
void fwrite_fully(const void *ptr, size_t size, size_t count, FILE *stream)
static const int16_t grisu_pow10_exponents[]
static const uint64_t log10_2_significand
#define FMT_END_NAMESPACE
FMT_FUNC int count_digits< 4 >(detail::fallback_uintptr n)
bigint & operator*=(Int value)
basic_string_view< char > string_view
void(*)(detail::buffer< char > &, int, string_view) format_func
constexpr size_type size() const noexcept
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)
fp get_cached_power(int min_exponent, int &pow10_exponent)
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
FMT_CONSTEXPR std::make_unsigned< Int >::type to_unsigned(Int value)
static uint32_t compute_delta(const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
FMT_CONSTEXPR_DECL FMT_INLINE auto visit_format_arg(Visitor &&vis, const basic_format_arg< Context > &arg) -> decltype(vis(0))
static const uint64_t dragonbox_pow10_significands_64[]
ImageBuf OIIO_API min(Image_or_Const A, Image_or_Const B, ROI roi={}, int nthreads=0)
void push_back(const T &value)
GLint GLenum GLboolean normalized
INT32 INT32 * denominator
int floor_log10_pow2_minus_log10_4_over_3(int e) FMT_NOEXCEPT
png_structrp png_const_color_16p background_color
constexpr iterator begin() const FMT_NOEXCEPT
bool is_center_integer(typename float_info< T >::carrier_uint two_f, int exponent, int minus_k) FMT_NOEXCEPT
FMT_API utf8_to_utf16(string_view s)
friend int add_compare(const bigint &lhs1, const bigint &lhs2, const bigint &rhs)
FMT_SAFEBUFFERS uint64_t umul192_middle64(uint64_t x, uint128_wrapper y) FMT_NOEXCEPT
GLboolean GLboolean GLboolean GLboolean a
std::basic_string< Char > vformat(basic_string_view< Char > format_str, basic_format_args< buffer_context< type_identity_t< Char >>> args)
bool divisible_by_power_of_5(uint32_t x, int exp) FMT_NOEXCEPT
GLsizei const GLchar *const * string
friend int compare(const bigint &lhs, const bigint &rhs)
static uint128_wrapper get_cached_power(int k) FMT_NOEXCEPT
static carrier_uint compute_mul(carrier_uint u, const cache_entry_type &cache) FMT_NOEXCEPT
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
typedef int(WINAPI *PFNWGLRELEASEPBUFFERDCARBPROC)(HPBUFFERARB hPbuffer
digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder, uint64_t error, int, bool integral)
static const uint64_t powers_of_5_64[]
bool check_divisibility_and_divide_by_pow5(uint32_t &n) FMT_NOEXCEPT
round_direction get_round_direction(uint64_t divisor, uint64_t remainder, uint64_t error)
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
static const uint64_t powers_of_10_64[]
significand_type significand
void assign(const bigint &other)
int format_float(T value, int precision, float_specs specs, buffer< char > &buf)
detail::named_arg< Char, T > arg(const Char *name, const T &arg)
GLenum GLuint GLenum GLsizei const GLchar * buf
FMT_INLINE std::string operator()(T value) const
GLenum GLint GLint * precision
const char * utf8_decode(const char *buf, uint32_t *c, int *e)
FMT_SAFEBUFFERS uint64_t umul192_upper64(uint64_t x, uint128_wrapper y) FMT_NOEXCEPT
GLint GLint GLsizei GLint GLenum format
GLfloat GLfloat GLfloat GLfloat h
FMT_NOINLINE bigint & operator<<=(int shift)
static carrier_uint compute_left_endpoint_for_shorter_interval_case(const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
FMT_NORETURN FMT_API void on_error(const char *message)
Dest bit_cast(const Source &source)
int snprintf_float(T value, int precision, float_specs specs, buffer< char > &buf)
typename basic_string_view< Char >::iterator iterator
static const divtest_table_entry< uint64_t > divtest_table_for_pow5_64[]
std::string lower(string_view a)
Return an all-upper case version of a (locale-independent).
static const uint128_wrapper dragonbox_pow10_significands_128[]
FMT_FUNC Char thousands_sep_impl(locale_ref loc)
static const uint32_t dragonbox_pow10_recovery_errors[]
int safe_strerror(int error_code, char *&buffer, size_t buffer_size) FMT_NOEXCEPT
OIIO_API bool copy(string_view from, string_view to, std::string &err)
GA_API const UT_StringHolder N
static uint64_t get_cached_power(int k) FMT_NOEXCEPT
GLsizei const GLfloat * value
T * make_checked(T *p, size_t)
**If you just want to fire and args
bool is_endpoint_integer(typename float_info< T >::carrier_uint two_f, int exponent, int minus_k) FMT_NOEXCEPT
FMT_SAFEBUFFERS uint128_wrapper umul128(uint64_t x, uint64_t y) FMT_NOEXCEPT
FMT_ALWAYS_INLINE digits::result grisu_gen_digits(fp value, uint64_t error, int &exp, Handler &handler)
static bool compute_mul_parity(carrier_uint two_f, const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
uint64_t high() const FMT_NOEXCEPT
void resize(size_t count)
INT64 INT64 INT64 remainder
bool is_left_endpoint_integer_shorter_interval(int exponent) FMT_NOEXCEPT
float_info< double >::carrier_uint carrier_uint
#define FMT_ASSERT(condition, message)
FMT_SAFEBUFFERS uint64_t umul128_upper64(uint64_t x, uint64_t y) FMT_NOEXCEPT
#define FMT_BEGIN_NAMESPACE
void align(const bigint &other)
static const uint64_t grisu_pow10_significands[]
FMT_FUNC void format_error_code(detail::buffer< char > &out, int error_code, string_view message) FMT_NOEXCEPT
GLfloat GLfloat GLfloat alpha
FMT_FUNC std::string grouping_impl(locale_ref loc)
int fprintf(std::FILE *f, const S &format, const Args &...args)
fp(uint64_t f_val, int e_val)
FMT_CONSTEXPR bool is_negative(T value)
std::integral_constant< bool, B > bool_constant
uint64_t multiply(uint64_t lhs, uint64_t rhs)
uint64_t cache_entry_type
static const divtest_table_entry< uint32_t > divtest_table_for_pow5_32[]
const charT * data() const noexcept
FMT_NORETURN FMT_API void assert_fail(const char *file, int line, const char *message)
static FMT_CONSTEXPR_DECL const int significand_size
FMT_ALWAYS_INLINE FMT_SAFEBUFFERS decimal_fp< T > shorter_interval_case(int exponent) FMT_NOEXCEPT
int count_digits(uint64_t n)
size_t capacity() const FMT_NOEXCEPT
digits::result on_start(uint64_t divisor, uint64_t remainder, uint64_t error, int &exp)