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