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

plotjuggler
Author(s): Davide Faconti
autogenerated on Sun Dec 6 2020 03:47:34