« back to all changes in this revision
Viewing changes to src/cpp-common/vendor/fmt/format-inl.h
- browse files at revision 4648
- compare with another revision
- download diff
- download tarball
- view history from revision 4648
- Committer: Simon Marchi
- Author(s): Philippe Proulx
- Date: 2023-12-14 15:57:04 UTC
- Revision ID: git-v1:7f66516e9046d905f08f55575fe801d5646745d5
src/cpp-common: add {fmt} 10.1.1
This very famous library [1] should be useful to format all sorts of
strings in the future instead of using `std::string` or
`std::ostringstream`, as well as to implement a C++ logger.
We're building `format.cc` and `os.cc` which should speed up the rest of
the build and maybe reduce the build size (not using `FMT_HEADER_ONLY`).
Adding `.reuse/dep5` to provide licensing information for all the source
files in `src/cpp-common/vendor/fmt` without modifying the original
ones.
[1]: https://fmt.dev/
Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: I65cfbca05e5481847ce7183a2a2b20c25ae260ad
Reviewed-on: https://review.lttng.org/c/babeltrace/+/11387
Tested-by: jenkins <jenkins@lttng.org>
Reviewed-by: Simon Marchi <simon.marchi@efficios.com>
CI-Build: Simon Marchi <simon.marchi@efficios.com>
This very famous library [1] should be useful to format all sorts of
strings in the future instead of using `std::string` or
`std::ostringstream`, as well as to implement a C++ logger.
We're building `format.cc` and `os.cc` which should speed up the rest of
the build and maybe reduce the build size (not using `FMT_HEADER_ONLY`).
Adding `.reuse/dep5` to provide licensing information for all the source
files in `src/cpp-common/vendor/fmt` without modifying the original
ones.
[1]: https://fmt.dev/
Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: I65cfbca05e5481847ce7183a2a2b20c25ae260ad
Reviewed-on: https://review.lttng.org/c/babeltrace/+/11387
Tested-by: jenkins <jenkins@lttng.org>
Reviewed-by: Simon Marchi <simon.marchi@efficios.com>
CI-Build: Simon Marchi <simon.marchi@efficios.com>
- files added:
- .reuse
- src/cpp-common/vendor/fmt
- files modified:
- src/Makefile.am
added
removed
src/cpp-common/vendor/fmt/format-inl.h
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 <algorithm>
12
#include <cerrno> // errno
13
#include <climits>
14
#include <cmath>
15
#include <exception>
16
17
#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
18
# include <locale>
19
#endif
20
21
#ifdef _WIN32
22
# include <io.h> // _isatty
23
#endif
24
25
#include "format.h"
26
27
FMT_BEGIN_NAMESPACE
28
namespace detail {
29
30
FMT_FUNC void assert_fail(const char* file, int line, const char* message) {
31
// Use unchecked std::fprintf to avoid triggering another assertion when
32
// writing to stderr fails
33
std::fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message);
34
// Chosen instead of std::abort to satisfy Clang in CUDA mode during device
35
// code pass.
36
std::terminate();
37
}
38
39
FMT_FUNC void throw_format_error(const char* message) {
40
FMT_THROW(format_error(message));
41
}
42
43
FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code,
44
string_view message) noexcept {
45
// Report error code making sure that the output fits into
46
// inline_buffer_size to avoid dynamic memory allocation and potential
47
// bad_alloc.
48
out.try_resize(0);
49
static const char SEP[] = ": ";
50
static const char ERROR_STR[] = "error ";
51
// Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
52
size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
53
auto abs_value = static_cast<uint32_or_64_or_128_t<int>>(error_code);
54
if (detail::is_negative(error_code)) {
55
abs_value = 0 - abs_value;
56
++error_code_size;
57
}
58
error_code_size += detail::to_unsigned(detail::count_digits(abs_value));
59
auto it = buffer_appender<char>(out);
60
if (message.size() <= inline_buffer_size - error_code_size)
61
format_to(it, FMT_STRING("{}{}"), message, SEP);
62
format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code);
63
FMT_ASSERT(out.size() <= inline_buffer_size, "");
64
}
65
66
FMT_FUNC void report_error(format_func func, int error_code,
67
const char* message) noexcept {
68
memory_buffer full_message;
69
func(full_message, error_code, message);
70
// Don't use fwrite_fully because the latter may throw.
71
if (std::fwrite(full_message.data(), full_message.size(), 1, stderr) > 0)
72
std::fputc('\n', stderr);
73
}
74
75
// A wrapper around fwrite that throws on error.
76
inline void fwrite_fully(const void* ptr, size_t size, size_t count,
77
FILE* stream) {
78
size_t written = std::fwrite(ptr, size, count, stream);
79
if (written < count)
80
FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
81
}
82
83
#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
84
template <typename Locale>
85
locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
86
static_assert(std::is_same<Locale, std::locale>::value, "");
87
}
88
89
template <typename Locale> Locale locale_ref::get() const {
90
static_assert(std::is_same<Locale, std::locale>::value, "");
91
return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
92
}
93
94
template <typename Char>
95
FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char> {
96
auto& facet = std::use_facet<std::numpunct<Char>>(loc.get<std::locale>());
97
auto grouping = facet.grouping();
98
auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep();
99
return {std::move(grouping), thousands_sep};
100
}
101
template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref loc) {
102
return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
103
.decimal_point();
104
}
105
#else
106
template <typename Char>
107
FMT_FUNC auto thousands_sep_impl(locale_ref) -> thousands_sep_result<Char> {
108
return {"\03", FMT_STATIC_THOUSANDS_SEPARATOR};
109
}
110
template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref) {
111
return '.';
112
}
113
#endif
114
115
FMT_FUNC auto write_loc(appender out, loc_value value,
116
const format_specs<>& specs, locale_ref loc) -> bool {
117
#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
118
auto locale = loc.get<std::locale>();
119
// We cannot use the num_put<char> facet because it may produce output in
120
// a wrong encoding.
121
using facet = format_facet<std::locale>;
122
if (std::has_facet<facet>(locale))
123
return std::use_facet<facet>(locale).put(out, value, specs);
124
return facet(locale).put(out, value, specs);
125
#endif
126
return false;
127
}
128
} // namespace detail
129
130
template <typename Locale> typename Locale::id format_facet<Locale>::id;
131
132
#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
133
template <typename Locale> format_facet<Locale>::format_facet(Locale& loc) {
134
auto& numpunct = std::use_facet<std::numpunct<char>>(loc);
135
grouping_ = numpunct.grouping();
136
if (!grouping_.empty()) separator_ = std::string(1, numpunct.thousands_sep());
137
}
138
139
template <>
140
FMT_API FMT_FUNC auto format_facet<std::locale>::do_put(
141
appender out, loc_value val, const format_specs<>& specs) const -> bool {
142
return val.visit(
143
detail::loc_writer<>{out, specs, separator_, grouping_, decimal_point_});
144
}
145
#endif
146
147
FMT_FUNC std::system_error vsystem_error(int error_code, string_view fmt,
148
format_args args) {
149
auto ec = std::error_code(error_code, std::generic_category());
150
return std::system_error(ec, vformat(fmt, args));
151
}
152
153
namespace detail {
154
155
template <typename F> inline bool operator==(basic_fp<F> x, basic_fp<F> y) {
156
return x.f == y.f && x.e == y.e;
157
}
158
159
// Compilers should be able to optimize this into the ror instruction.
160
FMT_CONSTEXPR inline uint32_t rotr(uint32_t n, uint32_t r) noexcept {
161
r &= 31;
162
return (n >> r) | (n << (32 - r));
163
}
164
FMT_CONSTEXPR inline uint64_t rotr(uint64_t n, uint32_t r) noexcept {
165
r &= 63;
166
return (n >> r) | (n << (64 - r));
167
}
168
169
// Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox.
170
namespace dragonbox {
171
// Computes upper 64 bits of multiplication of a 32-bit unsigned integer and a
172
// 64-bit unsigned integer.
173
inline uint64_t umul96_upper64(uint32_t x, uint64_t y) noexcept {
174
return umul128_upper64(static_cast<uint64_t>(x) << 32, y);
175
}
176
177
// Computes lower 128 bits of multiplication of a 64-bit unsigned integer and a
178
// 128-bit unsigned integer.
179
inline uint128_fallback umul192_lower128(uint64_t x,
180
uint128_fallback y) noexcept {
181
uint64_t high = x * y.high();
182
uint128_fallback high_low = umul128(x, y.low());
183
return {high + high_low.high(), high_low.low()};
184
}
185
186
// Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a
187
// 64-bit unsigned integer.
188
inline uint64_t umul96_lower64(uint32_t x, uint64_t y) noexcept {
189
return x * y;
190
}
191
192
// Various fast log computations.
193
inline int floor_log10_pow2_minus_log10_4_over_3(int e) noexcept {
194
FMT_ASSERT(e <= 2936 && e >= -2985, "too large exponent");
195
return (e * 631305 - 261663) >> 21;
196
}
197
198
FMT_INLINE_VARIABLE constexpr struct {
199
uint32_t divisor;
200
int shift_amount;
201
} div_small_pow10_infos[] = {{10, 16}, {100, 16}};
202
203
// Replaces n by floor(n / pow(10, N)) returning true if and only if n is
204
// divisible by pow(10, N).
205
// Precondition: n <= pow(10, N + 1).
206
template <int N>
207
bool check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept {
208
// The numbers below are chosen such that:
209
// 1. floor(n/d) = floor(nm / 2^k) where d=10 or d=100,
210
// 2. nm mod 2^k < m if and only if n is divisible by d,
211
// where m is magic_number, k is shift_amount
212
// and d is divisor.
213
//
214
// Item 1 is a common technique of replacing division by a constant with
215
// multiplication, see e.g. "Division by Invariant Integers Using
216
// Multiplication" by Granlund and Montgomery (1994). magic_number (m) is set
217
// to ceil(2^k/d) for large enough k.
218
// The idea for item 2 originates from Schubfach.
219
constexpr auto info = div_small_pow10_infos[N - 1];
220
FMT_ASSERT(n <= info.divisor * 10, "n is too large");
221
constexpr uint32_t magic_number =
222
(1u << info.shift_amount) / info.divisor + 1;
223
n *= magic_number;
224
const uint32_t comparison_mask = (1u << info.shift_amount) - 1;
225
bool result = (n & comparison_mask) < magic_number;
226
n >>= info.shift_amount;
227
return result;
228
}
229
230
// Computes floor(n / pow(10, N)) for small n and N.
231
// Precondition: n <= pow(10, N + 1).
232
template <int N> uint32_t small_division_by_pow10(uint32_t n) noexcept {
233
constexpr auto info = div_small_pow10_infos[N - 1];
234
FMT_ASSERT(n <= info.divisor * 10, "n is too large");
235
constexpr uint32_t magic_number =
236
(1u << info.shift_amount) / info.divisor + 1;
237
return (n * magic_number) >> info.shift_amount;
238
}
239
240
// Computes floor(n / 10^(kappa + 1)) (float)
241
inline uint32_t divide_by_10_to_kappa_plus_1(uint32_t n) noexcept {
242
// 1374389535 = ceil(2^37/100)
243
return static_cast<uint32_t>((static_cast<uint64_t>(n) * 1374389535) >> 37);
244
}
245
// Computes floor(n / 10^(kappa + 1)) (double)
246
inline uint64_t divide_by_10_to_kappa_plus_1(uint64_t n) noexcept {
247
// 2361183241434822607 = ceil(2^(64+7)/1000)
248
return umul128_upper64(n, 2361183241434822607ull) >> 7;
249
}
250
251
// Various subroutines using pow10 cache
252
template <typename T> struct cache_accessor;
253
254
template <> struct cache_accessor<float> {
255
using carrier_uint = float_info<float>::carrier_uint;
256
using cache_entry_type = uint64_t;
257
258
static uint64_t get_cached_power(int k) noexcept {
259
FMT_ASSERT(k >= float_info<float>::min_k && k <= float_info<float>::max_k,
260
"k is out of range");
261
static constexpr const uint64_t pow10_significands[] = {
262
0x81ceb32c4b43fcf5, 0xa2425ff75e14fc32, 0xcad2f7f5359a3b3f,
263
0xfd87b5f28300ca0e, 0x9e74d1b791e07e49, 0xc612062576589ddb,
264
0xf79687aed3eec552, 0x9abe14cd44753b53, 0xc16d9a0095928a28,
265
0xf1c90080baf72cb2, 0x971da05074da7bef, 0xbce5086492111aeb,
266
0xec1e4a7db69561a6, 0x9392ee8e921d5d08, 0xb877aa3236a4b44a,
267
0xe69594bec44de15c, 0x901d7cf73ab0acda, 0xb424dc35095cd810,
268
0xe12e13424bb40e14, 0x8cbccc096f5088cc, 0xafebff0bcb24aaff,
269
0xdbe6fecebdedd5bf, 0x89705f4136b4a598, 0xabcc77118461cefd,
270
0xd6bf94d5e57a42bd, 0x8637bd05af6c69b6, 0xa7c5ac471b478424,
271
0xd1b71758e219652c, 0x83126e978d4fdf3c, 0xa3d70a3d70a3d70b,
272
0xcccccccccccccccd, 0x8000000000000000, 0xa000000000000000,
273
0xc800000000000000, 0xfa00000000000000, 0x9c40000000000000,
274
0xc350000000000000, 0xf424000000000000, 0x9896800000000000,
275
0xbebc200000000000, 0xee6b280000000000, 0x9502f90000000000,
276
0xba43b74000000000, 0xe8d4a51000000000, 0x9184e72a00000000,
277
0xb5e620f480000000, 0xe35fa931a0000000, 0x8e1bc9bf04000000,
278
0xb1a2bc2ec5000000, 0xde0b6b3a76400000, 0x8ac7230489e80000,
279
0xad78ebc5ac620000, 0xd8d726b7177a8000, 0x878678326eac9000,
280
0xa968163f0a57b400, 0xd3c21bcecceda100, 0x84595161401484a0,
281
0xa56fa5b99019a5c8, 0xcecb8f27f4200f3a, 0x813f3978f8940985,
282
0xa18f07d736b90be6, 0xc9f2c9cd04674edf, 0xfc6f7c4045812297,
283
0x9dc5ada82b70b59e, 0xc5371912364ce306, 0xf684df56c3e01bc7,
284
0x9a130b963a6c115d, 0xc097ce7bc90715b4, 0xf0bdc21abb48db21,
285
0x96769950b50d88f5, 0xbc143fa4e250eb32, 0xeb194f8e1ae525fe,
286
0x92efd1b8d0cf37bf, 0xb7abc627050305ae, 0xe596b7b0c643c71a,
287
0x8f7e32ce7bea5c70, 0xb35dbf821ae4f38c, 0xe0352f62a19e306f};
288
return pow10_significands[k - float_info<float>::min_k];
289
}
290
291
struct compute_mul_result {
292
carrier_uint result;
293
bool is_integer;
294
};
295
struct compute_mul_parity_result {
296
bool parity;
297
bool is_integer;
298
};
299
300
static compute_mul_result compute_mul(
301
carrier_uint u, const cache_entry_type& cache) noexcept {
302
auto r = umul96_upper64(u, cache);
303
return {static_cast<carrier_uint>(r >> 32),
304
static_cast<carrier_uint>(r) == 0};
305
}
306
307
static uint32_t compute_delta(const cache_entry_type& cache,
308
int beta) noexcept {
309
return static_cast<uint32_t>(cache >> (64 - 1 - beta));
310
}
311
312
static compute_mul_parity_result compute_mul_parity(
313
carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept {
314
FMT_ASSERT(beta >= 1, "");
315
FMT_ASSERT(beta < 64, "");
316
317
auto r = umul96_lower64(two_f, cache);
318
return {((r >> (64 - beta)) & 1) != 0,
319
static_cast<uint32_t>(r >> (32 - beta)) == 0};
320
}
321
322
static carrier_uint compute_left_endpoint_for_shorter_interval_case(
323
const cache_entry_type& cache, int beta) noexcept {
324
return static_cast<carrier_uint>(
325
(cache - (cache >> (num_significand_bits<float>() + 2))) >>
326
(64 - num_significand_bits<float>() - 1 - beta));
327
}
328
329
static carrier_uint compute_right_endpoint_for_shorter_interval_case(
330
const cache_entry_type& cache, int beta) noexcept {
331
return static_cast<carrier_uint>(
332
(cache + (cache >> (num_significand_bits<float>() + 1))) >>
333
(64 - num_significand_bits<float>() - 1 - beta));
334
}
335
336
static carrier_uint compute_round_up_for_shorter_interval_case(
337
const cache_entry_type& cache, int beta) noexcept {
338
return (static_cast<carrier_uint>(
339
cache >> (64 - num_significand_bits<float>() - 2 - beta)) +
340
1) /
341
2;
342
}
343
};
344
345
template <> struct cache_accessor<double> {
346
using carrier_uint = float_info<double>::carrier_uint;
347
using cache_entry_type = uint128_fallback;
348
349
static uint128_fallback get_cached_power(int k) noexcept {
350
FMT_ASSERT(k >= float_info<double>::min_k && k <= float_info<double>::max_k,
351
"k is out of range");
352
353
static constexpr const uint128_fallback pow10_significands[] = {
354
#if FMT_USE_FULL_CACHE_DRAGONBOX
355
{0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
356
{0x9faacf3df73609b1, 0x77b191618c54e9ad},
357
{0xc795830d75038c1d, 0xd59df5b9ef6a2418},
358
{0xf97ae3d0d2446f25, 0x4b0573286b44ad1e},
359
{0x9becce62836ac577, 0x4ee367f9430aec33},
360
{0xc2e801fb244576d5, 0x229c41f793cda740},
361
{0xf3a20279ed56d48a, 0x6b43527578c11110},
362
{0x9845418c345644d6, 0x830a13896b78aaaa},
363
{0xbe5691ef416bd60c, 0x23cc986bc656d554},
364
{0xedec366b11c6cb8f, 0x2cbfbe86b7ec8aa9},
365
{0x94b3a202eb1c3f39, 0x7bf7d71432f3d6aa},
366
{0xb9e08a83a5e34f07, 0xdaf5ccd93fb0cc54},
367
{0xe858ad248f5c22c9, 0xd1b3400f8f9cff69},
368
{0x91376c36d99995be, 0x23100809b9c21fa2},
369
{0xb58547448ffffb2d, 0xabd40a0c2832a78b},
370
{0xe2e69915b3fff9f9, 0x16c90c8f323f516d},
371
{0x8dd01fad907ffc3b, 0xae3da7d97f6792e4},
372
{0xb1442798f49ffb4a, 0x99cd11cfdf41779d},
373
{0xdd95317f31c7fa1d, 0x40405643d711d584},
374
{0x8a7d3eef7f1cfc52, 0x482835ea666b2573},
375
{0xad1c8eab5ee43b66, 0xda3243650005eed0},
376
{0xd863b256369d4a40, 0x90bed43e40076a83},
377
{0x873e4f75e2224e68, 0x5a7744a6e804a292},
378
{0xa90de3535aaae202, 0x711515d0a205cb37},
379
{0xd3515c2831559a83, 0x0d5a5b44ca873e04},
380
{0x8412d9991ed58091, 0xe858790afe9486c3},
381
{0xa5178fff668ae0b6, 0x626e974dbe39a873},
382
{0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
383
{0x80fa687f881c7f8e, 0x7ce66634bc9d0b9a},
384
{0xa139029f6a239f72, 0x1c1fffc1ebc44e81},
385
{0xc987434744ac874e, 0xa327ffb266b56221},
386
{0xfbe9141915d7a922, 0x4bf1ff9f0062baa9},
387
{0x9d71ac8fada6c9b5, 0x6f773fc3603db4aa},
388
{0xc4ce17b399107c22, 0xcb550fb4384d21d4},
389
{0xf6019da07f549b2b, 0x7e2a53a146606a49},
390
{0x99c102844f94e0fb, 0x2eda7444cbfc426e},
391
{0xc0314325637a1939, 0xfa911155fefb5309},
392
{0xf03d93eebc589f88, 0x793555ab7eba27cb},
393
{0x96267c7535b763b5, 0x4bc1558b2f3458df},
394
{0xbbb01b9283253ca2, 0x9eb1aaedfb016f17},
395
{0xea9c227723ee8bcb, 0x465e15a979c1cadd},
396
{0x92a1958a7675175f, 0x0bfacd89ec191eca},
397
{0xb749faed14125d36, 0xcef980ec671f667c},
398
{0xe51c79a85916f484, 0x82b7e12780e7401b},
399
{0x8f31cc0937ae58d2, 0xd1b2ecb8b0908811},
400
{0xb2fe3f0b8599ef07, 0x861fa7e6dcb4aa16},
401
{0xdfbdcece67006ac9, 0x67a791e093e1d49b},
402
{0x8bd6a141006042bd, 0xe0c8bb2c5c6d24e1},
403
{0xaecc49914078536d, 0x58fae9f773886e19},
404
{0xda7f5bf590966848, 0xaf39a475506a899f},
405
{0x888f99797a5e012d, 0x6d8406c952429604},
406
{0xaab37fd7d8f58178, 0xc8e5087ba6d33b84},
407
{0xd5605fcdcf32e1d6, 0xfb1e4a9a90880a65},
408
{0x855c3be0a17fcd26, 0x5cf2eea09a550680},
409
{0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},
410
{0xd0601d8efc57b08b, 0xf13b94daf124da27},
411
{0x823c12795db6ce57, 0x76c53d08d6b70859},
412
{0xa2cb1717b52481ed, 0x54768c4b0c64ca6f},
413
{0xcb7ddcdda26da268, 0xa9942f5dcf7dfd0a},
414
{0xfe5d54150b090b02, 0xd3f93b35435d7c4d},
415
{0x9efa548d26e5a6e1, 0xc47bc5014a1a6db0},
416
{0xc6b8e9b0709f109a, 0x359ab6419ca1091c},
417
{0xf867241c8cc6d4c0, 0xc30163d203c94b63},
418
{0x9b407691d7fc44f8, 0x79e0de63425dcf1e},
419
{0xc21094364dfb5636, 0x985915fc12f542e5},
420
{0xf294b943e17a2bc4, 0x3e6f5b7b17b2939e},
421
{0x979cf3ca6cec5b5a, 0xa705992ceecf9c43},
422
{0xbd8430bd08277231, 0x50c6ff782a838354},
423
{0xece53cec4a314ebd, 0xa4f8bf5635246429},
424
{0x940f4613ae5ed136, 0x871b7795e136be9a},
425
{0xb913179899f68584, 0x28e2557b59846e40},
426
{0xe757dd7ec07426e5, 0x331aeada2fe589d0},
427
{0x9096ea6f3848984f, 0x3ff0d2c85def7622},
428
{0xb4bca50b065abe63, 0x0fed077a756b53aa},
429
{0xe1ebce4dc7f16dfb, 0xd3e8495912c62895},
430
{0x8d3360f09cf6e4bd, 0x64712dd7abbbd95d},
431
{0xb080392cc4349dec, 0xbd8d794d96aacfb4},
432
{0xdca04777f541c567, 0xecf0d7a0fc5583a1},
433
{0x89e42caaf9491b60, 0xf41686c49db57245},
434
{0xac5d37d5b79b6239, 0x311c2875c522ced6},
435
{0xd77485cb25823ac7, 0x7d633293366b828c},
436
{0x86a8d39ef77164bc, 0xae5dff9c02033198},
437
{0xa8530886b54dbdeb, 0xd9f57f830283fdfd},
438
{0xd267caa862a12d66, 0xd072df63c324fd7c},
439
{0x8380dea93da4bc60, 0x4247cb9e59f71e6e},
440
{0xa46116538d0deb78, 0x52d9be85f074e609},
441
{0xcd795be870516656, 0x67902e276c921f8c},
442
{0x806bd9714632dff6, 0x00ba1cd8a3db53b7},
443
{0xa086cfcd97bf97f3, 0x80e8a40eccd228a5},
444
{0xc8a883c0fdaf7df0, 0x6122cd128006b2ce},
445
{0xfad2a4b13d1b5d6c, 0x796b805720085f82},
446
{0x9cc3a6eec6311a63, 0xcbe3303674053bb1},
447
{0xc3f490aa77bd60fc, 0xbedbfc4411068a9d},
448
{0xf4f1b4d515acb93b, 0xee92fb5515482d45},
449
{0x991711052d8bf3c5, 0x751bdd152d4d1c4b},
450
{0xbf5cd54678eef0b6, 0xd262d45a78a0635e},
451
{0xef340a98172aace4, 0x86fb897116c87c35},
452
{0x9580869f0e7aac0e, 0xd45d35e6ae3d4da1},
453
{0xbae0a846d2195712, 0x8974836059cca10a},
454
{0xe998d258869facd7, 0x2bd1a438703fc94c},
455
{0x91ff83775423cc06, 0x7b6306a34627ddd0},
456
{0xb67f6455292cbf08, 0x1a3bc84c17b1d543},
457
{0xe41f3d6a7377eeca, 0x20caba5f1d9e4a94},
458
{0x8e938662882af53e, 0x547eb47b7282ee9d},
459
{0xb23867fb2a35b28d, 0xe99e619a4f23aa44},
460
{0xdec681f9f4c31f31, 0x6405fa00e2ec94d5},
461
{0x8b3c113c38f9f37e, 0xde83bc408dd3dd05},
462
{0xae0b158b4738705e, 0x9624ab50b148d446},
463
{0xd98ddaee19068c76, 0x3badd624dd9b0958},
464
{0x87f8a8d4cfa417c9, 0xe54ca5d70a80e5d7},
465
{0xa9f6d30a038d1dbc, 0x5e9fcf4ccd211f4d},
466
{0xd47487cc8470652b, 0x7647c32000696720},
467
{0x84c8d4dfd2c63f3b, 0x29ecd9f40041e074},
468
{0xa5fb0a17c777cf09, 0xf468107100525891},
469
{0xcf79cc9db955c2cc, 0x7182148d4066eeb5},
470
{0x81ac1fe293d599bf, 0xc6f14cd848405531},
471
{0xa21727db38cb002f, 0xb8ada00e5a506a7d},
472
{0xca9cf1d206fdc03b, 0xa6d90811f0e4851d},
473
{0xfd442e4688bd304a, 0x908f4a166d1da664},
474
{0x9e4a9cec15763e2e, 0x9a598e4e043287ff},
475
{0xc5dd44271ad3cdba, 0x40eff1e1853f29fe},
476
{0xf7549530e188c128, 0xd12bee59e68ef47d},
477
{0x9a94dd3e8cf578b9, 0x82bb74f8301958cf},
478
{0xc13a148e3032d6e7, 0xe36a52363c1faf02},
479
{0xf18899b1bc3f8ca1, 0xdc44e6c3cb279ac2},
480
{0x96f5600f15a7b7e5, 0x29ab103a5ef8c0ba},
481
{0xbcb2b812db11a5de, 0x7415d448f6b6f0e8},
482
{0xebdf661791d60f56, 0x111b495b3464ad22},
483
{0x936b9fcebb25c995, 0xcab10dd900beec35},
484
{0xb84687c269ef3bfb, 0x3d5d514f40eea743},
485
{0xe65829b3046b0afa, 0x0cb4a5a3112a5113},
486
{0x8ff71a0fe2c2e6dc, 0x47f0e785eaba72ac},
487
{0xb3f4e093db73a093, 0x59ed216765690f57},
488
{0xe0f218b8d25088b8, 0x306869c13ec3532d},
489
{0x8c974f7383725573, 0x1e414218c73a13fc},
490
{0xafbd2350644eeacf, 0xe5d1929ef90898fb},
491
{0xdbac6c247d62a583, 0xdf45f746b74abf3a},
492
{0x894bc396ce5da772, 0x6b8bba8c328eb784},
493
{0xab9eb47c81f5114f, 0x066ea92f3f326565},
494
{0xd686619ba27255a2, 0xc80a537b0efefebe},
495
{0x8613fd0145877585, 0xbd06742ce95f5f37},
496
{0xa798fc4196e952e7, 0x2c48113823b73705},
497
{0xd17f3b51fca3a7a0, 0xf75a15862ca504c6},
498
{0x82ef85133de648c4, 0x9a984d73dbe722fc},
499
{0xa3ab66580d5fdaf5, 0xc13e60d0d2e0ebbb},
500
{0xcc963fee10b7d1b3, 0x318df905079926a9},
501
{0xffbbcfe994e5c61f, 0xfdf17746497f7053},
502
{0x9fd561f1fd0f9bd3, 0xfeb6ea8bedefa634},
503
{0xc7caba6e7c5382c8, 0xfe64a52ee96b8fc1},
504
{0xf9bd690a1b68637b, 0x3dfdce7aa3c673b1},
505
{0x9c1661a651213e2d, 0x06bea10ca65c084f},
506
{0xc31bfa0fe5698db8, 0x486e494fcff30a63},
507
{0xf3e2f893dec3f126, 0x5a89dba3c3efccfb},
508
{0x986ddb5c6b3a76b7, 0xf89629465a75e01d},
509
{0xbe89523386091465, 0xf6bbb397f1135824},
510
{0xee2ba6c0678b597f, 0x746aa07ded582e2d},
511
{0x94db483840b717ef, 0xa8c2a44eb4571cdd},
512
{0xba121a4650e4ddeb, 0x92f34d62616ce414},
513
{0xe896a0d7e51e1566, 0x77b020baf9c81d18},
514
{0x915e2486ef32cd60, 0x0ace1474dc1d122f},
515
{0xb5b5ada8aaff80b8, 0x0d819992132456bb},
516
{0xe3231912d5bf60e6, 0x10e1fff697ed6c6a},
517
{0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},
518
{0xb1736b96b6fd83b3, 0xbd308ff8a6b17cb3},
519
{0xddd0467c64bce4a0, 0xac7cb3f6d05ddbdf},
520
{0x8aa22c0dbef60ee4, 0x6bcdf07a423aa96c},
521
{0xad4ab7112eb3929d, 0x86c16c98d2c953c7},
522
{0xd89d64d57a607744, 0xe871c7bf077ba8b8},
523
{0x87625f056c7c4a8b, 0x11471cd764ad4973},
524
{0xa93af6c6c79b5d2d, 0xd598e40d3dd89bd0},
525
{0xd389b47879823479, 0x4aff1d108d4ec2c4},
526
{0x843610cb4bf160cb, 0xcedf722a585139bb},
527
{0xa54394fe1eedb8fe, 0xc2974eb4ee658829},
528
{0xce947a3da6a9273e, 0x733d226229feea33},
529
{0x811ccc668829b887, 0x0806357d5a3f5260},
530
{0xa163ff802a3426a8, 0xca07c2dcb0cf26f8},
531
{0xc9bcff6034c13052, 0xfc89b393dd02f0b6},
532
{0xfc2c3f3841f17c67, 0xbbac2078d443ace3},
533
{0x9d9ba7832936edc0, 0xd54b944b84aa4c0e},
534
{0xc5029163f384a931, 0x0a9e795e65d4df12},
535
{0xf64335bcf065d37d, 0x4d4617b5ff4a16d6},
536
{0x99ea0196163fa42e, 0x504bced1bf8e4e46},
537
{0xc06481fb9bcf8d39, 0xe45ec2862f71e1d7},
538
{0xf07da27a82c37088, 0x5d767327bb4e5a4d},
539
{0x964e858c91ba2655, 0x3a6a07f8d510f870},
540
{0xbbe226efb628afea, 0x890489f70a55368c},
541
{0xeadab0aba3b2dbe5, 0x2b45ac74ccea842f},
542
{0x92c8ae6b464fc96f, 0x3b0b8bc90012929e},
543
{0xb77ada0617e3bbcb, 0x09ce6ebb40173745},
544
{0xe55990879ddcaabd, 0xcc420a6a101d0516},
545
{0x8f57fa54c2a9eab6, 0x9fa946824a12232e},
546
{0xb32df8e9f3546564, 0x47939822dc96abfa},
547
{0xdff9772470297ebd, 0x59787e2b93bc56f8},
548
{0x8bfbea76c619ef36, 0x57eb4edb3c55b65b},
549
{0xaefae51477a06b03, 0xede622920b6b23f2},
550
{0xdab99e59958885c4, 0xe95fab368e45ecee},
551
{0x88b402f7fd75539b, 0x11dbcb0218ebb415},
552
{0xaae103b5fcd2a881, 0xd652bdc29f26a11a},
553
{0xd59944a37c0752a2, 0x4be76d3346f04960},
554
{0x857fcae62d8493a5, 0x6f70a4400c562ddc},
555
{0xa6dfbd9fb8e5b88e, 0xcb4ccd500f6bb953},
556
{0xd097ad07a71f26b2, 0x7e2000a41346a7a8},
557
{0x825ecc24c873782f, 0x8ed400668c0c28c9},
558
{0xa2f67f2dfa90563b, 0x728900802f0f32fb},
559
{0xcbb41ef979346bca, 0x4f2b40a03ad2ffba},
560
{0xfea126b7d78186bc, 0xe2f610c84987bfa9},
561
{0x9f24b832e6b0f436, 0x0dd9ca7d2df4d7ca},
562
{0xc6ede63fa05d3143, 0x91503d1c79720dbc},
563
{0xf8a95fcf88747d94, 0x75a44c6397ce912b},
564
{0x9b69dbe1b548ce7c, 0xc986afbe3ee11abb},
565
{0xc24452da229b021b, 0xfbe85badce996169},
566
{0xf2d56790ab41c2a2, 0xfae27299423fb9c4},
567
{0x97c560ba6b0919a5, 0xdccd879fc967d41b},
568
{0xbdb6b8e905cb600f, 0x5400e987bbc1c921},
569
{0xed246723473e3813, 0x290123e9aab23b69},
570
{0x9436c0760c86e30b, 0xf9a0b6720aaf6522},
571
{0xb94470938fa89bce, 0xf808e40e8d5b3e6a},
572
{0xe7958cb87392c2c2, 0xb60b1d1230b20e05},
573
{0x90bd77f3483bb9b9, 0xb1c6f22b5e6f48c3},
574
{0xb4ecd5f01a4aa828, 0x1e38aeb6360b1af4},
575
{0xe2280b6c20dd5232, 0x25c6da63c38de1b1},
576
{0x8d590723948a535f, 0x579c487e5a38ad0f},
577
{0xb0af48ec79ace837, 0x2d835a9df0c6d852},
578
{0xdcdb1b2798182244, 0xf8e431456cf88e66},
579
{0x8a08f0f8bf0f156b, 0x1b8e9ecb641b5900},
580
{0xac8b2d36eed2dac5, 0xe272467e3d222f40},
581
{0xd7adf884aa879177, 0x5b0ed81dcc6abb10},
582
{0x86ccbb52ea94baea, 0x98e947129fc2b4ea},
583
{0xa87fea27a539e9a5, 0x3f2398d747b36225},
584
{0xd29fe4b18e88640e, 0x8eec7f0d19a03aae},
585
{0x83a3eeeef9153e89, 0x1953cf68300424ad},
586
{0xa48ceaaab75a8e2b, 0x5fa8c3423c052dd8},
587
{0xcdb02555653131b6, 0x3792f412cb06794e},
588
{0x808e17555f3ebf11, 0xe2bbd88bbee40bd1},
589
{0xa0b19d2ab70e6ed6, 0x5b6aceaeae9d0ec5},
590
{0xc8de047564d20a8b, 0xf245825a5a445276},
591
{0xfb158592be068d2e, 0xeed6e2f0f0d56713},
592
{0x9ced737bb6c4183d, 0x55464dd69685606c},
593
{0xc428d05aa4751e4c, 0xaa97e14c3c26b887},
594
{0xf53304714d9265df, 0xd53dd99f4b3066a9},
595
{0x993fe2c6d07b7fab, 0xe546a8038efe402a},
596
{0xbf8fdb78849a5f96, 0xde98520472bdd034},
597
{0xef73d256a5c0f77c, 0x963e66858f6d4441},
598
{0x95a8637627989aad, 0xdde7001379a44aa9},
599
{0xbb127c53b17ec159, 0x5560c018580d5d53},
600
{0xe9d71b689dde71af, 0xaab8f01e6e10b4a7},
601
{0x9226712162ab070d, 0xcab3961304ca70e9},
602
{0xb6b00d69bb55c8d1, 0x3d607b97c5fd0d23},
603
{0xe45c10c42a2b3b05, 0x8cb89a7db77c506b},
604
{0x8eb98a7a9a5b04e3, 0x77f3608e92adb243},
605
{0xb267ed1940f1c61c, 0x55f038b237591ed4},
606
{0xdf01e85f912e37a3, 0x6b6c46dec52f6689},
607
{0x8b61313bbabce2c6, 0x2323ac4b3b3da016},
608
{0xae397d8aa96c1b77, 0xabec975e0a0d081b},
609
{0xd9c7dced53c72255, 0x96e7bd358c904a22},
610
{0x881cea14545c7575, 0x7e50d64177da2e55},
611
{0xaa242499697392d2, 0xdde50bd1d5d0b9ea},
612
{0xd4ad2dbfc3d07787, 0x955e4ec64b44e865},
613
{0x84ec3c97da624ab4, 0xbd5af13bef0b113f},
614
{0xa6274bbdd0fadd61, 0xecb1ad8aeacdd58f},
615
{0xcfb11ead453994ba, 0x67de18eda5814af3},
616
{0x81ceb32c4b43fcf4, 0x80eacf948770ced8},
617
{0xa2425ff75e14fc31, 0xa1258379a94d028e},
618
{0xcad2f7f5359a3b3e, 0x096ee45813a04331},
619
{0xfd87b5f28300ca0d, 0x8bca9d6e188853fd},
620
{0x9e74d1b791e07e48, 0x775ea264cf55347e},
621
{0xc612062576589dda, 0x95364afe032a819e},
622
{0xf79687aed3eec551, 0x3a83ddbd83f52205},
623
{0x9abe14cd44753b52, 0xc4926a9672793543},
624
{0xc16d9a0095928a27, 0x75b7053c0f178294},
625
{0xf1c90080baf72cb1, 0x5324c68b12dd6339},
626
{0x971da05074da7bee, 0xd3f6fc16ebca5e04},
627
{0xbce5086492111aea, 0x88f4bb1ca6bcf585},
628
{0xec1e4a7db69561a5, 0x2b31e9e3d06c32e6},
629
{0x9392ee8e921d5d07, 0x3aff322e62439fd0},
630
{0xb877aa3236a4b449, 0x09befeb9fad487c3},
631
{0xe69594bec44de15b, 0x4c2ebe687989a9b4},
632
{0x901d7cf73ab0acd9, 0x0f9d37014bf60a11},
633
{0xb424dc35095cd80f, 0x538484c19ef38c95},
634
{0xe12e13424bb40e13, 0x2865a5f206b06fba},
635
{0x8cbccc096f5088cb, 0xf93f87b7442e45d4},
636
{0xafebff0bcb24aafe, 0xf78f69a51539d749},
637
{0xdbe6fecebdedd5be, 0xb573440e5a884d1c},
638
{0x89705f4136b4a597, 0x31680a88f8953031},
639
{0xabcc77118461cefc, 0xfdc20d2b36ba7c3e},
640
{0xd6bf94d5e57a42bc, 0x3d32907604691b4d},
641
{0x8637bd05af6c69b5, 0xa63f9a49c2c1b110},
642
{0xa7c5ac471b478423, 0x0fcf80dc33721d54},
643
{0xd1b71758e219652b, 0xd3c36113404ea4a9},
644
{0x83126e978d4fdf3b, 0x645a1cac083126ea},
645
{0xa3d70a3d70a3d70a, 0x3d70a3d70a3d70a4},
646
{0xcccccccccccccccc, 0xcccccccccccccccd},
647
{0x8000000000000000, 0x0000000000000000},
648
{0xa000000000000000, 0x0000000000000000},
649
{0xc800000000000000, 0x0000000000000000},
650
{0xfa00000000000000, 0x0000000000000000},
651
{0x9c40000000000000, 0x0000000000000000},
652
{0xc350000000000000, 0x0000000000000000},
653
{0xf424000000000000, 0x0000000000000000},
654
{0x9896800000000000, 0x0000000000000000},
655
{0xbebc200000000000, 0x0000000000000000},
656
{0xee6b280000000000, 0x0000000000000000},
657
{0x9502f90000000000, 0x0000000000000000},
658
{0xba43b74000000000, 0x0000000000000000},
659
{0xe8d4a51000000000, 0x0000000000000000},
660
{0x9184e72a00000000, 0x0000000000000000},
661
{0xb5e620f480000000, 0x0000000000000000},
662
{0xe35fa931a0000000, 0x0000000000000000},
663
{0x8e1bc9bf04000000, 0x0000000000000000},
664
{0xb1a2bc2ec5000000, 0x0000000000000000},
665
{0xde0b6b3a76400000, 0x0000000000000000},
666
{0x8ac7230489e80000, 0x0000000000000000},
667
{0xad78ebc5ac620000, 0x0000000000000000},
668
{0xd8d726b7177a8000, 0x0000000000000000},
669
{0x878678326eac9000, 0x0000000000000000},
670
{0xa968163f0a57b400, 0x0000000000000000},
671
{0xd3c21bcecceda100, 0x0000000000000000},
672
{0x84595161401484a0, 0x0000000000000000},
673
{0xa56fa5b99019a5c8, 0x0000000000000000},
674
{0xcecb8f27f4200f3a, 0x0000000000000000},
675
{0x813f3978f8940984, 0x4000000000000000},
676
{0xa18f07d736b90be5, 0x5000000000000000},
677
{0xc9f2c9cd04674ede, 0xa400000000000000},
678
{0xfc6f7c4045812296, 0x4d00000000000000},
679
{0x9dc5ada82b70b59d, 0xf020000000000000},
680
{0xc5371912364ce305, 0x6c28000000000000},
681
{0xf684df56c3e01bc6, 0xc732000000000000},
682
{0x9a130b963a6c115c, 0x3c7f400000000000},
683
{0xc097ce7bc90715b3, 0x4b9f100000000000},
684
{0xf0bdc21abb48db20, 0x1e86d40000000000},
685
{0x96769950b50d88f4, 0x1314448000000000},
686
{0xbc143fa4e250eb31, 0x17d955a000000000},
687
{0xeb194f8e1ae525fd, 0x5dcfab0800000000},
688
{0x92efd1b8d0cf37be, 0x5aa1cae500000000},
689
{0xb7abc627050305ad, 0xf14a3d9e40000000},
690
{0xe596b7b0c643c719, 0x6d9ccd05d0000000},
691
{0x8f7e32ce7bea5c6f, 0xe4820023a2000000},
692
{0xb35dbf821ae4f38b, 0xdda2802c8a800000},
693
{0xe0352f62a19e306e, 0xd50b2037ad200000},
694
{0x8c213d9da502de45, 0x4526f422cc340000},
695
{0xaf298d050e4395d6, 0x9670b12b7f410000},
696
{0xdaf3f04651d47b4c, 0x3c0cdd765f114000},
697
{0x88d8762bf324cd0f, 0xa5880a69fb6ac800},
698
{0xab0e93b6efee0053, 0x8eea0d047a457a00},
699
{0xd5d238a4abe98068, 0x72a4904598d6d880},
700
{0x85a36366eb71f041, 0x47a6da2b7f864750},
701
{0xa70c3c40a64e6c51, 0x999090b65f67d924},
702
{0xd0cf4b50cfe20765, 0xfff4b4e3f741cf6d},
703
{0x82818f1281ed449f, 0xbff8f10e7a8921a5},
704
{0xa321f2d7226895c7, 0xaff72d52192b6a0e},
705
{0xcbea6f8ceb02bb39, 0x9bf4f8a69f764491},
706
{0xfee50b7025c36a08, 0x02f236d04753d5b5},
707
{0x9f4f2726179a2245, 0x01d762422c946591},
708
{0xc722f0ef9d80aad6, 0x424d3ad2b7b97ef6},
709
{0xf8ebad2b84e0d58b, 0xd2e0898765a7deb3},
710
{0x9b934c3b330c8577, 0x63cc55f49f88eb30},
711
{0xc2781f49ffcfa6d5, 0x3cbf6b71c76b25fc},
712
{0xf316271c7fc3908a, 0x8bef464e3945ef7b},
713
{0x97edd871cfda3a56, 0x97758bf0e3cbb5ad},
714
{0xbde94e8e43d0c8ec, 0x3d52eeed1cbea318},
715
{0xed63a231d4c4fb27, 0x4ca7aaa863ee4bde},
716
{0x945e455f24fb1cf8, 0x8fe8caa93e74ef6b},
717
{0xb975d6b6ee39e436, 0xb3e2fd538e122b45},
718
{0xe7d34c64a9c85d44, 0x60dbbca87196b617},
719
{0x90e40fbeea1d3a4a, 0xbc8955e946fe31ce},
720
{0xb51d13aea4a488dd, 0x6babab6398bdbe42},
721
{0xe264589a4dcdab14, 0xc696963c7eed2dd2},
722
{0x8d7eb76070a08aec, 0xfc1e1de5cf543ca3},
723
{0xb0de65388cc8ada8, 0x3b25a55f43294bcc},
724
{0xdd15fe86affad912, 0x49ef0eb713f39ebf},
725
{0x8a2dbf142dfcc7ab, 0x6e3569326c784338},
726
{0xacb92ed9397bf996, 0x49c2c37f07965405},
727
{0xd7e77a8f87daf7fb, 0xdc33745ec97be907},
728
{0x86f0ac99b4e8dafd, 0x69a028bb3ded71a4},
729
{0xa8acd7c0222311bc, 0xc40832ea0d68ce0d},
730
{0xd2d80db02aabd62b, 0xf50a3fa490c30191},
731
{0x83c7088e1aab65db, 0x792667c6da79e0fb},
732
{0xa4b8cab1a1563f52, 0x577001b891185939},
733
{0xcde6fd5e09abcf26, 0xed4c0226b55e6f87},
734
{0x80b05e5ac60b6178, 0x544f8158315b05b5},
735
{0xa0dc75f1778e39d6, 0x696361ae3db1c722},
736
{0xc913936dd571c84c, 0x03bc3a19cd1e38ea},
737
{0xfb5878494ace3a5f, 0x04ab48a04065c724},
738
{0x9d174b2dcec0e47b, 0x62eb0d64283f9c77},
739
{0xc45d1df942711d9a, 0x3ba5d0bd324f8395},
740
{0xf5746577930d6500, 0xca8f44ec7ee3647a},
741
{0x9968bf6abbe85f20, 0x7e998b13cf4e1ecc},
742
{0xbfc2ef456ae276e8, 0x9e3fedd8c321a67f},
743
{0xefb3ab16c59b14a2, 0xc5cfe94ef3ea101f},
744
{0x95d04aee3b80ece5, 0xbba1f1d158724a13},
745
{0xbb445da9ca61281f, 0x2a8a6e45ae8edc98},
746
{0xea1575143cf97226, 0xf52d09d71a3293be},
747
{0x924d692ca61be758, 0x593c2626705f9c57},
748
{0xb6e0c377cfa2e12e, 0x6f8b2fb00c77836d},
749
{0xe498f455c38b997a, 0x0b6dfb9c0f956448},
750
{0x8edf98b59a373fec, 0x4724bd4189bd5ead},
751
{0xb2977ee300c50fe7, 0x58edec91ec2cb658},
752
{0xdf3d5e9bc0f653e1, 0x2f2967b66737e3ee},
753
{0x8b865b215899f46c, 0xbd79e0d20082ee75},
754
{0xae67f1e9aec07187, 0xecd8590680a3aa12},
755
{0xda01ee641a708de9, 0xe80e6f4820cc9496},
756
{0x884134fe908658b2, 0x3109058d147fdcde},
757
{0xaa51823e34a7eede, 0xbd4b46f0599fd416},
758
{0xd4e5e2cdc1d1ea96, 0x6c9e18ac7007c91b},
759
{0x850fadc09923329e, 0x03e2cf6bc604ddb1},
760
{0xa6539930bf6bff45, 0x84db8346b786151d},
761
{0xcfe87f7cef46ff16, 0xe612641865679a64},
762
{0x81f14fae158c5f6e, 0x4fcb7e8f3f60c07f},
763
{0xa26da3999aef7749, 0xe3be5e330f38f09e},
764
{0xcb090c8001ab551c, 0x5cadf5bfd3072cc6},
765
{0xfdcb4fa002162a63, 0x73d9732fc7c8f7f7},
766
{0x9e9f11c4014dda7e, 0x2867e7fddcdd9afb},
767
{0xc646d63501a1511d, 0xb281e1fd541501b9},
768
{0xf7d88bc24209a565, 0x1f225a7ca91a4227},
769
{0x9ae757596946075f, 0x3375788de9b06959},
770
{0xc1a12d2fc3978937, 0x0052d6b1641c83af},
771
{0xf209787bb47d6b84, 0xc0678c5dbd23a49b},
772
{0x9745eb4d50ce6332, 0xf840b7ba963646e1},
773
{0xbd176620a501fbff, 0xb650e5a93bc3d899},
774
{0xec5d3fa8ce427aff, 0xa3e51f138ab4cebf},
775
{0x93ba47c980e98cdf, 0xc66f336c36b10138},
776
{0xb8a8d9bbe123f017, 0xb80b0047445d4185},
777
{0xe6d3102ad96cec1d, 0xa60dc059157491e6},
778
{0x9043ea1ac7e41392, 0x87c89837ad68db30},
779
{0xb454e4a179dd1877, 0x29babe4598c311fc},
780
{0xe16a1dc9d8545e94, 0xf4296dd6fef3d67b},
781
{0x8ce2529e2734bb1d, 0x1899e4a65f58660d},
782
{0xb01ae745b101e9e4, 0x5ec05dcff72e7f90},
783
{0xdc21a1171d42645d, 0x76707543f4fa1f74},
784
{0x899504ae72497eba, 0x6a06494a791c53a9},
785
{0xabfa45da0edbde69, 0x0487db9d17636893},
786
{0xd6f8d7509292d603, 0x45a9d2845d3c42b7},
787
{0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3},
788
{0xa7f26836f282b732, 0x8e6cac7768d7141f},
789
{0xd1ef0244af2364ff, 0x3207d795430cd927},
790
{0x8335616aed761f1f, 0x7f44e6bd49e807b9},
791
{0xa402b9c5a8d3a6e7, 0x5f16206c9c6209a7},
792
{0xcd036837130890a1, 0x36dba887c37a8c10},
793
{0x802221226be55a64, 0xc2494954da2c978a},
794
{0xa02aa96b06deb0fd, 0xf2db9baa10b7bd6d},
795
{0xc83553c5c8965d3d, 0x6f92829494e5acc8},
796
{0xfa42a8b73abbf48c, 0xcb772339ba1f17fa},
797
{0x9c69a97284b578d7, 0xff2a760414536efc},
798
{0xc38413cf25e2d70d, 0xfef5138519684abb},
799
{0xf46518c2ef5b8cd1, 0x7eb258665fc25d6a},
800
{0x98bf2f79d5993802, 0xef2f773ffbd97a62},
801
{0xbeeefb584aff8603, 0xaafb550ffacfd8fb},
802
{0xeeaaba2e5dbf6784, 0x95ba2a53f983cf39},
803
{0x952ab45cfa97a0b2, 0xdd945a747bf26184},
804
{0xba756174393d88df, 0x94f971119aeef9e5},
805
{0xe912b9d1478ceb17, 0x7a37cd5601aab85e},
806
{0x91abb422ccb812ee, 0xac62e055c10ab33b},
807
{0xb616a12b7fe617aa, 0x577b986b314d600a},
808
{0xe39c49765fdf9d94, 0xed5a7e85fda0b80c},
809
{0x8e41ade9fbebc27d, 0x14588f13be847308},
810
{0xb1d219647ae6b31c, 0x596eb2d8ae258fc9},
811
{0xde469fbd99a05fe3, 0x6fca5f8ed9aef3bc},
812
{0x8aec23d680043bee, 0x25de7bb9480d5855},
813
{0xada72ccc20054ae9, 0xaf561aa79a10ae6b},
814
{0xd910f7ff28069da4, 0x1b2ba1518094da05},
815
{0x87aa9aff79042286, 0x90fb44d2f05d0843},
816
{0xa99541bf57452b28, 0x353a1607ac744a54},
817
{0xd3fa922f2d1675f2, 0x42889b8997915ce9},
818
{0x847c9b5d7c2e09b7, 0x69956135febada12},
819
{0xa59bc234db398c25, 0x43fab9837e699096},
820
{0xcf02b2c21207ef2e, 0x94f967e45e03f4bc},
821
{0x8161afb94b44f57d, 0x1d1be0eebac278f6},
822
{0xa1ba1ba79e1632dc, 0x6462d92a69731733},
823
{0xca28a291859bbf93, 0x7d7b8f7503cfdcff},
824
{0xfcb2cb35e702af78, 0x5cda735244c3d43f},
825
{0x9defbf01b061adab, 0x3a0888136afa64a8},
826
{0xc56baec21c7a1916, 0x088aaa1845b8fdd1},
827
{0xf6c69a72a3989f5b, 0x8aad549e57273d46},
828
{0x9a3c2087a63f6399, 0x36ac54e2f678864c},
829
{0xc0cb28a98fcf3c7f, 0x84576a1bb416a7de},
830
{0xf0fdf2d3f3c30b9f, 0x656d44a2a11c51d6},
831
{0x969eb7c47859e743, 0x9f644ae5a4b1b326},
832
{0xbc4665b596706114, 0x873d5d9f0dde1fef},
833
{0xeb57ff22fc0c7959, 0xa90cb506d155a7eb},
834
{0x9316ff75dd87cbd8, 0x09a7f12442d588f3},
835
{0xb7dcbf5354e9bece, 0x0c11ed6d538aeb30},
836
{0xe5d3ef282a242e81, 0x8f1668c8a86da5fb},
837
{0x8fa475791a569d10, 0xf96e017d694487bd},
838
{0xb38d92d760ec4455, 0x37c981dcc395a9ad},
839
{0xe070f78d3927556a, 0x85bbe253f47b1418},
840
{0x8c469ab843b89562, 0x93956d7478ccec8f},
841
{0xaf58416654a6babb, 0x387ac8d1970027b3},
842
{0xdb2e51bfe9d0696a, 0x06997b05fcc0319f},
843
{0x88fcf317f22241e2, 0x441fece3bdf81f04},
844
{0xab3c2fddeeaad25a, 0xd527e81cad7626c4},
845
{0xd60b3bd56a5586f1, 0x8a71e223d8d3b075},
846
{0x85c7056562757456, 0xf6872d5667844e4a},
847
{0xa738c6bebb12d16c, 0xb428f8ac016561dc},
848
{0xd106f86e69d785c7, 0xe13336d701beba53},
849
{0x82a45b450226b39c, 0xecc0024661173474},
850
{0xa34d721642b06084, 0x27f002d7f95d0191},
851
{0xcc20ce9bd35c78a5, 0x31ec038df7b441f5},
852
{0xff290242c83396ce, 0x7e67047175a15272},
853
{0x9f79a169bd203e41, 0x0f0062c6e984d387},
854
{0xc75809c42c684dd1, 0x52c07b78a3e60869},
855
{0xf92e0c3537826145, 0xa7709a56ccdf8a83},
856
{0x9bbcc7a142b17ccb, 0x88a66076400bb692},
857
{0xc2abf989935ddbfe, 0x6acff893d00ea436},
858
{0xf356f7ebf83552fe, 0x0583f6b8c4124d44},
859
{0x98165af37b2153de, 0xc3727a337a8b704b},
860
{0xbe1bf1b059e9a8d6, 0x744f18c0592e4c5d},
861
{0xeda2ee1c7064130c, 0x1162def06f79df74},
862
{0x9485d4d1c63e8be7, 0x8addcb5645ac2ba9},
863
{0xb9a74a0637ce2ee1, 0x6d953e2bd7173693},
864
{0xe8111c87c5c1ba99, 0xc8fa8db6ccdd0438},
865
{0x910ab1d4db9914a0, 0x1d9c9892400a22a3},
866
{0xb54d5e4a127f59c8, 0x2503beb6d00cab4c},
867
{0xe2a0b5dc971f303a, 0x2e44ae64840fd61e},
868
{0x8da471a9de737e24, 0x5ceaecfed289e5d3},
869
{0xb10d8e1456105dad, 0x7425a83e872c5f48},
870
{0xdd50f1996b947518, 0xd12f124e28f7771a},
871
{0x8a5296ffe33cc92f, 0x82bd6b70d99aaa70},
872
{0xace73cbfdc0bfb7b, 0x636cc64d1001550c},
873
{0xd8210befd30efa5a, 0x3c47f7e05401aa4f},
874
{0x8714a775e3e95c78, 0x65acfaec34810a72},
875
{0xa8d9d1535ce3b396, 0x7f1839a741a14d0e},
876
{0xd31045a8341ca07c, 0x1ede48111209a051},
877
{0x83ea2b892091e44d, 0x934aed0aab460433},
878
{0xa4e4b66b68b65d60, 0xf81da84d56178540},
879
{0xce1de40642e3f4b9, 0x36251260ab9d668f},
880
{0x80d2ae83e9ce78f3, 0xc1d72b7c6b42601a},
881
{0xa1075a24e4421730, 0xb24cf65b8612f820},
882
{0xc94930ae1d529cfc, 0xdee033f26797b628},
883
{0xfb9b7cd9a4a7443c, 0x169840ef017da3b2},
884
{0x9d412e0806e88aa5, 0x8e1f289560ee864f},
885
{0xc491798a08a2ad4e, 0xf1a6f2bab92a27e3},
886
{0xf5b5d7ec8acb58a2, 0xae10af696774b1dc},
887
{0x9991a6f3d6bf1765, 0xacca6da1e0a8ef2a},
888
{0xbff610b0cc6edd3f, 0x17fd090a58d32af4},
889
{0xeff394dcff8a948e, 0xddfc4b4cef07f5b1},
890
{0x95f83d0a1fb69cd9, 0x4abdaf101564f98f},
891
{0xbb764c4ca7a4440f, 0x9d6d1ad41abe37f2},
892
{0xea53df5fd18d5513, 0x84c86189216dc5ee},
893
{0x92746b9be2f8552c, 0x32fd3cf5b4e49bb5},
894
{0xb7118682dbb66a77, 0x3fbc8c33221dc2a2},
895
{0xe4d5e82392a40515, 0x0fabaf3feaa5334b},
896
{0x8f05b1163ba6832d, 0x29cb4d87f2a7400f},
897
{0xb2c71d5bca9023f8, 0x743e20e9ef511013},
898
{0xdf78e4b2bd342cf6, 0x914da9246b255417},
899
{0x8bab8eefb6409c1a, 0x1ad089b6c2f7548f},
900
{0xae9672aba3d0c320, 0xa184ac2473b529b2},
901
{0xda3c0f568cc4f3e8, 0xc9e5d72d90a2741f},
902
{0x8865899617fb1871, 0x7e2fa67c7a658893},
903
{0xaa7eebfb9df9de8d, 0xddbb901b98feeab8},
904
{0xd51ea6fa85785631, 0x552a74227f3ea566},
905
{0x8533285c936b35de, 0xd53a88958f872760},
906
{0xa67ff273b8460356, 0x8a892abaf368f138},
907
{0xd01fef10a657842c, 0x2d2b7569b0432d86},
908
{0x8213f56a67f6b29b, 0x9c3b29620e29fc74},
909
{0xa298f2c501f45f42, 0x8349f3ba91b47b90},
910
{0xcb3f2f7642717713, 0x241c70a936219a74},
911
{0xfe0efb53d30dd4d7, 0xed238cd383aa0111},
912
{0x9ec95d1463e8a506, 0xf4363804324a40ab},
913
{0xc67bb4597ce2ce48, 0xb143c6053edcd0d6},
914
{0xf81aa16fdc1b81da, 0xdd94b7868e94050b},
915
{0x9b10a4e5e9913128, 0xca7cf2b4191c8327},
916
{0xc1d4ce1f63f57d72, 0xfd1c2f611f63a3f1},
917
{0xf24a01a73cf2dccf, 0xbc633b39673c8ced},
918
{0x976e41088617ca01, 0xd5be0503e085d814},
919
{0xbd49d14aa79dbc82, 0x4b2d8644d8a74e19},
920
{0xec9c459d51852ba2, 0xddf8e7d60ed1219f},
921
{0x93e1ab8252f33b45, 0xcabb90e5c942b504},
922
{0xb8da1662e7b00a17, 0x3d6a751f3b936244},
923
{0xe7109bfba19c0c9d, 0x0cc512670a783ad5},
924
{0x906a617d450187e2, 0x27fb2b80668b24c6},
925
{0xb484f9dc9641e9da, 0xb1f9f660802dedf7},
926
{0xe1a63853bbd26451, 0x5e7873f8a0396974},
927
{0x8d07e33455637eb2, 0xdb0b487b6423e1e9},
928
{0xb049dc016abc5e5f, 0x91ce1a9a3d2cda63},
929
{0xdc5c5301c56b75f7, 0x7641a140cc7810fc},
930
{0x89b9b3e11b6329ba, 0xa9e904c87fcb0a9e},
931
{0xac2820d9623bf429, 0x546345fa9fbdcd45},
932
{0xd732290fbacaf133, 0xa97c177947ad4096},
933
{0x867f59a9d4bed6c0, 0x49ed8eabcccc485e},
934
{0xa81f301449ee8c70, 0x5c68f256bfff5a75},
935
{0xd226fc195c6a2f8c, 0x73832eec6fff3112},
936
{0x83585d8fd9c25db7, 0xc831fd53c5ff7eac},
937
{0xa42e74f3d032f525, 0xba3e7ca8b77f5e56},
938
{0xcd3a1230c43fb26f, 0x28ce1bd2e55f35ec},
939
{0x80444b5e7aa7cf85, 0x7980d163cf5b81b4},
940
{0xa0555e361951c366, 0xd7e105bcc3326220},
941
{0xc86ab5c39fa63440, 0x8dd9472bf3fefaa8},
942
{0xfa856334878fc150, 0xb14f98f6f0feb952},
943
{0x9c935e00d4b9d8d2, 0x6ed1bf9a569f33d4},
944
{0xc3b8358109e84f07, 0x0a862f80ec4700c9},
945
{0xf4a642e14c6262c8, 0xcd27bb612758c0fb},
946
{0x98e7e9cccfbd7dbd, 0x8038d51cb897789d},
947
{0xbf21e44003acdd2c, 0xe0470a63e6bd56c4},
948
{0xeeea5d5004981478, 0x1858ccfce06cac75},
949
{0x95527a5202df0ccb, 0x0f37801e0c43ebc9},
950
{0xbaa718e68396cffd, 0xd30560258f54e6bb},
951
{0xe950df20247c83fd, 0x47c6b82ef32a206a},
952
{0x91d28b7416cdd27e, 0x4cdc331d57fa5442},
953
{0xb6472e511c81471d, 0xe0133fe4adf8e953},
954
{0xe3d8f9e563a198e5, 0x58180fddd97723a7},
955
{0x8e679c2f5e44ff8f, 0x570f09eaa7ea7649},
956
{0xb201833b35d63f73, 0x2cd2cc6551e513db},
957
{0xde81e40a034bcf4f, 0xf8077f7ea65e58d2},
958
{0x8b112e86420f6191, 0xfb04afaf27faf783},
959
{0xadd57a27d29339f6, 0x79c5db9af1f9b564},
960
{0xd94ad8b1c7380874, 0x18375281ae7822bd},
961
{0x87cec76f1c830548, 0x8f2293910d0b15b6},
962
{0xa9c2794ae3a3c69a, 0xb2eb3875504ddb23},
963
{0xd433179d9c8cb841, 0x5fa60692a46151ec},
964
{0x849feec281d7f328, 0xdbc7c41ba6bcd334},
965
{0xa5c7ea73224deff3, 0x12b9b522906c0801},
966
{0xcf39e50feae16bef, 0xd768226b34870a01},
967
{0x81842f29f2cce375, 0xe6a1158300d46641},
968
{0xa1e53af46f801c53, 0x60495ae3c1097fd1},
969
{0xca5e89b18b602368, 0x385bb19cb14bdfc5},
970
{0xfcf62c1dee382c42, 0x46729e03dd9ed7b6},
971
{0x9e19db92b4e31ba9, 0x6c07a2c26a8346d2},
972
{0xc5a05277621be293, 0xc7098b7305241886},
973
{0xf70867153aa2db38, 0xb8cbee4fc66d1ea8},
974
{0x9a65406d44a5c903, 0x737f74f1dc043329},
975
{0xc0fe908895cf3b44, 0x505f522e53053ff3},
976
{0xf13e34aabb430a15, 0x647726b9e7c68ff0},
977
{0x96c6e0eab509e64d, 0x5eca783430dc19f6},
978
{0xbc789925624c5fe0, 0xb67d16413d132073},
979
{0xeb96bf6ebadf77d8, 0xe41c5bd18c57e890},
980
{0x933e37a534cbaae7, 0x8e91b962f7b6f15a},
981
{0xb80dc58e81fe95a1, 0x723627bbb5a4adb1},
982
{0xe61136f2227e3b09, 0xcec3b1aaa30dd91d},
983
{0x8fcac257558ee4e6, 0x213a4f0aa5e8a7b2},
984
{0xb3bd72ed2af29e1f, 0xa988e2cd4f62d19e},
985
{0xe0accfa875af45a7, 0x93eb1b80a33b8606},
986
{0x8c6c01c9498d8b88, 0xbc72f130660533c4},
987
{0xaf87023b9bf0ee6a, 0xeb8fad7c7f8680b5},
988
{ 0xdb68c2ca82ed2a05,
989
0xa67398db9f6820e2 }
990
#else
991
{0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
992
{0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
993
{0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},
994
{0x86a8d39ef77164bc, 0xae5dff9c02033198},
995
{0xd98ddaee19068c76, 0x3badd624dd9b0958},
996
{0xafbd2350644eeacf, 0xe5d1929ef90898fb},
997
{0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},
998
{0xe55990879ddcaabd, 0xcc420a6a101d0516},
999
{0xb94470938fa89bce, 0xf808e40e8d5b3e6a},
1000
{0x95a8637627989aad, 0xdde7001379a44aa9},
1001
{0xf1c90080baf72cb1, 0x5324c68b12dd6339},
1002
{0xc350000000000000, 0x0000000000000000},
1003
{0x9dc5ada82b70b59d, 0xf020000000000000},
1004
{0xfee50b7025c36a08, 0x02f236d04753d5b5},
1005
{0xcde6fd5e09abcf26, 0xed4c0226b55e6f87},
1006
{0xa6539930bf6bff45, 0x84db8346b786151d},
1007
{0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3},
1008
{0xd910f7ff28069da4, 0x1b2ba1518094da05},
1009
{0xaf58416654a6babb, 0x387ac8d1970027b3},
1010
{0x8da471a9de737e24, 0x5ceaecfed289e5d3},
1011
{0xe4d5e82392a40515, 0x0fabaf3feaa5334b},
1012
{0xb8da1662e7b00a17, 0x3d6a751f3b936244},
1013
{0x95527a5202df0ccb, 0x0f37801e0c43ebc9},
1014
{0xf13e34aabb430a15, 0x647726b9e7c68ff0}
1015
#endif
1016
};
1017
1018
#if FMT_USE_FULL_CACHE_DRAGONBOX
1019
return pow10_significands[k - float_info<double>::min_k];
1020
#else
1021
static constexpr const uint64_t powers_of_5_64[] = {
1022
0x0000000000000001, 0x0000000000000005, 0x0000000000000019,
1023
0x000000000000007d, 0x0000000000000271, 0x0000000000000c35,
1024
0x0000000000003d09, 0x000000000001312d, 0x000000000005f5e1,
1025
0x00000000001dcd65, 0x00000000009502f9, 0x0000000002e90edd,
1026
0x000000000e8d4a51, 0x0000000048c27395, 0x000000016bcc41e9,
1027
0x000000071afd498d, 0x0000002386f26fc1, 0x000000b1a2bc2ec5,
1028
0x000003782dace9d9, 0x00001158e460913d, 0x000056bc75e2d631,
1029
0x0001b1ae4d6e2ef5, 0x000878678326eac9, 0x002a5a058fc295ed,
1030
0x00d3c21bcecceda1, 0x0422ca8b0a00a425, 0x14adf4b7320334b9};
1031
1032
static const int compression_ratio = 27;
1033
1034
// Compute base index.
1035
int cache_index = (k - float_info<double>::min_k) / compression_ratio;
1036
int kb = cache_index * compression_ratio + float_info<double>::min_k;
1037
int offset = k - kb;
1038
1039
// Get base cache.
1040
uint128_fallback base_cache = pow10_significands[cache_index];
1041
if (offset == 0) return base_cache;
1042
1043
// Compute the required amount of bit-shift.
1044
int alpha = floor_log2_pow10(kb + offset) - floor_log2_pow10(kb) - offset;
1045
FMT_ASSERT(alpha > 0 && alpha < 64, "shifting error detected");
1046
1047
// Try to recover the real cache.
1048
uint64_t pow5 = powers_of_5_64[offset];
1049
uint128_fallback recovered_cache = umul128(base_cache.high(), pow5);
1050
uint128_fallback middle_low = umul128(base_cache.low(), pow5);
1051
1052
recovered_cache += middle_low.high();
1053
1054
uint64_t high_to_middle = recovered_cache.high() << (64 - alpha);
1055
uint64_t middle_to_low = recovered_cache.low() << (64 - alpha);
1056
1057
recovered_cache =
1058
uint128_fallback{(recovered_cache.low() >> alpha) | high_to_middle,
1059
((middle_low.low() >> alpha) | middle_to_low)};
1060
FMT_ASSERT(recovered_cache.low() + 1 != 0, "");
1061
return {recovered_cache.high(), recovered_cache.low() + 1};
1062
#endif
1063
}
1064
1065
struct compute_mul_result {
1066
carrier_uint result;
1067
bool is_integer;
1068
};
1069
struct compute_mul_parity_result {
1070
bool parity;
1071
bool is_integer;
1072
};
1073
1074
static compute_mul_result compute_mul(
1075
carrier_uint u, const cache_entry_type& cache) noexcept {
1076
auto r = umul192_upper128(u, cache);
1077
return {r.high(), r.low() == 0};
1078
}
1079
1080
static uint32_t compute_delta(cache_entry_type const& cache,
1081
int beta) noexcept {
1082
return static_cast<uint32_t>(cache.high() >> (64 - 1 - beta));
1083
}
1084
1085
static compute_mul_parity_result compute_mul_parity(
1086
carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept {
1087
FMT_ASSERT(beta >= 1, "");
1088
FMT_ASSERT(beta < 64, "");
1089
1090
auto r = umul192_lower128(two_f, cache);
1091
return {((r.high() >> (64 - beta)) & 1) != 0,
1092
((r.high() << beta) | (r.low() >> (64 - beta))) == 0};
1093
}
1094
1095
static carrier_uint compute_left_endpoint_for_shorter_interval_case(
1096
const cache_entry_type& cache, int beta) noexcept {
1097
return (cache.high() -
1098
(cache.high() >> (num_significand_bits<double>() + 2))) >>
1099
(64 - num_significand_bits<double>() - 1 - beta);
1100
}
1101
1102
static carrier_uint compute_right_endpoint_for_shorter_interval_case(
1103
const cache_entry_type& cache, int beta) noexcept {
1104
return (cache.high() +
1105
(cache.high() >> (num_significand_bits<double>() + 1))) >>
1106
(64 - num_significand_bits<double>() - 1 - beta);
1107
}
1108
1109
static carrier_uint compute_round_up_for_shorter_interval_case(
1110
const cache_entry_type& cache, int beta) noexcept {
1111
return ((cache.high() >> (64 - num_significand_bits<double>() - 2 - beta)) +
1112
1) /
1113
2;
1114
}
1115
};
1116
1117
FMT_FUNC uint128_fallback get_cached_power(int k) noexcept {
1118
return cache_accessor<double>::get_cached_power(k);
1119
}
1120
1121
// Various integer checks
1122
template <typename T>
1123
bool is_left_endpoint_integer_shorter_interval(int exponent) noexcept {
1124
const int case_shorter_interval_left_endpoint_lower_threshold = 2;
1125
const int case_shorter_interval_left_endpoint_upper_threshold = 3;
1126
return exponent >= case_shorter_interval_left_endpoint_lower_threshold &&
1127
exponent <= case_shorter_interval_left_endpoint_upper_threshold;
1128
}
1129
1130
// Remove trailing zeros from n and return the number of zeros removed (float)
1131
FMT_INLINE int remove_trailing_zeros(uint32_t& n, int s = 0) noexcept {
1132
FMT_ASSERT(n != 0, "");
1133
// Modular inverse of 5 (mod 2^32): (mod_inv_5 * 5) mod 2^32 = 1.
1134
constexpr uint32_t mod_inv_5 = 0xcccccccd;
1135
constexpr uint32_t mod_inv_25 = 0xc28f5c29; // = mod_inv_5 * mod_inv_5
1136
1137
while (true) {
1138
auto q = rotr(n * mod_inv_25, 2);
1139
if (q > max_value<uint32_t>() / 100) break;
1140
n = q;
1141
s += 2;
1142
}
1143
auto q = rotr(n * mod_inv_5, 1);
1144
if (q <= max_value<uint32_t>() / 10) {
1145
n = q;
1146
s |= 1;
1147
}
1148
return s;
1149
}
1150
1151
// Removes trailing zeros and returns the number of zeros removed (double)
1152
FMT_INLINE int remove_trailing_zeros(uint64_t& n) noexcept {
1153
FMT_ASSERT(n != 0, "");
1154
1155
// This magic number is ceil(2^90 / 10^8).
1156
constexpr uint64_t magic_number = 12379400392853802749ull;
1157
auto nm = umul128(n, magic_number);
1158
1159
// Is n is divisible by 10^8?
1160
if ((nm.high() & ((1ull << (90 - 64)) - 1)) == 0 && nm.low() < magic_number) {
1161
// If yes, work with the quotient...
1162
auto n32 = static_cast<uint32_t>(nm.high() >> (90 - 64));
1163
// ... and use the 32 bit variant of the function
1164
int s = remove_trailing_zeros(n32, 8);
1165
n = n32;
1166
return s;
1167
}
1168
1169
// If n is not divisible by 10^8, work with n itself.
1170
constexpr uint64_t mod_inv_5 = 0xcccccccccccccccd;
1171
constexpr uint64_t mod_inv_25 = 0x8f5c28f5c28f5c29; // = mod_inv_5 * mod_inv_5
1172
1173
int s = 0;
1174
while (true) {
1175
auto q = rotr(n * mod_inv_25, 2);
1176
if (q > max_value<uint64_t>() / 100) break;
1177
n = q;
1178
s += 2;
1179
}
1180
auto q = rotr(n * mod_inv_5, 1);
1181
if (q <= max_value<uint64_t>() / 10) {
1182
n = q;
1183
s |= 1;
1184
}
1185
1186
return s;
1187
}
1188
1189
// The main algorithm for shorter interval case
1190
template <typename T>
1191
FMT_INLINE decimal_fp<T> shorter_interval_case(int exponent) noexcept {
1192
decimal_fp<T> ret_value;
1193
// Compute k and beta
1194
const int minus_k = floor_log10_pow2_minus_log10_4_over_3(exponent);
1195
const int beta = exponent + floor_log2_pow10(-minus_k);
1196
1197
// Compute xi and zi
1198
using cache_entry_type = typename cache_accessor<T>::cache_entry_type;
1199
const cache_entry_type cache = cache_accessor<T>::get_cached_power(-minus_k);
1200
1201
auto xi = cache_accessor<T>::compute_left_endpoint_for_shorter_interval_case(
1202
cache, beta);
1203
auto zi = cache_accessor<T>::compute_right_endpoint_for_shorter_interval_case(
1204
cache, beta);
1205
1206
// If the left endpoint is not an integer, increase it
1207
if (!is_left_endpoint_integer_shorter_interval<T>(exponent)) ++xi;
1208
1209
// Try bigger divisor
1210
ret_value.significand = zi / 10;
1211
1212
// If succeed, remove trailing zeros if necessary and return
1213
if (ret_value.significand * 10 >= xi) {
1214
ret_value.exponent = minus_k + 1;
1215
ret_value.exponent += remove_trailing_zeros(ret_value.significand);
1216
return ret_value;
1217
}
1218
1219
// Otherwise, compute the round-up of y
1220
ret_value.significand =
1221
cache_accessor<T>::compute_round_up_for_shorter_interval_case(cache,
1222
beta);
1223
ret_value.exponent = minus_k;
1224
1225
// When tie occurs, choose one of them according to the rule
1226
if (exponent >= float_info<T>::shorter_interval_tie_lower_threshold &&
1227
exponent <= float_info<T>::shorter_interval_tie_upper_threshold) {
1228
ret_value.significand = ret_value.significand % 2 == 0
1229
? ret_value.significand
1230
: ret_value.significand - 1;
1231
} else if (ret_value.significand < xi) {
1232
++ret_value.significand;
1233
}
1234
return ret_value;
1235
}
1236
1237
template <typename T> decimal_fp<T> to_decimal(T x) noexcept {
1238
// Step 1: integer promotion & Schubfach multiplier calculation.
1239
1240
using carrier_uint = typename float_info<T>::carrier_uint;
1241
using cache_entry_type = typename cache_accessor<T>::cache_entry_type;
1242
auto br = bit_cast<carrier_uint>(x);
1243
1244
// Extract significand bits and exponent bits.
1245
const carrier_uint significand_mask =
1246
(static_cast<carrier_uint>(1) << num_significand_bits<T>()) - 1;
1247
carrier_uint significand = (br & significand_mask);
1248
int exponent =
1249
static_cast<int>((br & exponent_mask<T>()) >> num_significand_bits<T>());
1250
1251
if (exponent != 0) { // Check if normal.
1252
exponent -= exponent_bias<T>() + num_significand_bits<T>();
1253
1254
// Shorter interval case; proceed like Schubfach.
1255
// In fact, when exponent == 1 and significand == 0, the interval is
1256
// regular. However, it can be shown that the end-results are anyway same.
1257
if (significand == 0) return shorter_interval_case<T>(exponent);
1258
1259
significand |= (static_cast<carrier_uint>(1) << num_significand_bits<T>());
1260
} else {
1261
// Subnormal case; the interval is always regular.
1262
if (significand == 0) return {0, 0};
1263
exponent =
1264
std::numeric_limits<T>::min_exponent - num_significand_bits<T>() - 1;
1265
}
1266
1267
const bool include_left_endpoint = (significand % 2 == 0);
1268
const bool include_right_endpoint = include_left_endpoint;
1269
1270
// Compute k and beta.
1271
const int minus_k = floor_log10_pow2(exponent) - float_info<T>::kappa;
1272
const cache_entry_type cache = cache_accessor<T>::get_cached_power(-minus_k);
1273
const int beta = exponent + floor_log2_pow10(-minus_k);
1274
1275
// Compute zi and deltai.
1276
// 10^kappa <= deltai < 10^(kappa + 1)
1277
const uint32_t deltai = cache_accessor<T>::compute_delta(cache, beta);
1278
const carrier_uint two_fc = significand << 1;
1279
1280
// For the case of binary32, the result of integer check is not correct for
1281
// 29711844 * 2^-82
1282
// = 6.1442653300000000008655037797566933477355632930994033813476... * 10^-18
1283
// and 29711844 * 2^-81
1284
// = 1.2288530660000000001731007559513386695471126586198806762695... * 10^-17,
1285
// and they are the unique counterexamples. However, since 29711844 is even,
1286
// this does not cause any problem for the endpoints calculations; it can only
1287
// cause a problem when we need to perform integer check for the center.
1288
// Fortunately, with these inputs, that branch is never executed, so we are
1289
// fine.
1290
const typename cache_accessor<T>::compute_mul_result z_mul =
1291
cache_accessor<T>::compute_mul((two_fc | 1) << beta, cache);
1292
1293
// Step 2: Try larger divisor; remove trailing zeros if necessary.
1294
1295
// Using an upper bound on zi, we might be able to optimize the division
1296
// better than the compiler; we are computing zi / big_divisor here.
1297
decimal_fp<T> ret_value;
1298
ret_value.significand = divide_by_10_to_kappa_plus_1(z_mul.result);
1299
uint32_t r = static_cast<uint32_t>(z_mul.result - float_info<T>::big_divisor *
1300
ret_value.significand);
1301
1302
if (r < deltai) {
1303
// Exclude the right endpoint if necessary.
1304
if (r == 0 && (z_mul.is_integer & !include_right_endpoint)) {
1305
--ret_value.significand;
1306
r = float_info<T>::big_divisor;
1307
goto small_divisor_case_label;
1308
}
1309
} else if (r > deltai) {
1310
goto small_divisor_case_label;
1311
} else {
1312
// r == deltai; compare fractional parts.
1313
const typename cache_accessor<T>::compute_mul_parity_result x_mul =
1314
cache_accessor<T>::compute_mul_parity(two_fc - 1, cache, beta);
1315
1316
if (!(x_mul.parity | (x_mul.is_integer & include_left_endpoint)))
1317
goto small_divisor_case_label;
1318
}
1319
ret_value.exponent = minus_k + float_info<T>::kappa + 1;
1320
1321
// We may need to remove trailing zeros.
1322
ret_value.exponent += remove_trailing_zeros(ret_value.significand);
1323
return ret_value;
1324
1325
// Step 3: Find the significand with the smaller divisor.
1326
1327
small_divisor_case_label:
1328
ret_value.significand *= 10;
1329
ret_value.exponent = minus_k + float_info<T>::kappa;
1330
1331
uint32_t dist = r - (deltai / 2) + (float_info<T>::small_divisor / 2);
1332
const bool approx_y_parity =
1333
((dist ^ (float_info<T>::small_divisor / 2)) & 1) != 0;
1334
1335
// Is dist divisible by 10^kappa?
1336
const bool divisible_by_small_divisor =
1337
check_divisibility_and_divide_by_pow10<float_info<T>::kappa>(dist);
1338
1339
// Add dist / 10^kappa to the significand.
1340
ret_value.significand += dist;
1341
1342
if (!divisible_by_small_divisor) return ret_value;
1343
1344
// Check z^(f) >= epsilon^(f).
1345
// We have either yi == zi - epsiloni or yi == (zi - epsiloni) - 1,
1346
// where yi == zi - epsiloni if and only if z^(f) >= epsilon^(f).
1347
// Since there are only 2 possibilities, we only need to care about the
1348
// parity. Also, zi and r should have the same parity since the divisor
1349
// is an even number.
1350
const auto y_mul = cache_accessor<T>::compute_mul_parity(two_fc, cache, beta);
1351
1352
// If z^(f) >= epsilon^(f), we might have a tie when z^(f) == epsilon^(f),
1353
// or equivalently, when y is an integer.
1354
if (y_mul.parity != approx_y_parity)
1355
--ret_value.significand;
1356
else if (y_mul.is_integer & (ret_value.significand % 2 != 0))
1357
--ret_value.significand;
1358
return ret_value;
1359
}
1360
} // namespace dragonbox
1361
} // namespace detail
1362
1363
template <> struct formatter<detail::bigint> {
1364
FMT_CONSTEXPR auto parse(format_parse_context& ctx)
1365
-> format_parse_context::iterator {
1366
return ctx.begin();
1367
}
1368
1369
auto format(const detail::bigint& n, format_context& ctx) const
1370
-> format_context::iterator {
1371
auto out = ctx.out();
1372
bool first = true;
1373
for (auto i = n.bigits_.size(); i > 0; --i) {
1374
auto value = n.bigits_[i - 1u];
1375
if (first) {
1376
out = format_to(out, FMT_STRING("{:x}"), value);
1377
first = false;
1378
continue;
1379
}
1380
out = format_to(out, FMT_STRING("{:08x}"), value);
1381
}
1382
if (n.exp_ > 0)
1383
out = format_to(out, FMT_STRING("p{}"),
1384
n.exp_ * detail::bigint::bigit_bits);
1385
return out;
1386
}
1387
};
1388
1389
FMT_FUNC detail::utf8_to_utf16::utf8_to_utf16(string_view s) {
1390
for_each_codepoint(s, [this](uint32_t cp, string_view) {
1391
if (cp == invalid_code_point) FMT_THROW(std::runtime_error("invalid utf8"));
1392
if (cp <= 0xFFFF) {
1393
buffer_.push_back(static_cast<wchar_t>(cp));
1394
} else {
1395
cp -= 0x10000;
1396
buffer_.push_back(static_cast<wchar_t>(0xD800 + (cp >> 10)));
1397
buffer_.push_back(static_cast<wchar_t>(0xDC00 + (cp & 0x3FF)));
1398
}
1399
return true;
1400
});
1401
buffer_.push_back(0);
1402
}
1403
1404
FMT_FUNC void format_system_error(detail::buffer<char>& out, int error_code,
1405
const char* message) noexcept {
1406
FMT_TRY {
1407
auto ec = std::error_code(error_code, std::generic_category());
1408
write(std::back_inserter(out), std::system_error(ec, message).what());
1409
return;
1410
}
1411
FMT_CATCH(...) {}
1412
format_error_code(out, error_code, message);
1413
}
1414
1415
FMT_FUNC void report_system_error(int error_code,
1416
const char* message) noexcept {
1417
report_error(format_system_error, error_code, message);
1418
}
1419
1420
FMT_FUNC std::string vformat(string_view fmt, format_args args) {
1421
// Don't optimize the "{}" case to keep the binary size small and because it
1422
// can be better optimized in fmt::format anyway.
1423
auto buffer = memory_buffer();
1424
detail::vformat_to(buffer, fmt, args);
1425
return to_string(buffer);
1426
}
1427
1428
namespace detail {
1429
#ifndef _WIN32
1430
FMT_FUNC bool write_console(std::FILE*, string_view) { return false; }
1431
#else
1432
using dword = conditional_t<sizeof(long) == 4, unsigned long, unsigned>;
1433
extern "C" __declspec(dllimport) int __stdcall WriteConsoleW( //
1434
void*, const void*, dword, dword*, void*);
1435
1436
FMT_FUNC bool write_console(std::FILE* f, string_view text) {
1437
auto fd = _fileno(f);
1438
if (!_isatty(fd)) return false;
1439
auto u16 = utf8_to_utf16(text);
1440
auto written = dword();
1441
return WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)), u16.c_str(),
1442
static_cast<uint32_t>(u16.size()), &written, nullptr) != 0;
1443
}
1444
1445
// Print assuming legacy (non-Unicode) encoding.
1446
FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args) {
1447
auto buffer = memory_buffer();
1448
detail::vformat_to(buffer, fmt,
1449
basic_format_args<buffer_context<char>>(args));
1450
fwrite_fully(buffer.data(), 1, buffer.size(), f);
1451
}
1452
#endif
1453
1454
FMT_FUNC void print(std::FILE* f, string_view text) {
1455
if (!write_console(f, text)) fwrite_fully(text.data(), 1, text.size(), f);
1456
}
1457
} // namespace detail
1458
1459
FMT_FUNC void vprint(std::FILE* f, string_view fmt, format_args args) {
1460
auto buffer = memory_buffer();
1461
detail::vformat_to(buffer, fmt, args);
1462
detail::print(f, {buffer.data(), buffer.size()});
1463
}
1464
1465
FMT_FUNC void vprint(string_view fmt, format_args args) {
1466
vprint(stdout, fmt, args);
1467
}
1468
1469
namespace detail {
1470
1471
struct singleton {
1472
unsigned char upper;
1473
unsigned char lower_count;
1474
};
1475
1476
inline auto is_printable(uint16_t x, const singleton* singletons,
1477
size_t singletons_size,
1478
const unsigned char* singleton_lowers,
1479
const unsigned char* normal, size_t normal_size)
1480
-> bool {
1481
auto upper = x >> 8;
1482
auto lower_start = 0;
1483
for (size_t i = 0; i < singletons_size; ++i) {
1484
auto s = singletons[i];
1485
auto lower_end = lower_start + s.lower_count;
1486
if (upper < s.upper) break;
1487
if (upper == s.upper) {
1488
for (auto j = lower_start; j < lower_end; ++j) {
1489
if (singleton_lowers[j] == (x & 0xff)) return false;
1490
}
1491
}
1492
lower_start = lower_end;
1493
}
1494
1495
auto xsigned = static_cast<int>(x);
1496
auto current = true;
1497
for (size_t i = 0; i < normal_size; ++i) {
1498
auto v = static_cast<int>(normal[i]);
1499
auto len = (v & 0x80) != 0 ? (v & 0x7f) << 8 | normal[++i] : v;
1500
xsigned -= len;
1501
if (xsigned < 0) break;
1502
current = !current;
1503
}
1504
return current;
1505
}
1506
1507
// This code is generated by support/printable.py.
1508
FMT_FUNC auto is_printable(uint32_t cp) -> bool {
1509
static constexpr singleton singletons0[] = {
1510
{0x00, 1}, {0x03, 5}, {0x05, 6}, {0x06, 3}, {0x07, 6}, {0x08, 8},
1511
{0x09, 17}, {0x0a, 28}, {0x0b, 25}, {0x0c, 20}, {0x0d, 16}, {0x0e, 13},
1512
{0x0f, 4}, {0x10, 3}, {0x12, 18}, {0x13, 9}, {0x16, 1}, {0x17, 5},
1513
{0x18, 2}, {0x19, 3}, {0x1a, 7}, {0x1c, 2}, {0x1d, 1}, {0x1f, 22},
1514
{0x20, 3}, {0x2b, 3}, {0x2c, 2}, {0x2d, 11}, {0x2e, 1}, {0x30, 3},
1515
{0x31, 2}, {0x32, 1}, {0xa7, 2}, {0xa9, 2}, {0xaa, 4}, {0xab, 8},
1516
{0xfa, 2}, {0xfb, 5}, {0xfd, 4}, {0xfe, 3}, {0xff, 9},
1517
};
1518
static constexpr unsigned char singletons0_lower[] = {
1519
0xad, 0x78, 0x79, 0x8b, 0x8d, 0xa2, 0x30, 0x57, 0x58, 0x8b, 0x8c, 0x90,
1520
0x1c, 0x1d, 0xdd, 0x0e, 0x0f, 0x4b, 0x4c, 0xfb, 0xfc, 0x2e, 0x2f, 0x3f,
1521
0x5c, 0x5d, 0x5f, 0xb5, 0xe2, 0x84, 0x8d, 0x8e, 0x91, 0x92, 0xa9, 0xb1,
1522
0xba, 0xbb, 0xc5, 0xc6, 0xc9, 0xca, 0xde, 0xe4, 0xe5, 0xff, 0x00, 0x04,
1523
0x11, 0x12, 0x29, 0x31, 0x34, 0x37, 0x3a, 0x3b, 0x3d, 0x49, 0x4a, 0x5d,
1524
0x84, 0x8e, 0x92, 0xa9, 0xb1, 0xb4, 0xba, 0xbb, 0xc6, 0xca, 0xce, 0xcf,
1525
0xe4, 0xe5, 0x00, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a,
1526
0x3b, 0x45, 0x46, 0x49, 0x4a, 0x5e, 0x64, 0x65, 0x84, 0x91, 0x9b, 0x9d,
1527
0xc9, 0xce, 0xcf, 0x0d, 0x11, 0x29, 0x45, 0x49, 0x57, 0x64, 0x65, 0x8d,
1528
0x91, 0xa9, 0xb4, 0xba, 0xbb, 0xc5, 0xc9, 0xdf, 0xe4, 0xe5, 0xf0, 0x0d,
1529
0x11, 0x45, 0x49, 0x64, 0x65, 0x80, 0x84, 0xb2, 0xbc, 0xbe, 0xbf, 0xd5,
1530
0xd7, 0xf0, 0xf1, 0x83, 0x85, 0x8b, 0xa4, 0xa6, 0xbe, 0xbf, 0xc5, 0xc7,
1531
0xce, 0xcf, 0xda, 0xdb, 0x48, 0x98, 0xbd, 0xcd, 0xc6, 0xce, 0xcf, 0x49,
1532
0x4e, 0x4f, 0x57, 0x59, 0x5e, 0x5f, 0x89, 0x8e, 0x8f, 0xb1, 0xb6, 0xb7,
1533
0xbf, 0xc1, 0xc6, 0xc7, 0xd7, 0x11, 0x16, 0x17, 0x5b, 0x5c, 0xf6, 0xf7,
1534
0xfe, 0xff, 0x80, 0x0d, 0x6d, 0x71, 0xde, 0xdf, 0x0e, 0x0f, 0x1f, 0x6e,
1535
0x6f, 0x1c, 0x1d, 0x5f, 0x7d, 0x7e, 0xae, 0xaf, 0xbb, 0xbc, 0xfa, 0x16,
1536
0x17, 0x1e, 0x1f, 0x46, 0x47, 0x4e, 0x4f, 0x58, 0x5a, 0x5c, 0x5e, 0x7e,
1537
0x7f, 0xb5, 0xc5, 0xd4, 0xd5, 0xdc, 0xf0, 0xf1, 0xf5, 0x72, 0x73, 0x8f,
1538
0x74, 0x75, 0x96, 0x2f, 0x5f, 0x26, 0x2e, 0x2f, 0xa7, 0xaf, 0xb7, 0xbf,
1539
0xc7, 0xcf, 0xd7, 0xdf, 0x9a, 0x40, 0x97, 0x98, 0x30, 0x8f, 0x1f, 0xc0,
1540
0xc1, 0xce, 0xff, 0x4e, 0x4f, 0x5a, 0x5b, 0x07, 0x08, 0x0f, 0x10, 0x27,
1541
0x2f, 0xee, 0xef, 0x6e, 0x6f, 0x37, 0x3d, 0x3f, 0x42, 0x45, 0x90, 0x91,
1542
0xfe, 0xff, 0x53, 0x67, 0x75, 0xc8, 0xc9, 0xd0, 0xd1, 0xd8, 0xd9, 0xe7,
1543
0xfe, 0xff,
1544
};
1545
static constexpr singleton singletons1[] = {
1546
{0x00, 6}, {0x01, 1}, {0x03, 1}, {0x04, 2}, {0x08, 8}, {0x09, 2},
1547
{0x0a, 5}, {0x0b, 2}, {0x0e, 4}, {0x10, 1}, {0x11, 2}, {0x12, 5},
1548
{0x13, 17}, {0x14, 1}, {0x15, 2}, {0x17, 2}, {0x19, 13}, {0x1c, 5},
1549
{0x1d, 8}, {0x24, 1}, {0x6a, 3}, {0x6b, 2}, {0xbc, 2}, {0xd1, 2},
1550
{0xd4, 12}, {0xd5, 9}, {0xd6, 2}, {0xd7, 2}, {0xda, 1}, {0xe0, 5},
1551
{0xe1, 2}, {0xe8, 2}, {0xee, 32}, {0xf0, 4}, {0xf8, 2}, {0xf9, 2},
1552
{0xfa, 2}, {0xfb, 1},
1553
};
1554
static constexpr unsigned char singletons1_lower[] = {
1555
0x0c, 0x27, 0x3b, 0x3e, 0x4e, 0x4f, 0x8f, 0x9e, 0x9e, 0x9f, 0x06, 0x07,
1556
0x09, 0x36, 0x3d, 0x3e, 0x56, 0xf3, 0xd0, 0xd1, 0x04, 0x14, 0x18, 0x36,
1557
0x37, 0x56, 0x57, 0x7f, 0xaa, 0xae, 0xaf, 0xbd, 0x35, 0xe0, 0x12, 0x87,
1558
0x89, 0x8e, 0x9e, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a,
1559
0x45, 0x46, 0x49, 0x4a, 0x4e, 0x4f, 0x64, 0x65, 0x5c, 0xb6, 0xb7, 0x1b,
1560
0x1c, 0x07, 0x08, 0x0a, 0x0b, 0x14, 0x17, 0x36, 0x39, 0x3a, 0xa8, 0xa9,
1561
0xd8, 0xd9, 0x09, 0x37, 0x90, 0x91, 0xa8, 0x07, 0x0a, 0x3b, 0x3e, 0x66,
1562
0x69, 0x8f, 0x92, 0x6f, 0x5f, 0xee, 0xef, 0x5a, 0x62, 0x9a, 0x9b, 0x27,
1563
0x28, 0x55, 0x9d, 0xa0, 0xa1, 0xa3, 0xa4, 0xa7, 0xa8, 0xad, 0xba, 0xbc,
1564
0xc4, 0x06, 0x0b, 0x0c, 0x15, 0x1d, 0x3a, 0x3f, 0x45, 0x51, 0xa6, 0xa7,
1565
0xcc, 0xcd, 0xa0, 0x07, 0x19, 0x1a, 0x22, 0x25, 0x3e, 0x3f, 0xc5, 0xc6,
1566
0x04, 0x20, 0x23, 0x25, 0x26, 0x28, 0x33, 0x38, 0x3a, 0x48, 0x4a, 0x4c,
1567
0x50, 0x53, 0x55, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x63, 0x65, 0x66,
1568
0x6b, 0x73, 0x78, 0x7d, 0x7f, 0x8a, 0xa4, 0xaa, 0xaf, 0xb0, 0xc0, 0xd0,
1569
0xae, 0xaf, 0x79, 0xcc, 0x6e, 0x6f, 0x93,
1570
};
1571
static constexpr unsigned char normal0[] = {
1572
0x00, 0x20, 0x5f, 0x22, 0x82, 0xdf, 0x04, 0x82, 0x44, 0x08, 0x1b, 0x04,
1573
0x06, 0x11, 0x81, 0xac, 0x0e, 0x80, 0xab, 0x35, 0x28, 0x0b, 0x80, 0xe0,
1574
0x03, 0x19, 0x08, 0x01, 0x04, 0x2f, 0x04, 0x34, 0x04, 0x07, 0x03, 0x01,
1575
0x07, 0x06, 0x07, 0x11, 0x0a, 0x50, 0x0f, 0x12, 0x07, 0x55, 0x07, 0x03,
1576
0x04, 0x1c, 0x0a, 0x09, 0x03, 0x08, 0x03, 0x07, 0x03, 0x02, 0x03, 0x03,
1577
0x03, 0x0c, 0x04, 0x05, 0x03, 0x0b, 0x06, 0x01, 0x0e, 0x15, 0x05, 0x3a,
1578
0x03, 0x11, 0x07, 0x06, 0x05, 0x10, 0x07, 0x57, 0x07, 0x02, 0x07, 0x15,
1579
0x0d, 0x50, 0x04, 0x43, 0x03, 0x2d, 0x03, 0x01, 0x04, 0x11, 0x06, 0x0f,
1580
0x0c, 0x3a, 0x04, 0x1d, 0x25, 0x5f, 0x20, 0x6d, 0x04, 0x6a, 0x25, 0x80,
1581
0xc8, 0x05, 0x82, 0xb0, 0x03, 0x1a, 0x06, 0x82, 0xfd, 0x03, 0x59, 0x07,
1582
0x15, 0x0b, 0x17, 0x09, 0x14, 0x0c, 0x14, 0x0c, 0x6a, 0x06, 0x0a, 0x06,
1583
0x1a, 0x06, 0x59, 0x07, 0x2b, 0x05, 0x46, 0x0a, 0x2c, 0x04, 0x0c, 0x04,
1584
0x01, 0x03, 0x31, 0x0b, 0x2c, 0x04, 0x1a, 0x06, 0x0b, 0x03, 0x80, 0xac,
1585
0x06, 0x0a, 0x06, 0x21, 0x3f, 0x4c, 0x04, 0x2d, 0x03, 0x74, 0x08, 0x3c,
1586
0x03, 0x0f, 0x03, 0x3c, 0x07, 0x38, 0x08, 0x2b, 0x05, 0x82, 0xff, 0x11,
1587
0x18, 0x08, 0x2f, 0x11, 0x2d, 0x03, 0x20, 0x10, 0x21, 0x0f, 0x80, 0x8c,
1588
0x04, 0x82, 0x97, 0x19, 0x0b, 0x15, 0x88, 0x94, 0x05, 0x2f, 0x05, 0x3b,
1589
0x07, 0x02, 0x0e, 0x18, 0x09, 0x80, 0xb3, 0x2d, 0x74, 0x0c, 0x80, 0xd6,
1590
0x1a, 0x0c, 0x05, 0x80, 0xff, 0x05, 0x80, 0xdf, 0x0c, 0xee, 0x0d, 0x03,
1591
0x84, 0x8d, 0x03, 0x37, 0x09, 0x81, 0x5c, 0x14, 0x80, 0xb8, 0x08, 0x80,
1592
0xcb, 0x2a, 0x38, 0x03, 0x0a, 0x06, 0x38, 0x08, 0x46, 0x08, 0x0c, 0x06,
1593
0x74, 0x0b, 0x1e, 0x03, 0x5a, 0x04, 0x59, 0x09, 0x80, 0x83, 0x18, 0x1c,
1594
0x0a, 0x16, 0x09, 0x4c, 0x04, 0x80, 0x8a, 0x06, 0xab, 0xa4, 0x0c, 0x17,
1595
0x04, 0x31, 0xa1, 0x04, 0x81, 0xda, 0x26, 0x07, 0x0c, 0x05, 0x05, 0x80,
1596
0xa5, 0x11, 0x81, 0x6d, 0x10, 0x78, 0x28, 0x2a, 0x06, 0x4c, 0x04, 0x80,
1597
0x8d, 0x04, 0x80, 0xbe, 0x03, 0x1b, 0x03, 0x0f, 0x0d,
1598
};
1599
static constexpr unsigned char normal1[] = {
1600
0x5e, 0x22, 0x7b, 0x05, 0x03, 0x04, 0x2d, 0x03, 0x66, 0x03, 0x01, 0x2f,
1601
0x2e, 0x80, 0x82, 0x1d, 0x03, 0x31, 0x0f, 0x1c, 0x04, 0x24, 0x09, 0x1e,
1602
0x05, 0x2b, 0x05, 0x44, 0x04, 0x0e, 0x2a, 0x80, 0xaa, 0x06, 0x24, 0x04,
1603
0x24, 0x04, 0x28, 0x08, 0x34, 0x0b, 0x01, 0x80, 0x90, 0x81, 0x37, 0x09,
1604
0x16, 0x0a, 0x08, 0x80, 0x98, 0x39, 0x03, 0x63, 0x08, 0x09, 0x30, 0x16,
1605
0x05, 0x21, 0x03, 0x1b, 0x05, 0x01, 0x40, 0x38, 0x04, 0x4b, 0x05, 0x2f,
1606
0x04, 0x0a, 0x07, 0x09, 0x07, 0x40, 0x20, 0x27, 0x04, 0x0c, 0x09, 0x36,
1607
0x03, 0x3a, 0x05, 0x1a, 0x07, 0x04, 0x0c, 0x07, 0x50, 0x49, 0x37, 0x33,
1608
0x0d, 0x33, 0x07, 0x2e, 0x08, 0x0a, 0x81, 0x26, 0x52, 0x4e, 0x28, 0x08,
1609
0x2a, 0x56, 0x1c, 0x14, 0x17, 0x09, 0x4e, 0x04, 0x1e, 0x0f, 0x43, 0x0e,
1610
0x19, 0x07, 0x0a, 0x06, 0x48, 0x08, 0x27, 0x09, 0x75, 0x0b, 0x3f, 0x41,
1611
0x2a, 0x06, 0x3b, 0x05, 0x0a, 0x06, 0x51, 0x06, 0x01, 0x05, 0x10, 0x03,
1612
0x05, 0x80, 0x8b, 0x62, 0x1e, 0x48, 0x08, 0x0a, 0x80, 0xa6, 0x5e, 0x22,
1613
0x45, 0x0b, 0x0a, 0x06, 0x0d, 0x13, 0x39, 0x07, 0x0a, 0x36, 0x2c, 0x04,
1614
0x10, 0x80, 0xc0, 0x3c, 0x64, 0x53, 0x0c, 0x48, 0x09, 0x0a, 0x46, 0x45,
1615
0x1b, 0x48, 0x08, 0x53, 0x1d, 0x39, 0x81, 0x07, 0x46, 0x0a, 0x1d, 0x03,
1616
0x47, 0x49, 0x37, 0x03, 0x0e, 0x08, 0x0a, 0x06, 0x39, 0x07, 0x0a, 0x81,
1617
0x36, 0x19, 0x80, 0xb7, 0x01, 0x0f, 0x32, 0x0d, 0x83, 0x9b, 0x66, 0x75,
1618
0x0b, 0x80, 0xc4, 0x8a, 0xbc, 0x84, 0x2f, 0x8f, 0xd1, 0x82, 0x47, 0xa1,
1619
0xb9, 0x82, 0x39, 0x07, 0x2a, 0x04, 0x02, 0x60, 0x26, 0x0a, 0x46, 0x0a,
1620
0x28, 0x05, 0x13, 0x82, 0xb0, 0x5b, 0x65, 0x4b, 0x04, 0x39, 0x07, 0x11,
1621
0x40, 0x05, 0x0b, 0x02, 0x0e, 0x97, 0xf8, 0x08, 0x84, 0xd6, 0x2a, 0x09,
1622
0xa2, 0xf7, 0x81, 0x1f, 0x31, 0x03, 0x11, 0x04, 0x08, 0x81, 0x8c, 0x89,
1623
0x04, 0x6b, 0x05, 0x0d, 0x03, 0x09, 0x07, 0x10, 0x93, 0x60, 0x80, 0xf6,
1624
0x0a, 0x73, 0x08, 0x6e, 0x17, 0x46, 0x80, 0x9a, 0x14, 0x0c, 0x57, 0x09,
1625
0x19, 0x80, 0x87, 0x81, 0x47, 0x03, 0x85, 0x42, 0x0f, 0x15, 0x85, 0x50,
1626
0x2b, 0x80, 0xd5, 0x2d, 0x03, 0x1a, 0x04, 0x02, 0x81, 0x70, 0x3a, 0x05,
1627
0x01, 0x85, 0x00, 0x80, 0xd7, 0x29, 0x4c, 0x04, 0x0a, 0x04, 0x02, 0x83,
1628
0x11, 0x44, 0x4c, 0x3d, 0x80, 0xc2, 0x3c, 0x06, 0x01, 0x04, 0x55, 0x05,
1629
0x1b, 0x34, 0x02, 0x81, 0x0e, 0x2c, 0x04, 0x64, 0x0c, 0x56, 0x0a, 0x80,
1630
0xae, 0x38, 0x1d, 0x0d, 0x2c, 0x04, 0x09, 0x07, 0x02, 0x0e, 0x06, 0x80,
1631
0x9a, 0x83, 0xd8, 0x08, 0x0d, 0x03, 0x0d, 0x03, 0x74, 0x0c, 0x59, 0x07,
1632
0x0c, 0x14, 0x0c, 0x04, 0x38, 0x08, 0x0a, 0x06, 0x28, 0x08, 0x22, 0x4e,
1633
0x81, 0x54, 0x0c, 0x15, 0x03, 0x03, 0x05, 0x07, 0x09, 0x19, 0x07, 0x07,
1634
0x09, 0x03, 0x0d, 0x07, 0x29, 0x80, 0xcb, 0x25, 0x0a, 0x84, 0x06,
1635
};
1636
auto lower = static_cast<uint16_t>(cp);
1637
if (cp < 0x10000) {
1638
return is_printable(lower, singletons0,
1639
sizeof(singletons0) / sizeof(*singletons0),
1640
singletons0_lower, normal0, sizeof(normal0));
1641
}
1642
if (cp < 0x20000) {
1643
return is_printable(lower, singletons1,
1644
sizeof(singletons1) / sizeof(*singletons1),
1645
singletons1_lower, normal1, sizeof(normal1));
1646
}
1647
if (0x2a6de <= cp && cp < 0x2a700) return false;
1648
if (0x2b735 <= cp && cp < 0x2b740) return false;
1649
if (0x2b81e <= cp && cp < 0x2b820) return false;
1650
if (0x2cea2 <= cp && cp < 0x2ceb0) return false;
1651
if (0x2ebe1 <= cp && cp < 0x2f800) return false;
1652
if (0x2fa1e <= cp && cp < 0x30000) return false;
1653
if (0x3134b <= cp && cp < 0xe0100) return false;
1654
if (0xe01f0 <= cp && cp < 0x110000) return false;
1655
return cp < 0x110000;
1656
}
1657
1658
} // namespace detail
1659
1660
FMT_END_NAMESPACE
1661
1662
#endif // FMT_FORMAT_INL_H_
Loggerhead is a web-based interface for Breezy
Version: 2.0.1