SoPlex Documentation
Loading...
Searching...
No Matches
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.
32inline fmt::detail::null<> strerror_r(int, char*, ...) { return {}; }
33inline fmt::detail::null<> strerror_s(char*, size_t, ...) { return {}; }
34
36namespace detail {
37
38FMT_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
50inline 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.
69inline 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
131 string_view message) FMT_NOEXCEPT {
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);
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
154 string_view message) FMT_NOEXCEPT {
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.
163inline 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)
171namespace detail {
172
173template <typename Locale>
174locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
175 static_assert(std::is_same<Locale, std::locale>::value, "");
176}
177
178template <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
183template <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}
186template <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}
190template <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
196template <typename Char>
197FMT_FUNC std::string detail::grouping_impl(locale_ref) {
198 return "\03";
199}
200template <typename Char> FMT_FUNC Char detail::thousands_sep_impl(locale_ref) {
201 return FMT_STATIC_THOUSANDS_SEPARATOR;
202}
203template <typename Char> FMT_FUNC Char detail::decimal_point_impl(locale_ref) {
204 return '.';
205}
206#endif
207
210
211FMT_FUNC void system_error::init(int err_code, string_view format_str,
212 format_args args) {
213 error_code_ = err_code;
214 memory_buffer buffer;
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
220namespace 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
230template <typename T>
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
250template <typename T>
251const 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
258template <typename T>
259const uint64_t basic_data<T>::powers_of_10_64[] = {
260 1, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ULL),
261 10000000000000000000ULL};
262
263template <typename T>
264const uint32_t basic_data<T>::zero_or_powers_of_10_32[] = {0,
266template <typename T>
268 0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ULL),
269 10000000000000000000ULL};
270
271template <typename T>
273 0, 0, FMT_POWERS_OF_10(1)};
274
275template <typename T>
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.
282template <typename T>
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.
317template <typename T>
318const 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
328template <typename T>
329const 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
337template <typename T>
338const 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
364template <typename T>
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
393template <typename T>
394const 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
1043template <typename T>
1044const 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
1055template <typename T>
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
1066template <typename T>
1067const char basic_data<T>::foreground_color[] = "\x1b[38;2;";
1068template <typename T>
1069const char basic_data<T>::background_color[] = "\x1b[48;2;";
1070template <typename T> const char basic_data<T>::reset_color[] = "\x1b[0m";
1071template <typename T> const wchar_t basic_data<T>::wreset_color[] = L"\x1b[0m";
1072template <typename T> const char basic_data<T>::signs[] = {0, '-', '+', ' '};
1073template <typename T>
1074const char basic_data<T>::left_padding_shifts[] = {31, 31, 0, 1, 0};
1075template <typename T>
1076const char basic_data<T>::right_padding_shifts[] = {0, 31, 0, 1, 0};
1077
1078template <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
1083class fp;
1084template <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.
1090 uint64_t lower;
1091 uint64_t upper;
1092};
1093
1094// A handmade floating-point number f * pow(2, e).
1095class 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:
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 =
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.
1125 template <typename Float, FMT_ENABLE_IF(is_supported_float<Float>::value)>
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);
1137 auto u = bit_cast<conditional_t<is_double, uint64_t, uint32_t>>(d);
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
1152 template <typename Float, FMT_ENABLE_IF(!is_supported_float<Float>::value)>
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).
1160template <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
1175inline 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.
1178inline 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
1195inline 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`.
1199inline 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;
1215}
1216
1217// A simple accumulator to hold the sums of terms in bigint::square if uint128_t
1218// is not available.
1220 uint64_t lower;
1221 uint64_t upper;
1222
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
1238class 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
1250
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
1262 int num_bigits = static_cast<int>(bigits_.size()) - 1;
1263 while (num_bigits > 0 && (*this)[num_bigits] == 0) --num_bigits;
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);
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); }
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);
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() {
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;
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.
1461 int divmod_assign(const bigint& divisor) {
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
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.
1481inline round_direction get_round_direction(uint64_t divisor, uint64_t remainder,
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 }
1495}
1496
1497namespace digits {
1499 more, // Generate more digits.
1500 done, // Done generating digits.
1501 error // Digit generation cancelled due to an error.
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).
1508template <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;
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.
1647namespace 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)
1654 uint128_wrapper result;
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.
1678FMT_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.
1701inline 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.
1716inline 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.
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.
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).
1752inline 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}
1761inline 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).
1772inline bool divisible_by_power_of_5(uint32_t x, int exp) FMT_NOEXCEPT {
1773 FMT_ASSERT(exp <= 10, "too large exponent");
1776}
1777inline bool divisible_by_power_of_5(uint64_t x, int exp) FMT_NOEXCEPT {
1778 FMT_ASSERT(exp <= 23, "too large exponent");
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).
1786template <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).
1804template <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)
1816inline uint32_t divide_by_10_to_kappa_plus_1(uint32_t n) FMT_NOEXCEPT {
1818}
1819// Computes floor(n / 10^(kappa + 1)) (double)
1820inline 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
1825template <class T> struct cache_accessor;
1826
1827template <> 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
1880template <> 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
1980template <class T>
1982 return exponent >=
1983 float_info<
1984 T>::case_shorter_interval_left_endpoint_lower_threshold &&
1985 exponent <=
1987}
1988template <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
1999template <class T>
2000bool 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
2126template <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
2174template <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;
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
2257small_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?
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.
2312template <typename Double>
2313void 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 }
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;
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
2429template <typename T>
2430int 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
2492template <typename T>
2493int 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 */
2613inline 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
2645 template <typename T> FMT_INLINE std::string operator()(T value) const {
2646 return to_string(value);
2647 }
2649 memory_buffer buf;
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
2658template <> struct formatter<detail::bigint> {
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
2714 string_view message) FMT_NOEXCEPT {
2715 FMT_TRY {
2716 memory_buffer buf;
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) {
2723 format_to(detail::buffer_appender<char>(out), "{}: {}", message,
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
2741 fmt::string_view message) FMT_NOEXCEPT {
2743}
2744
2745FMT_FUNC std::string detail::vformat(string_view format_str, format_args args) {
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
2757namespace detail {
2758using dword = conditional_t<sizeof(long) == 4, unsigned long, unsigned>;
2759extern "C" __declspec(dllimport) int __stdcall WriteConsoleW( //
2760 void*, const void*, dword, dword*, void*);
2761} // namespace detail
2762#endif
2763
2764FMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args args) {
2765 memory_buffer buffer;
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.
2786FMT_FUNC void detail::vprint_mojibake(std::FILE* f, string_view format_str,
2787 format_args args) {
2788 memory_buffer buffer;
2789 detail::vformat_to(buffer, format_str,
2791 fwrite_fully(buffer.data(), 1, buffer.size(), f);
2792}
2793#endif
2794
2795FMT_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_
void format(typename Context::parse_context_type &parse_ctx, Context &ctx) const
Definition core.h:1281
format_arg get(int id) const
Definition core.h:1897
iterator out()
Definition core.h:1526
OutputIt iterator
Definition core.h:1501
constexpr iterator begin() const FMT_NOEXCEPT
Definition core.h:577
typename basic_string_view< Char >::iterator iterator
Definition core.h:566
void resize(size_t count)
Definition format.h:727
constexpr size_t size() const
Definition core.h:399
constexpr const Char * data() const
Definition core.h:396
basic_memory_buffer< bigit, bigits_capacity > bigits_
bigint & operator*=(Int value)
void align(const bigint &other)
void operator=(const bigint &)=delete
bigit & operator[](int index)
bigit operator[](int index) const
bigint(uint64_t n)
uint64_t double_bigit
void assign_pow10(int exp)
void subtract_aligned(const bigint &other)
void assign(uint64_t n)
static FMT_CONSTEXPR_DECL const int bigit_bits
void assign(const bigint &other)
int num_bigits() const
int divmod_assign(const bigint &divisor)
FMT_NOINLINE bigint & operator<<=(int shift)
friend int compare(const bigint &lhs, const bigint &rhs)
void multiply(uint64_t value)
friend int add_compare(const bigint &lhs1, const bigint &lhs2, const bigint &rhs)
void multiply(uint32_t value)
void subtract_bigits(int index, bigit other, bigit &borrow)
bigint(const bigint &)=delete
void remove_leading_zeros()
void try_reserve(size_t new_capacity)
Definition core.h:731
T * data() FMT_NOEXCEPT
Definition core.h:712
void try_resize(size_t count)
Definition core.h:722
void push_back(const T &value)
Definition core.h:735
size_t size() const FMT_NOEXCEPT
Definition core.h:706
size_t capacity() const FMT_NOEXCEPT
Definition core.h:709
static FMT_CONSTEXPR_DECL const int significand_size
static FMT_CONSTEXPR_DECL const uint64_t implicit_bit
fp(Double d)
static FMT_CONSTEXPR_DECL const int double_significand_size
bool assign(Float d)
bool_constant< sizeof(Float)==sizeof(uint64_t)|| sizeof(Float)==sizeof(uint32_t)> is_supported_float
uint64_t significand_type
significand_type f
bool assign(Float)
fp(uint64_t f_val, int e_val)
Locale get() const
Definition format-inl.h:178
const void * locale_
Definition core.h:1394
size_t size() const
Definition format.h:1137
FMT_API utf8_to_utf16(string_view s)
const wchar_t * c_str() const
Definition format.h:1138
wmemory_buffer buffer_
Definition format.h:1132
~format_error() FMT_NOEXCEPT FMT_OVERRIDE
auto format_to(OutputIt out, const text_style &ts, const S &format_str, Args &&... args) -> typename std::enable_if< enable, OutputIt >::type
Definition color.h:594
std::basic_string< Char > format(const text_style &ts, const S &format_str, const Args &... args)
Definition color.h:560
std::basic_string< Char > vformat(const text_style &ts, const S &format_str, basic_format_args< buffer_context< type_identity_t< Char > > > args)
Definition color.h:539
void vprint(std::FILE *f, const text_style &ts, const S &format, basic_format_args< buffer_context< type_identity_t< Char > > > args)
Definition color.h:498
#define FMT_ASSERT(condition, message)
Definition core.h:292
std::integral_constant< bool, B > bool_constant
Definition core.h:262
basic_string_view< char > string_view
Definition core.h:440
detail::named_arg< Char, T > arg(const Char *name, const T &arg)
Definition core.h:1640
auto format_to(OutputIt out, const S &format_str, Args &&... args) -> typename std::enable_if< enable, OutputIt >::type
Definition core.h:2002
#define FMT_BEGIN_NAMESPACE
Definition core.h:203
#define FMT_API
Definition core.h:222
#define FMT_INLINE
Definition core.h:177
FMT_CONSTEXPR_DECL FMT_INLINE auto visit_format_arg(Visitor &&vis, const basic_format_arg< Context > &arg) -> decltype(vis(0))
Definition core.h:1310
typename std::conditional< B, T, F >::type conditional_t
Definition core.h:261
#define FMT_END_NAMESPACE
Definition core.h:198
#define FMT_NOEXCEPT
Definition core.h:139
#define FMT_CONSTEXPR_DECL
Definition core.h:99
FMT_FUNC void format_system_error(detail::buffer< char > &out, int error_code, string_view message) FMT_NOEXCEPT
FMT_FUNC void report_system_error(int error_code, fmt::string_view message) FMT_NOEXCEPT
#define FMT_SNPRINTF
Definition format-inl.h:48
fmt::detail::null strerror_s(char *, size_t,...)
Definition format-inl.h:33
fmt::detail::null strerror_r(int, char *,...)
Definition format-inl.h:32
#define FMT_POWERS_OF_10(factor)
Definition format-inl.h:253
#define FMT_FUNC
Definition format.h:3954
@ inline_buffer_size
Definition format.h:621
#define FMT_SAFEBUFFERS
Definition format.h:984
const void * ptr(const T *p)
Definition format.h:3603
#define FMT_TRY
Definition format.h:128
#define FMT_MAYBE_UNUSED
Definition format.h:94
#define FMT_ALWAYS_INLINE
Definition format.h:977
std::string to_string(const T &value)
Definition format.h:3730
#define FMT_CATCH(x)
Definition format.h:129
#define FMT_NOINLINE
Definition format.h:69
#define FMT_THROW(x)
Definition format.h:116
bool is_center_integer(typename float_info< T >::carrier_uint two_f, int exponent, int minus_k) FMT_NOEXCEPT
FMT_ALWAYS_INLINE int remove_trailing_zeros(uint32_t &n) FMT_NOEXCEPT
FMT_SAFEBUFFERS uint64_t umul128_upper64(uint64_t x, uint64_t y) FMT_NOEXCEPT
bool is_left_endpoint_integer_shorter_interval(int exponent) FMT_NOEXCEPT
FMT_SAFEBUFFERS decimal_fp< T > to_decimal(T x) FMT_NOEXCEPT
FMT_SAFEBUFFERS uint64_t umul192_middle64(uint64_t x, uint128_wrapper y) FMT_NOEXCEPT
uint32_t umul96_upper32(uint32_t x, uint64_t y) FMT_NOEXCEPT
uint64_t umul96_lower64(uint32_t x, uint64_t y) FMT_NOEXCEPT
FMT_SAFEBUFFERS uint64_t umul192_upper64(uint64_t x, uint128_wrapper y) FMT_NOEXCEPT
bool is_endpoint_integer(typename float_info< T >::carrier_uint two_f, int exponent, int minus_k) FMT_NOEXCEPT
bool divisible_by_power_of_2(uint32_t x, int exp) FMT_NOEXCEPT
int floor_log10_pow2(int e) FMT_NOEXCEPT
FMT_ALWAYS_INLINE FMT_SAFEBUFFERS decimal_fp< T > shorter_interval_case(int exponent) FMT_NOEXCEPT
bool check_divisibility_and_divide_by_pow5(uint32_t &n) FMT_NOEXCEPT
uint32_t small_division_by_pow10(uint32_t n) FMT_NOEXCEPT
FMT_SAFEBUFFERS uint128_wrapper umul128(uint64_t x, uint64_t y) FMT_NOEXCEPT
int floor_log2_pow10(int e) FMT_NOEXCEPT
bool divisible_by_power_of_5(uint32_t x, int exp) FMT_NOEXCEPT
int floor_log10_pow2_minus_log10_4_over_3(int e) FMT_NOEXCEPT
uint32_t divide_by_10_to_kappa_plus_1(uint32_t n) FMT_NOEXCEPT
round_direction get_round_direction(uint64_t divisor, uint64_t remainder, uint64_t error)
int snprintf_float(T value, int precision, float_specs specs, buffer< char > &buf)
int safe_strerror(int error_code, char *&buffer, size_t buffer_size) FMT_NOEXCEPT
Definition format-inl.h:69
T * make_checked(T *p, size_t)
Definition format.h:365
bool equal2(const Char *lhs, const char *rhs)
Definition format.h:1026
void vprint_mojibake(std::FILE *, basic_string_view< Char >, const Args &)
Definition core.h:1967
FMT_FUNC int count_digits< 4 >(detail::fallback_uintptr n)
Definition format-inl.h:222
FMT_NORETURN FMT_API void assert_fail(const char *file, int line, const char *message)
Definition format-inl.h:38
FMT_FUNC void format_error_code(detail::buffer< char > &out, int error_code, string_view message) FMT_NOEXCEPT
Definition format-inl.h:130
const char * utf8_decode(const char *buf, uint32_t *c, int *e)
void fwrite_fully(const void *ptr, size_t size, size_t count, FILE *stream)
Definition format-inl.h:163
FMT_CONSTEXPR std::make_unsigned< Int >::type to_unsigned(Int value)
Definition core.h:325
FMT_FUNC std::string grouping_impl(locale_ref loc)
Definition format-inl.h:183
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:810
void(*)(detail::buffer< char > &, int, string_view) format_func
Definition format.h:3249
fp normalize(fp value)
int count_digits(uint64_t n)
Definition format.h:928
fp get_cached_power(int min_exponent, int &pow10_exponent)
constexpr size_t count()
Definition core.h:968
void vformat_to(buffer< Char > &buf, const text_style &ts, basic_string_view< Char > format_str, basic_format_args< buffer_context< type_identity_t< Char > > > args)
Definition color.h:473
FMT_CONSTEXPR bool is_negative(T value)
Definition format.h:792
FMT_FUNC Char decimal_point_impl(locale_ref loc)
Definition format-inl.h:190
FMT_FUNC void report_error(format_func func, int error_code, string_view message) FMT_NOEXCEPT
Definition format-inl.h:153
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
FMT_ALWAYS_INLINE digits::result grisu_gen_digits(fp value, uint64_t error, int &exp, Handler &handler)
uint64_t multiply(uint64_t lhs, uint64_t rhs)
fp operator*(fp x, fp y)
void fallback_format(Double d, int num_digits, bool binary32, buffer< char > &buf, int &exp10)
constexpr dragonbox::float_info< T >::carrier_uint exponent_mask()
Definition format.h:1273
FMT_FUNC Char thousands_sep_impl(locale_ref loc)
Definition format-inl.h:186
FMT_CONSTEXPR int code_point_length(const Char *begin)
Definition format.h:2767
int format_float(T value, int precision, float_specs specs, buffer< char > &buf)
bool operator==(fp x, fp y)
Integer numerator(const Rational &r)
Definition rational.h:940
Integer denominator(const Rational &r)
Definition rational.h:945
void operator>>=(int shift)
void operator+=(uint64_t n)
static const divtest_table_entry< uint64_t > divtest_table_for_pow5_64[]
Definition format.h:874
static const uint64_t log10_2_significand
Definition format.h:878
static const uint32_t zero_or_powers_of_10_32[]
Definition format.h:896
static const uint32_t dragonbox_pow10_recovery_errors[]
Definition format.h:881
static const char left_padding_shifts[5]
Definition format.h:892
static const int16_t grisu_pow10_exponents[]
Definition format.h:872
static const uint64_t zero_or_powers_of_10_64_new[]
Definition format.h:870
static const digit_pair digits[]
Definition format.h:885
static const uint64_t zero_or_powers_of_10_64[]
Definition format.h:897
static const uint32_t zero_or_powers_of_10_32_new[]
Definition format.h:869
static const uint64_t grisu_pow10_significands[]
Definition format.h:871
static const uint64_t dragonbox_pow10_significands_64[]
Definition format.h:875
static const uint64_t powers_of_5_64[]
Definition format.h:880
static const char right_padding_shifts[5]
Definition format.h:893
static const char foreground_color[]
Definition format.h:887
static const uint64_t powers_of_10_64[]
Definition format.h:868
static const divtest_table_entry< uint32_t > divtest_table_for_pow5_32[]
Definition format.h:873
static const wchar_t wreset_color[5]
Definition format.h:890
char[2] digit_pair
Definition format.h:884
static const uint128_wrapper dragonbox_pow10_significands_128[]
Definition format.h:876
static const char reset_color[5]
Definition format.h:889
static const char background_color[]
Definition format.h:888
static const char hex_digits[]
Definition format.h:886
static const char signs[]
Definition format.h:891
T mod_inv
Definition format.h:862
T max_quotient
Definition format.h:863
static uint32_t compute_delta(cache_entry_type const &cache, int beta_minus_1) FMT_NOEXCEPT
static uint128_wrapper get_cached_power(int k) FMT_NOEXCEPT
static carrier_uint compute_right_endpoint_for_shorter_interval_case(const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
static carrier_uint compute_left_endpoint_for_shorter_interval_case(const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
static bool compute_mul_parity(carrier_uint two_f, const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
static carrier_uint compute_mul(carrier_uint u, const cache_entry_type &cache) FMT_NOEXCEPT
static carrier_uint compute_round_up_for_shorter_interval_case(const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
float_info< double >::carrier_uint carrier_uint
static uint32_t compute_delta(const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
static uint64_t get_cached_power(int k) 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
static carrier_uint compute_left_endpoint_for_shorter_interval_case(const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
static bool compute_mul_parity(carrier_uint two_f, const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
static carrier_uint compute_mul(carrier_uint u, const cache_entry_type &cache) FMT_NOEXCEPT
static carrier_uint compute_round_up_for_shorter_interval_case(const cache_entry_type &cache, int beta_minus_1) FMT_NOEXCEPT
significand_type significand
Definition format.h:1265
FMT_NORETURN FMT_API void on_error(const char *message)
unsigned char value[sizeof(void *)]
Definition format.h:299
digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder, uint64_t error, int, bool integral)
digits::result on_start(uint64_t divisor, uint64_t remainder, uint64_t error, int &exp)
float_format format
Definition format.h:1289
std::string operator()(basic_format_arg< format_context >::handle h) const
FMT_INLINE std::string operator()(T value) const
uint64_t high() const FMT_NOEXCEPT
Definition format.h:842
uint64_t low() const FMT_NOEXCEPT
Definition format.h:843
format_parse_context::iterator parse(format_parse_context &ctx)
format_context::iterator format(const detail::bigint &n, format_context &ctx)