Bug Summary

File:builds/wireshark/wireshark/wsutil/dtoa.c
Warning:line 2946, column 20
The result of left shift is undefined because the right operand is not smaller than 64, the capacity of 'unsigned long long'

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name dtoa.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -ffloat16-excess-precision=fast -fbfloat16-excess-precision=fast -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/builds/wireshark/wireshark/build -fcoverage-compilation-dir=/builds/wireshark/wireshark/build -resource-dir /usr/lib/llvm-18/lib/clang/18 -isystem /usr/include/glib-2.0 -isystem /usr/lib/x86_64-linux-gnu/glib-2.0/include -D BUILD_WSUTIL -D G_DISABLE_DEPRECATED -D G_DISABLE_SINGLE_INCLUDES -D WS_BUILD_DLL -D WS_DEBUG -D WS_DEBUG_UTF_8 -D wsutil_EXPORTS -I /builds/wireshark/wireshark/build -I /builds/wireshark/wireshark -I /builds/wireshark/wireshark/include -I /builds/wireshark/wireshark/build/wsutil -D _GLIBCXX_ASSERTIONS -internal-isystem /usr/lib/llvm-18/lib/clang/18/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/builds/wireshark/wireshark/= -fmacro-prefix-map=/builds/wireshark/wireshark/build/= -fmacro-prefix-map=../= -Wno-format-truncation -Wno-format-nonliteral -Wno-pointer-sign -std=gnu11 -ferror-limit 19 -fvisibility=hidden -fwrapv -fstrict-flex-arrays=3 -stack-protector 2 -fstack-clash-protection -fcf-protection=full -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fexceptions -fcolor-diagnostics -analyzer-output=html -dwarf-debug-flags /usr/lib/llvm-18/bin/clang -### --analyze -x c -D BUILD_WSUTIL -D G_DISABLE_DEPRECATED -D G_DISABLE_SINGLE_INCLUDES -D WS_BUILD_DLL -D WS_DEBUG -D WS_DEBUG_UTF_8 -D wsutil_EXPORTS -I /builds/wireshark/wireshark/build -I /builds/wireshark/wireshark -I /builds/wireshark/wireshark/include -I /builds/wireshark/wireshark/build/wsutil -isystem /usr/include/glib-2.0 -isystem /usr/lib/x86_64-linux-gnu/glib-2.0/include -fvisibility=hidden -fexcess-precision=fast -fstrict-flex-arrays=3 -fstack-clash-protection -fcf-protection=full -D _GLIBCXX_ASSERTIONS -fstack-protector-strong -fno-delete-null-pointer-checks -fno-strict-overflow -fno-strict-aliasing -fexceptions -Wno-format-truncation -Wno-format-nonliteral -fdiagnostics-color=always -Wno-pointer-sign -fmacro-prefix-map=/builds/wireshark/wireshark/= -fmacro-prefix-map=/builds/wireshark/wireshark/build/= -fmacro-prefix-map=../= -std=gnu11 -fPIC /builds/wireshark/wireshark/wsutil/dtoa.c -o /builds/wireshark/wireshark/sbout/2025-01-02-100258-3934-1 -Xclang -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /builds/wireshark/wireshark/sbout/2025-01-02-100258-3934-1 -x c /builds/wireshark/wireshark/wsutil/dtoa.c
1/****************************************************************
2 *
3 * The author of this software is David M. Gay.
4 *
5 * Copyright (c) 1991, 2000, 2001 by Lucent Technologies.
6 *
7 * Permission to use, copy, modify, and distribute this software for any
8 * purpose without fee is hereby granted, provided that this entire notice
9 * is included in all copies of any software which is or includes a copy
10 * or modification of this software and in all copies of the supporting
11 * documentation for such software.
12 *
13 * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
14 * WARRANTY. IN PARTICULAR, NEITHER THE AUTHOR NOR LUCENT MAKES ANY
15 * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
16 * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
17 *
18 ***************************************************************/
19
20/* Please send bug reports to David M. Gay (dmg at acm dot org,
21 * with " at " changed at "@" and " dot " changed to "."). */
22
23/* On a machine with IEEE extended-precision registers, it is
24 * necessary to specify double-precision (53-bit) rounding precision
25 * before invoking strtod or dtoa. If the machine uses (the equivalent
26 * of) Intel 80x87 arithmetic, the call
27 * _control87(PC_53, MCW_PC);
28 * does this with many compilers. Whether this or another call is
29 * appropriate depends on the compiler; for this to work, it may be
30 * necessary to #include "float.h" or another system-dependent header
31 * file. When needed, this call avoids double rounding, which can
32 * cause one bit errors, e.g., with strtod on 8.3e26 or 6.3876e-16.
33 */
34
35/* strtod for IEEE-, VAX-, and IBM-arithmetic machines.
36 * (Note that IEEE arithmetic is disabled by gcc's -ffast-math flag.)
37 *
38 * This strtod returns a nearest machine number to the input decimal
39 * string (or sets errno to ERANGE). With IEEE arithmetic, ties are
40 * broken by the IEEE round-even rule. Otherwise ties are broken by
41 * biased rounding (add half and chop).
42 *
43 * Inspired loosely by William D. Clinger's paper "How to Read Floating
44 * Point Numbers Accurately" [Proc. ACM SIGPLAN '90, pp. 92-101].
45 *
46 * Modifications:
47 *
48 * 1. We only require IEEE, IBM, or VAX double-precision
49 * arithmetic (not IEEE double-extended).
50 * 2. We get by with floating-point arithmetic in a case that
51 * Clinger missed -- when we're computing d * 10^n
52 * for a small integer d and the integer n is not too
53 * much larger than 22 (the maximum integer k for which
54 * we can represent 10^k exactly), we may be able to
55 * compute (d*10^k) * 10^(e-k) with just one roundoff.
56 * 3. Rather than a bit-at-a-time adjustment of the binary
57 * result in the hard case, we use floating-point
58 * arithmetic to determine the adjustment to within
59 * one bit; only in really hard cases do we need to
60 * compute a second residual.
61 * 4. Because of 3., we don't need a large table of powers of 10
62 * for ten-to-e (just some small tables, e.g. of 10^k
63 * for 0 <= k <= 22).
64 */
65
66/*
67 * #define IEEE_8087 for IEEE-arithmetic machines where the least
68 * significant byte has the lowest address.
69 * #define IEEE_MC68k for IEEE-arithmetic machines where the most
70 * significant byte has the lowest address.
71 * #define Long int on machines with 32-bit ints and 64-bit longs.
72 * #define IBM for IBM mainframe-style floating-point arithmetic.
73 * #define VAX for VAX-style floating-point arithmetic (D_floating).
74 * #define No_leftright to omit left-right logic in fast floating-point
75 * computation of dtoa. This will cause dtoa modes 4 and 5 to be
76 * treated the same as modes 2 and 3 for some inputs.
77 * #define Honor_FLT_ROUNDS if FLT_ROUNDS can assume the values 2 or 3
78 * and strtod and dtoa should round accordingly. Unless Trust_FLT_ROUNDS
79 * is also #defined, fegetround() will be queried for the rounding mode.
80 * Note that both FLT_ROUNDS and fegetround() are specified by the C99
81 * standard (and are specified to be consistent, with fesetround()
82 * affecting the value of FLT_ROUNDS), but that some (Linux) systems
83 * do not work correctly in this regard, so using fegetround() is more
84 * portable than using FLT_ROUNDS directly.
85 * #define Check_FLT_ROUNDS if FLT_ROUNDS can assume the values 2 or 3
86 * and Honor_FLT_ROUNDS is not #defined.
87 * #define RND_PRODQUOT to use rnd_prod and rnd_quot (assembly routines
88 * that use extended-precision instructions to compute rounded
89 * products and quotients) with IBM.
90 * #define ROUND_BIASED for IEEE-format with biased rounding and arithmetic
91 * that rounds toward +Infinity.
92 * #define ROUND_BIASED_without_Round_Up for IEEE-format with biased
93 * rounding when the underlying floating-point arithmetic uses
94 * unbiased rounding. This prevent using ordinary floating-point
95 * arithmetic when the result could be computed with one rounding error.
96 * #define Inaccurate_Divide for IEEE-format with correctly rounded
97 * products but inaccurate quotients, e.g., for Intel i860.
98 * #define NO_LONG_LONG on machines that do not have a "long long"
99 * integer type (of >= 64 bits). On such machines, you can
100 * #define Just_16 to store 16 bits per 32-bit Long when doing
101 * high-precision integer arithmetic. Whether this speeds things
102 * up or slows things down depends on the machine and the number
103 * being converted. If long long is available and the name is
104 * something other than "long long", #define Llong to be the name,
105 * and if "unsigned Llong" does not work as an unsigned version of
106 * Llong, #define #ULLong to be the corresponding unsigned type.
107 * #define Bad_float_h if your system lacks a float.h or if it does not
108 * define some or all of DBL_DIG, DBL_MAX_10_EXP, DBL_MAX_EXP,
109 * FLT_RADIX, FLT_ROUNDS, and DBL_MAX.
110 * #define MALLOC your_malloc, where your_malloc(n) acts like malloc(n)
111 * if memory is available and otherwise does something you deem
112 * appropriate. If MALLOC is undefined, malloc will be invoked
113 * directly -- and assumed always to succeed. Similarly, if you
114 * want something other than the system's free() to be called to
115 * recycle memory acquired from MALLOC, #define FREE to be the
116 * name of the alternate routine. (FREE or free is only called in
117 * pathological cases, e.g., in a dtoa call after a dtoa return in
118 * mode 3 with thousands of digits requested.)
119 * #define Omit_Private_Memory to omit logic (added Jan. 1998) for making
120 * memory allocations from a private pool of memory when possible.
121 * When used, the private pool is PRIVATE_MEM bytes long: 2304 bytes,
122 * unless #defined to be a different length. This default length
123 * suffices to get rid of MALLOC calls except for unusual cases,
124 * such as decimal-to-binary conversion of a very long string of
125 * digits. The longest string dtoa can return is about 751 bytes
126 * long. For conversions by strtod of strings of 800 digits and
127 * all dtoa conversions in single-threaded executions with 8-byte
128 * pointers, PRIVATE_MEM >= 7400 appears to suffice; with 4-byte
129 * pointers, PRIVATE_MEM >= 7112 appears adequate.
130 * #define NO_INFNAN_CHECK if you do not wish to have INFNAN_CHECK
131 * #defined automatically on IEEE systems. On such systems,
132 * when INFNAN_CHECK is #defined, strtod checks
133 * for Infinity and NaN (case insensitively). On some systems
134 * (e.g., some HP systems), it may be necessary to #define NAN_WORD0
135 * appropriately -- to the most significant word of a quiet NaN.
136 * (On HP Series 700/800 machines, -DNAN_WORD0=0x7ff40000 works.)
137 * When INFNAN_CHECK is #defined and No_Hex_NaN is not #defined,
138 * strtod also accepts (case insensitively) strings of the form
139 * NaN(x), where x is a string of hexadecimal digits and spaces;
140 * if there is only one string of hexadecimal digits, it is taken
141 * for the 52 fraction bits of the resulting NaN; if there are two
142 * or more strings of hex digits, the first is for the high 20 bits,
143 * the second and subsequent for the low 32 bits, with intervening
144 * white space ignored; but if this results in none of the 52
145 * fraction bits being on (an IEEE Infinity symbol), then NAN_WORD0
146 * and NAN_WORD1 are used instead.
147 * #define MULTIPLE_THREADS if the system offers preemptively scheduled
148 * multiple threads. In this case, you must provide (or suitably
149 * #define) two locks, acquired by ACQUIRE_DTOA_LOCK(n) and freed
150 * by FREE_DTOA_LOCK(n) for n = 0 or 1. (The second lock, accessed
151 * in pow5mult, ensures lazy evaluation of only one copy of high
152 * powers of 5; omitting this lock would introduce a small
153 * probability of wasting memory, but would otherwise be harmless.)
154 * You must also invoke freedtoa(s) to free the value s returned by
155 * dtoa. You may do so whether or not MULTIPLE_THREADS is #defined.
156
157 * When MULTIPLE_THREADS is #defined, this source file provides
158 * void set_max_dtoa_threads(unsigned int n);
159 * and expects
160 * unsigned int dtoa_get_threadno(void);
161 * to be available (possibly provided by
162 * #define dtoa_get_threadno omp_get_thread_num
163 * if OpenMP is in use or by
164 * #define dtoa_get_threadno pthread_self
165 * if Pthreads is in use), to return the current thread number.
166 * If set_max_dtoa_threads(n) was called and the current thread
167 * number is k with k < n, then calls on ACQUIRE_DTOA_LOCK(...) and
168 * FREE_DTOA_LOCK(...) are avoided; instead each thread with thread
169 * number < n has a separate copy of relevant data structures.
170 * After set_max_dtoa_threads(n), a call set_max_dtoa_threads(m)
171 * with m <= n has has no effect, but a call with m > n is honored.
172 * Such a call invokes REALLOC (assumed to be "realloc" if REALLOC
173 * is not #defined) to extend the size of the relevant array.
174
175 * #define NO_IEEE_Scale to disable new (Feb. 1997) logic in strtod that
176 * avoids underflows on inputs whose result does not underflow.
177 * If you #define NO_IEEE_Scale on a machine that uses IEEE-format
178 * floating-point numbers and flushes underflows to zero rather
179 * than implementing gradual underflow, then you must also #define
180 * Sudden_Underflow.
181 * #define USE_LOCALE to use the current locale's decimal_point value.
182 * #define SET_INEXACT if IEEE arithmetic is being used and extra
183 * computation should be done to set the inexact flag when the
184 * result is inexact and avoid setting inexact when the result
185 * is exact. In this case, dtoa.c must be compiled in
186 * an environment, perhaps provided by #include "dtoa.c" in a
187 * suitable wrapper, that defines two functions,
188 * int get_inexact(void);
189 * void clear_inexact(void);
190 * such that get_inexact() returns a nonzero value if the
191 * inexact bit is already set, and clear_inexact() sets the
192 * inexact bit to 0. When SET_INEXACT is #defined, strtod
193 * also does extra computations to set the underflow and overflow
194 * flags when appropriate (i.e., when the result is tiny and
195 * inexact or when it is a numeric value rounded to +-infinity).
196 * #define NO_ERRNO if strtod should not assign errno = ERANGE when
197 * the result overflows to +-Infinity or underflows to 0.
198 * When errno should be assigned, under seemingly rare conditions
199 * it may be necessary to define Set_errno(x) suitably, e.g., in
200 * a local errno.h, such as
201 * #include <errno.h>
202 * #define Set_errno(x) _set_errno(x)
203 * #define NO_HEX_FP to omit recognition of hexadecimal floating-point
204 * values by strtod.
205 * #define NO_STRTOD_BIGCOMP (on IEEE-arithmetic systems only for now)
206 * to disable logic for "fast" testing of very long input strings
207 * to strtod. This testing proceeds by initially truncating the
208 * input string, then if necessary comparing the whole string with
209 * a decimal expansion to decide close cases. This logic is only
210 * used for input more than STRTOD_DIGLIM digits long (default 40).
211 */
212
213/* Begin Wireshark defines and includes */
214#include <wireshark.h>
215#include "dtoa.h"
216
217#if G_BYTE_ORDER1234 == G_LITTLE_ENDIAN1234
218#define IEEE_8087
219#elif G_BYTE_ORDER1234 == G_BIG_ENDIAN4321
220#define IEEE_MC68k
221#else
222#error "Unsupported byte order"
223#endif
224
225#define MALLOCg_malloc g_malloc
226#define REALLOCg_realloc g_realloc
227#define FREEg_free g_free
228
229typedef int32_t Longint;
230typedef uint32_t ULong;
231typedef uint64_t ULLongunsigned long long;
232
233#define NO_HEX_FP
234
235#ifdef _MSC_VER
236/* disable: "warning C4146: unary minus operator applied to unsigned type, result still unsigned" */
237#pragma warning(disable:4146)
238#endif
239
240/* End Wireshark defines and includes */
241
242#ifndef Longint
243#define Longint int
244#endif
245#ifndef ULong
246typedef unsigned Longint ULong;
247#endif
248
249#ifdef DEBUG
250#include <assert.h>
251#include "stdio.h"
252#define Bug(x) {ws_error("%s", x)ws_log_fatal_full("", LOG_LEVEL_ERROR, "wsutil/dtoa.c", 252, __func__
, "%s", x);}
253#define Debug(x) x
254int dtoa_stats[7]; /* strtod_{64,96,bigcomp},dtoa_{exact,64,96,bigcomp} */
255#else
256#define assert(x) /*nothing*/
257#define Debug(x) /*nothing*/
258#endif
259
260#include "stdlib.h"
261#include "string.h"
262
263#ifdef USE_LOCALE
264#include "locale.h"
265#endif
266
267#ifdef Honor_FLT_ROUNDS
268#ifndef Trust_FLT_ROUNDS
269#include <fenv.h>
270#endif
271#endif
272
273#ifndef Omit_Private_Memory
274#ifndef PRIVATE_MEM2304
275#define PRIVATE_MEM2304 2304
276#endif
277#define PRIVATE_mem((2304 +sizeof(double)-1)/sizeof(double)) ((PRIVATE_MEM2304+sizeof(double)-1)/sizeof(double))
278static double private_mem[PRIVATE_mem((2304 +sizeof(double)-1)/sizeof(double))], *pmem_next = private_mem;
279#endif
280
281#undef IEEE_Arith
282#undef Avoid_Underflow
283#ifdef IEEE_MC68k
284#define IEEE_Arith
285#endif
286#ifdef IEEE_8087
287#define IEEE_Arith
288#endif
289
290#ifdef IEEE_Arith
291#ifndef NO_INFNAN_CHECK
292#undef INFNAN_CHECK
293#define INFNAN_CHECK
294#endif
295#else
296#undef INFNAN_CHECK
297#define NO_STRTOD_BIGCOMP
298#endif
299
300#include "errno.h"
301
302#ifdef NO_ERRNO /*{*/
303#undef Set_errno
304#define Set_errno(x)(*__errno_location ()) = x
305#else
306#ifndef Set_errno
307#define Set_errno(x)(*__errno_location ()) = x errno(*__errno_location ()) = x
308#endif
309#endif /*}*/
310
311#ifdef Bad_float_h
312
313#ifdef IEEE_Arith
314#define DBL_DIG15 15
315#define DBL_MAX_10_EXP308 308
316#define DBL_MAX_EXP1024 1024
317#define FLT_RADIX2 2
318#endif /*IEEE_Arith*/
319
320#ifdef IBM
321#define DBL_DIG15 16
322#define DBL_MAX_10_EXP308 75
323#define DBL_MAX_EXP1024 63
324#define FLT_RADIX2 16
325#define DBL_MAX1.7976931348623157e+308 7.2370055773322621e+75
326#endif
327
328#ifdef VAX
329#define DBL_DIG15 16
330#define DBL_MAX_10_EXP308 38
331#define DBL_MAX_EXP1024 127
332#define FLT_RADIX2 2
333#define DBL_MAX1.7976931348623157e+308 1.7014118346046923e+38
334#endif
335
336#ifndef LONG_MAX9223372036854775807L
337#define LONG_MAX9223372036854775807L 2147483647
338#endif
339
340#else /* ifndef Bad_float_h */
341#include "float.h"
342#endif /* Bad_float_h */
343
344#ifndef __MATH_H__
345#include "math.h"
346#endif
347
348#ifdef __cplusplus
349extern "C" {
350#endif
351
352#if defined(IEEE_8087) + defined(IEEE_MC68k) + defined(VAX) + defined(IBM) != 1
353Exactly one of IEEE_8087, IEEE_MC68k, VAX, or IBM should be defined.
354#endif
355
356#undef USE_BF96
357
358#ifdef NO_LONG_LONG /*{{*/
359#undef ULLongunsigned long long
360#ifdef Just_16
361#undef Pack_32
362/* When Pack_32 is not defined, we store 16 bits per 32-bit Long.
363 * This makes some inner loops simpler and sometimes saves work
364 * during multiplications, but it often seems to make things slightly
365 * slower. Hence the default is now to store 32 bits per Long.
366 */
367#endif
368#else /*}{ long long available */
369#ifndef Llonglong long
370#define Llonglong long long long
371#endif
372#ifndef ULLongunsigned long long
373#define ULLongunsigned long long unsigned Llonglong long
374#endif
375#ifndef NO_BF96 /*{*/
376#define USE_BF96
377
378#ifdef SET_INEXACT
379#define dtoa_divmax 27
380#else
381int dtoa_divmax = 2; /* Permit experimenting: on some systems, 64-bit integer */
382 /* division is slow enough that we may sometimes want to */
383 /* avoid using it. We assume (but do not check) that */
384 /* dtoa_divmax <= 27.*/
385#endif
386
387typedef struct BF96 { /* Normalized 96-bit software floating point numbers */
388 unsigned int b0,b1,b2; /* b0 = most significant, binary point just to its left */
389 int e; /* number represented = b * 2^e, with .5 <= b < 1 */
390 } BF96;
391
392 static BF96 pten[667] = {
393 { 0xeef453d6, 0x923bd65a, 0x113faa29, -1136 },
394 { 0x9558b466, 0x1b6565f8, 0x4ac7ca59, -1132 },
395 { 0xbaaee17f, 0xa23ebf76, 0x5d79bcf0, -1129 },
396 { 0xe95a99df, 0x8ace6f53, 0xf4d82c2c, -1126 },
397 { 0x91d8a02b, 0xb6c10594, 0x79071b9b, -1122 },
398 { 0xb64ec836, 0xa47146f9, 0x9748e282, -1119 },
399 { 0xe3e27a44, 0x4d8d98b7, 0xfd1b1b23, -1116 },
400 { 0x8e6d8c6a, 0xb0787f72, 0xfe30f0f5, -1112 },
401 { 0xb208ef85, 0x5c969f4f, 0xbdbd2d33, -1109 },
402 { 0xde8b2b66, 0xb3bc4723, 0xad2c7880, -1106 },
403 { 0x8b16fb20, 0x3055ac76, 0x4c3bcb50, -1102 },
404 { 0xaddcb9e8, 0x3c6b1793, 0xdf4abe24, -1099 },
405 { 0xd953e862, 0x4b85dd78, 0xd71d6dad, -1096 },
406 { 0x87d4713d, 0x6f33aa6b, 0x8672648c, -1092 },
407 { 0xa9c98d8c, 0xcb009506, 0x680efdaf, -1089 },
408 { 0xd43bf0ef, 0xfdc0ba48, 0x0212bd1b, -1086 },
409 { 0x84a57695, 0xfe98746d, 0x014bb630, -1082 },
410 { 0xa5ced43b, 0x7e3e9188, 0x419ea3bd, -1079 },
411 { 0xcf42894a, 0x5dce35ea, 0x52064cac, -1076 },
412 { 0x818995ce, 0x7aa0e1b2, 0x7343efeb, -1072 },
413 { 0xa1ebfb42, 0x19491a1f, 0x1014ebe6, -1069 },
414 { 0xca66fa12, 0x9f9b60a6, 0xd41a26e0, -1066 },
415 { 0xfd00b897, 0x478238d0, 0x8920b098, -1063 },
416 { 0x9e20735e, 0x8cb16382, 0x55b46e5f, -1059 },
417 { 0xc5a89036, 0x2fddbc62, 0xeb2189f7, -1056 },
418 { 0xf712b443, 0xbbd52b7b, 0xa5e9ec75, -1053 },
419 { 0x9a6bb0aa, 0x55653b2d, 0x47b233c9, -1049 },
420 { 0xc1069cd4, 0xeabe89f8, 0x999ec0bb, -1046 },
421 { 0xf148440a, 0x256e2c76, 0xc00670ea, -1043 },
422 { 0x96cd2a86, 0x5764dbca, 0x38040692, -1039 },
423 { 0xbc807527, 0xed3e12bc, 0xc6050837, -1036 },
424 { 0xeba09271, 0xe88d976b, 0xf7864a44, -1033 },
425 { 0x93445b87, 0x31587ea3, 0x7ab3ee6a, -1029 },
426 { 0xb8157268, 0xfdae9e4c, 0x5960ea05, -1026 },
427 { 0xe61acf03, 0x3d1a45df, 0x6fb92487, -1023 },
428 { 0x8fd0c162, 0x06306bab, 0xa5d3b6d4, -1019 },
429 { 0xb3c4f1ba, 0x87bc8696, 0x8f48a489, -1016 },
430 { 0xe0b62e29, 0x29aba83c, 0x331acdab, -1013 },
431 { 0x8c71dcd9, 0xba0b4925, 0x9ff0c08b, -1009 },
432 { 0xaf8e5410, 0x288e1b6f, 0x07ecf0ae, -1006 },
433 { 0xdb71e914, 0x32b1a24a, 0xc9e82cd9, -1003 },
434 { 0x892731ac, 0x9faf056e, 0xbe311c08, -999 },
435 { 0xab70fe17, 0xc79ac6ca, 0x6dbd630a, -996 },
436 { 0xd64d3d9d, 0xb981787d, 0x092cbbcc, -993 },
437 { 0x85f04682, 0x93f0eb4e, 0x25bbf560, -989 },
438 { 0xa76c5823, 0x38ed2621, 0xaf2af2b8, -986 },
439 { 0xd1476e2c, 0x07286faa, 0x1af5af66, -983 },
440 { 0x82cca4db, 0x847945ca, 0x50d98d9f, -979 },
441 { 0xa37fce12, 0x6597973c, 0xe50ff107, -976 },
442 { 0xcc5fc196, 0xfefd7d0c, 0x1e53ed49, -973 },
443 { 0xff77b1fc, 0xbebcdc4f, 0x25e8e89c, -970 },
444 { 0x9faacf3d, 0xf73609b1, 0x77b19161, -966 },
445 { 0xc795830d, 0x75038c1d, 0xd59df5b9, -963 },
446 { 0xf97ae3d0, 0xd2446f25, 0x4b057328, -960 },
447 { 0x9becce62, 0x836ac577, 0x4ee367f9, -956 },
448 { 0xc2e801fb, 0x244576d5, 0x229c41f7, -953 },
449 { 0xf3a20279, 0xed56d48a, 0x6b435275, -950 },
450 { 0x9845418c, 0x345644d6, 0x830a1389, -946 },
451 { 0xbe5691ef, 0x416bd60c, 0x23cc986b, -943 },
452 { 0xedec366b, 0x11c6cb8f, 0x2cbfbe86, -940 },
453 { 0x94b3a202, 0xeb1c3f39, 0x7bf7d714, -936 },
454 { 0xb9e08a83, 0xa5e34f07, 0xdaf5ccd9, -933 },
455 { 0xe858ad24, 0x8f5c22c9, 0xd1b3400f, -930 },
456 { 0x91376c36, 0xd99995be, 0x23100809, -926 },
457 { 0xb5854744, 0x8ffffb2d, 0xabd40a0c, -923 },
458 { 0xe2e69915, 0xb3fff9f9, 0x16c90c8f, -920 },
459 { 0x8dd01fad, 0x907ffc3b, 0xae3da7d9, -916 },
460 { 0xb1442798, 0xf49ffb4a, 0x99cd11cf, -913 },
461 { 0xdd95317f, 0x31c7fa1d, 0x40405643, -910 },
462 { 0x8a7d3eef, 0x7f1cfc52, 0x482835ea, -906 },
463 { 0xad1c8eab, 0x5ee43b66, 0xda324365, -903 },
464 { 0xd863b256, 0x369d4a40, 0x90bed43e, -900 },
465 { 0x873e4f75, 0xe2224e68, 0x5a7744a6, -896 },
466 { 0xa90de353, 0x5aaae202, 0x711515d0, -893 },
467 { 0xd3515c28, 0x31559a83, 0x0d5a5b44, -890 },
468 { 0x8412d999, 0x1ed58091, 0xe858790a, -886 },
469 { 0xa5178fff, 0x668ae0b6, 0x626e974d, -883 },
470 { 0xce5d73ff, 0x402d98e3, 0xfb0a3d21, -880 },
471 { 0x80fa687f, 0x881c7f8e, 0x7ce66634, -876 },
472 { 0xa139029f, 0x6a239f72, 0x1c1fffc1, -873 },
473 { 0xc9874347, 0x44ac874e, 0xa327ffb2, -870 },
474 { 0xfbe91419, 0x15d7a922, 0x4bf1ff9f, -867 },
475 { 0x9d71ac8f, 0xada6c9b5, 0x6f773fc3, -863 },
476 { 0xc4ce17b3, 0x99107c22, 0xcb550fb4, -860 },
477 { 0xf6019da0, 0x7f549b2b, 0x7e2a53a1, -857 },
478 { 0x99c10284, 0x4f94e0fb, 0x2eda7444, -853 },
479 { 0xc0314325, 0x637a1939, 0xfa911155, -850 },
480 { 0xf03d93ee, 0xbc589f88, 0x793555ab, -847 },
481 { 0x96267c75, 0x35b763b5, 0x4bc1558b, -843 },
482 { 0xbbb01b92, 0x83253ca2, 0x9eb1aaed, -840 },
483 { 0xea9c2277, 0x23ee8bcb, 0x465e15a9, -837 },
484 { 0x92a1958a, 0x7675175f, 0x0bfacd89, -833 },
485 { 0xb749faed, 0x14125d36, 0xcef980ec, -830 },
486 { 0xe51c79a8, 0x5916f484, 0x82b7e127, -827 },
487 { 0x8f31cc09, 0x37ae58d2, 0xd1b2ecb8, -823 },
488 { 0xb2fe3f0b, 0x8599ef07, 0x861fa7e6, -820 },
489 { 0xdfbdcece, 0x67006ac9, 0x67a791e0, -817 },
490 { 0x8bd6a141, 0x006042bd, 0xe0c8bb2c, -813 },
491 { 0xaecc4991, 0x4078536d, 0x58fae9f7, -810 },
492 { 0xda7f5bf5, 0x90966848, 0xaf39a475, -807 },
493 { 0x888f9979, 0x7a5e012d, 0x6d8406c9, -803 },
494 { 0xaab37fd7, 0xd8f58178, 0xc8e5087b, -800 },
495 { 0xd5605fcd, 0xcf32e1d6, 0xfb1e4a9a, -797 },
496 { 0x855c3be0, 0xa17fcd26, 0x5cf2eea0, -793 },
497 { 0xa6b34ad8, 0xc9dfc06f, 0xf42faa48, -790 },
498 { 0xd0601d8e, 0xfc57b08b, 0xf13b94da, -787 },
499 { 0x823c1279, 0x5db6ce57, 0x76c53d08, -783 },
500 { 0xa2cb1717, 0xb52481ed, 0x54768c4b, -780 },
501 { 0xcb7ddcdd, 0xa26da268, 0xa9942f5d, -777 },
502 { 0xfe5d5415, 0x0b090b02, 0xd3f93b35, -774 },
503 { 0x9efa548d, 0x26e5a6e1, 0xc47bc501, -770 },
504 { 0xc6b8e9b0, 0x709f109a, 0x359ab641, -767 },
505 { 0xf867241c, 0x8cc6d4c0, 0xc30163d2, -764 },
506 { 0x9b407691, 0xd7fc44f8, 0x79e0de63, -760 },
507 { 0xc2109436, 0x4dfb5636, 0x985915fc, -757 },
508 { 0xf294b943, 0xe17a2bc4, 0x3e6f5b7b, -754 },
509 { 0x979cf3ca, 0x6cec5b5a, 0xa705992c, -750 },
510 { 0xbd8430bd, 0x08277231, 0x50c6ff78, -747 },
511 { 0xece53cec, 0x4a314ebd, 0xa4f8bf56, -744 },
512 { 0x940f4613, 0xae5ed136, 0x871b7795, -740 },
513 { 0xb9131798, 0x99f68584, 0x28e2557b, -737 },
514 { 0xe757dd7e, 0xc07426e5, 0x331aeada, -734 },
515 { 0x9096ea6f, 0x3848984f, 0x3ff0d2c8, -730 },
516 { 0xb4bca50b, 0x065abe63, 0x0fed077a, -727 },
517 { 0xe1ebce4d, 0xc7f16dfb, 0xd3e84959, -724 },
518 { 0x8d3360f0, 0x9cf6e4bd, 0x64712dd7, -720 },
519 { 0xb080392c, 0xc4349dec, 0xbd8d794d, -717 },
520 { 0xdca04777, 0xf541c567, 0xecf0d7a0, -714 },
521 { 0x89e42caa, 0xf9491b60, 0xf41686c4, -710 },
522 { 0xac5d37d5, 0xb79b6239, 0x311c2875, -707 },
523 { 0xd77485cb, 0x25823ac7, 0x7d633293, -704 },
524 { 0x86a8d39e, 0xf77164bc, 0xae5dff9c, -700 },
525 { 0xa8530886, 0xb54dbdeb, 0xd9f57f83, -697 },
526 { 0xd267caa8, 0x62a12d66, 0xd072df63, -694 },
527 { 0x8380dea9, 0x3da4bc60, 0x4247cb9e, -690 },
528 { 0xa4611653, 0x8d0deb78, 0x52d9be85, -687 },
529 { 0xcd795be8, 0x70516656, 0x67902e27, -684 },
530 { 0x806bd971, 0x4632dff6, 0x00ba1cd8, -680 },
531 { 0xa086cfcd, 0x97bf97f3, 0x80e8a40e, -677 },
532 { 0xc8a883c0, 0xfdaf7df0, 0x6122cd12, -674 },
533 { 0xfad2a4b1, 0x3d1b5d6c, 0x796b8057, -671 },
534 { 0x9cc3a6ee, 0xc6311a63, 0xcbe33036, -667 },
535 { 0xc3f490aa, 0x77bd60fc, 0xbedbfc44, -664 },
536 { 0xf4f1b4d5, 0x15acb93b, 0xee92fb55, -661 },
537 { 0x99171105, 0x2d8bf3c5, 0x751bdd15, -657 },
538 { 0xbf5cd546, 0x78eef0b6, 0xd262d45a, -654 },
539 { 0xef340a98, 0x172aace4, 0x86fb8971, -651 },
540 { 0x9580869f, 0x0e7aac0e, 0xd45d35e6, -647 },
541 { 0xbae0a846, 0xd2195712, 0x89748360, -644 },
542 { 0xe998d258, 0x869facd7, 0x2bd1a438, -641 },
543 { 0x91ff8377, 0x5423cc06, 0x7b6306a3, -637 },
544 { 0xb67f6455, 0x292cbf08, 0x1a3bc84c, -634 },
545 { 0xe41f3d6a, 0x7377eeca, 0x20caba5f, -631 },
546 { 0x8e938662, 0x882af53e, 0x547eb47b, -627 },
547 { 0xb23867fb, 0x2a35b28d, 0xe99e619a, -624 },
548 { 0xdec681f9, 0xf4c31f31, 0x6405fa00, -621 },
549 { 0x8b3c113c, 0x38f9f37e, 0xde83bc40, -617 },
550 { 0xae0b158b, 0x4738705e, 0x9624ab50, -614 },
551 { 0xd98ddaee, 0x19068c76, 0x3badd624, -611 },
552 { 0x87f8a8d4, 0xcfa417c9, 0xe54ca5d7, -607 },
553 { 0xa9f6d30a, 0x038d1dbc, 0x5e9fcf4c, -604 },
554 { 0xd47487cc, 0x8470652b, 0x7647c320, -601 },
555 { 0x84c8d4df, 0xd2c63f3b, 0x29ecd9f4, -597 },
556 { 0xa5fb0a17, 0xc777cf09, 0xf4681071, -594 },
557 { 0xcf79cc9d, 0xb955c2cc, 0x7182148d, -591 },
558 { 0x81ac1fe2, 0x93d599bf, 0xc6f14cd8, -587 },
559 { 0xa21727db, 0x38cb002f, 0xb8ada00e, -584 },
560 { 0xca9cf1d2, 0x06fdc03b, 0xa6d90811, -581 },
561 { 0xfd442e46, 0x88bd304a, 0x908f4a16, -578 },
562 { 0x9e4a9cec, 0x15763e2e, 0x9a598e4e, -574 },
563 { 0xc5dd4427, 0x1ad3cdba, 0x40eff1e1, -571 },
564 { 0xf7549530, 0xe188c128, 0xd12bee59, -568 },
565 { 0x9a94dd3e, 0x8cf578b9, 0x82bb74f8, -564 },
566 { 0xc13a148e, 0x3032d6e7, 0xe36a5236, -561 },
567 { 0xf18899b1, 0xbc3f8ca1, 0xdc44e6c3, -558 },
568 { 0x96f5600f, 0x15a7b7e5, 0x29ab103a, -554 },
569 { 0xbcb2b812, 0xdb11a5de, 0x7415d448, -551 },
570 { 0xebdf6617, 0x91d60f56, 0x111b495b, -548 },
571 { 0x936b9fce, 0xbb25c995, 0xcab10dd9, -544 },
572 { 0xb84687c2, 0x69ef3bfb, 0x3d5d514f, -541 },
573 { 0xe65829b3, 0x046b0afa, 0x0cb4a5a3, -538 },
574 { 0x8ff71a0f, 0xe2c2e6dc, 0x47f0e785, -534 },
575 { 0xb3f4e093, 0xdb73a093, 0x59ed2167, -531 },
576 { 0xe0f218b8, 0xd25088b8, 0x306869c1, -528 },
577 { 0x8c974f73, 0x83725573, 0x1e414218, -524 },
578 { 0xafbd2350, 0x644eeacf, 0xe5d1929e, -521 },
579 { 0xdbac6c24, 0x7d62a583, 0xdf45f746, -518 },
580 { 0x894bc396, 0xce5da772, 0x6b8bba8c, -514 },
581 { 0xab9eb47c, 0x81f5114f, 0x066ea92f, -511 },
582 { 0xd686619b, 0xa27255a2, 0xc80a537b, -508 },
583 { 0x8613fd01, 0x45877585, 0xbd06742c, -504 },
584 { 0xa798fc41, 0x96e952e7, 0x2c481138, -501 },
585 { 0xd17f3b51, 0xfca3a7a0, 0xf75a1586, -498 },
586 { 0x82ef8513, 0x3de648c4, 0x9a984d73, -494 },
587 { 0xa3ab6658, 0x0d5fdaf5, 0xc13e60d0, -491 },
588 { 0xcc963fee, 0x10b7d1b3, 0x318df905, -488 },
589 { 0xffbbcfe9, 0x94e5c61f, 0xfdf17746, -485 },
590 { 0x9fd561f1, 0xfd0f9bd3, 0xfeb6ea8b, -481 },
591 { 0xc7caba6e, 0x7c5382c8, 0xfe64a52e, -478 },
592 { 0xf9bd690a, 0x1b68637b, 0x3dfdce7a, -475 },
593 { 0x9c1661a6, 0x51213e2d, 0x06bea10c, -471 },
594 { 0xc31bfa0f, 0xe5698db8, 0x486e494f, -468 },
595 { 0xf3e2f893, 0xdec3f126, 0x5a89dba3, -465 },
596 { 0x986ddb5c, 0x6b3a76b7, 0xf8962946, -461 },
597 { 0xbe895233, 0x86091465, 0xf6bbb397, -458 },
598 { 0xee2ba6c0, 0x678b597f, 0x746aa07d, -455 },
599 { 0x94db4838, 0x40b717ef, 0xa8c2a44e, -451 },
600 { 0xba121a46, 0x50e4ddeb, 0x92f34d62, -448 },
601 { 0xe896a0d7, 0xe51e1566, 0x77b020ba, -445 },
602 { 0x915e2486, 0xef32cd60, 0x0ace1474, -441 },
603 { 0xb5b5ada8, 0xaaff80b8, 0x0d819992, -438 },
604 { 0xe3231912, 0xd5bf60e6, 0x10e1fff6, -435 },
605 { 0x8df5efab, 0xc5979c8f, 0xca8d3ffa, -431 },
606 { 0xb1736b96, 0xb6fd83b3, 0xbd308ff8, -428 },
607 { 0xddd0467c, 0x64bce4a0, 0xac7cb3f6, -425 },
608 { 0x8aa22c0d, 0xbef60ee4, 0x6bcdf07a, -421 },
609 { 0xad4ab711, 0x2eb3929d, 0x86c16c98, -418 },
610 { 0xd89d64d5, 0x7a607744, 0xe871c7bf, -415 },
611 { 0x87625f05, 0x6c7c4a8b, 0x11471cd7, -411 },
612 { 0xa93af6c6, 0xc79b5d2d, 0xd598e40d, -408 },
613 { 0xd389b478, 0x79823479, 0x4aff1d10, -405 },
614 { 0x843610cb, 0x4bf160cb, 0xcedf722a, -401 },
615 { 0xa54394fe, 0x1eedb8fe, 0xc2974eb4, -398 },
616 { 0xce947a3d, 0xa6a9273e, 0x733d2262, -395 },
617 { 0x811ccc66, 0x8829b887, 0x0806357d, -391 },
618 { 0xa163ff80, 0x2a3426a8, 0xca07c2dc, -388 },
619 { 0xc9bcff60, 0x34c13052, 0xfc89b393, -385 },
620 { 0xfc2c3f38, 0x41f17c67, 0xbbac2078, -382 },
621 { 0x9d9ba783, 0x2936edc0, 0xd54b944b, -378 },
622 { 0xc5029163, 0xf384a931, 0x0a9e795e, -375 },
623 { 0xf64335bc, 0xf065d37d, 0x4d4617b5, -372 },
624 { 0x99ea0196, 0x163fa42e, 0x504bced1, -368 },
625 { 0xc06481fb, 0x9bcf8d39, 0xe45ec286, -365 },
626 { 0xf07da27a, 0x82c37088, 0x5d767327, -362 },
627 { 0x964e858c, 0x91ba2655, 0x3a6a07f8, -358 },
628 { 0xbbe226ef, 0xb628afea, 0x890489f7, -355 },
629 { 0xeadab0ab, 0xa3b2dbe5, 0x2b45ac74, -352 },
630 { 0x92c8ae6b, 0x464fc96f, 0x3b0b8bc9, -348 },
631 { 0xb77ada06, 0x17e3bbcb, 0x09ce6ebb, -345 },
632 { 0xe5599087, 0x9ddcaabd, 0xcc420a6a, -342 },
633 { 0x8f57fa54, 0xc2a9eab6, 0x9fa94682, -338 },
634 { 0xb32df8e9, 0xf3546564, 0x47939822, -335 },
635 { 0xdff97724, 0x70297ebd, 0x59787e2b, -332 },
636 { 0x8bfbea76, 0xc619ef36, 0x57eb4edb, -328 },
637 { 0xaefae514, 0x77a06b03, 0xede62292, -325 },
638 { 0xdab99e59, 0x958885c4, 0xe95fab36, -322 },
639 { 0x88b402f7, 0xfd75539b, 0x11dbcb02, -318 },
640 { 0xaae103b5, 0xfcd2a881, 0xd652bdc2, -315 },
641 { 0xd59944a3, 0x7c0752a2, 0x4be76d33, -312 },
642 { 0x857fcae6, 0x2d8493a5, 0x6f70a440, -308 },
643 { 0xa6dfbd9f, 0xb8e5b88e, 0xcb4ccd50, -305 },
644 { 0xd097ad07, 0xa71f26b2, 0x7e2000a4, -302 },
645 { 0x825ecc24, 0xc873782f, 0x8ed40066, -298 },
646 { 0xa2f67f2d, 0xfa90563b, 0x72890080, -295 },
647 { 0xcbb41ef9, 0x79346bca, 0x4f2b40a0, -292 },
648 { 0xfea126b7, 0xd78186bc, 0xe2f610c8, -289 },
649 { 0x9f24b832, 0xe6b0f436, 0x0dd9ca7d, -285 },
650 { 0xc6ede63f, 0xa05d3143, 0x91503d1c, -282 },
651 { 0xf8a95fcf, 0x88747d94, 0x75a44c63, -279 },
652 { 0x9b69dbe1, 0xb548ce7c, 0xc986afbe, -275 },
653 { 0xc24452da, 0x229b021b, 0xfbe85bad, -272 },
654 { 0xf2d56790, 0xab41c2a2, 0xfae27299, -269 },
655 { 0x97c560ba, 0x6b0919a5, 0xdccd879f, -265 },
656 { 0xbdb6b8e9, 0x05cb600f, 0x5400e987, -262 },
657 { 0xed246723, 0x473e3813, 0x290123e9, -259 },
658 { 0x9436c076, 0x0c86e30b, 0xf9a0b672, -255 },
659 { 0xb9447093, 0x8fa89bce, 0xf808e40e, -252 },
660 { 0xe7958cb8, 0x7392c2c2, 0xb60b1d12, -249 },
661 { 0x90bd77f3, 0x483bb9b9, 0xb1c6f22b, -245 },
662 { 0xb4ecd5f0, 0x1a4aa828, 0x1e38aeb6, -242 },
663 { 0xe2280b6c, 0x20dd5232, 0x25c6da63, -239 },
664 { 0x8d590723, 0x948a535f, 0x579c487e, -235 },
665 { 0xb0af48ec, 0x79ace837, 0x2d835a9d, -232 },
666 { 0xdcdb1b27, 0x98182244, 0xf8e43145, -229 },
667 { 0x8a08f0f8, 0xbf0f156b, 0x1b8e9ecb, -225 },
668 { 0xac8b2d36, 0xeed2dac5, 0xe272467e, -222 },
669 { 0xd7adf884, 0xaa879177, 0x5b0ed81d, -219 },
670 { 0x86ccbb52, 0xea94baea, 0x98e94712, -215 },
671 { 0xa87fea27, 0xa539e9a5, 0x3f2398d7, -212 },
672 { 0xd29fe4b1, 0x8e88640e, 0x8eec7f0d, -209 },
673 { 0x83a3eeee, 0xf9153e89, 0x1953cf68, -205 },
674 { 0xa48ceaaa, 0xb75a8e2b, 0x5fa8c342, -202 },
675 { 0xcdb02555, 0x653131b6, 0x3792f412, -199 },
676 { 0x808e1755, 0x5f3ebf11, 0xe2bbd88b, -195 },
677 { 0xa0b19d2a, 0xb70e6ed6, 0x5b6aceae, -192 },
678 { 0xc8de0475, 0x64d20a8b, 0xf245825a, -189 },
679 { 0xfb158592, 0xbe068d2e, 0xeed6e2f0, -186 },
680 { 0x9ced737b, 0xb6c4183d, 0x55464dd6, -182 },
681 { 0xc428d05a, 0xa4751e4c, 0xaa97e14c, -179 },
682 { 0xf5330471, 0x4d9265df, 0xd53dd99f, -176 },
683 { 0x993fe2c6, 0xd07b7fab, 0xe546a803, -172 },
684 { 0xbf8fdb78, 0x849a5f96, 0xde985204, -169 },
685 { 0xef73d256, 0xa5c0f77c, 0x963e6685, -166 },
686 { 0x95a86376, 0x27989aad, 0xdde70013, -162 },
687 { 0xbb127c53, 0xb17ec159, 0x5560c018, -159 },
688 { 0xe9d71b68, 0x9dde71af, 0xaab8f01e, -156 },
689 { 0x92267121, 0x62ab070d, 0xcab39613, -152 },
690 { 0xb6b00d69, 0xbb55c8d1, 0x3d607b97, -149 },
691 { 0xe45c10c4, 0x2a2b3b05, 0x8cb89a7d, -146 },
692 { 0x8eb98a7a, 0x9a5b04e3, 0x77f3608e, -142 },
693 { 0xb267ed19, 0x40f1c61c, 0x55f038b2, -139 },
694 { 0xdf01e85f, 0x912e37a3, 0x6b6c46de, -136 },
695 { 0x8b61313b, 0xbabce2c6, 0x2323ac4b, -132 },
696 { 0xae397d8a, 0xa96c1b77, 0xabec975e, -129 },
697 { 0xd9c7dced, 0x53c72255, 0x96e7bd35, -126 },
698 { 0x881cea14, 0x545c7575, 0x7e50d641, -122 },
699 { 0xaa242499, 0x697392d2, 0xdde50bd1, -119 },
700 { 0xd4ad2dbf, 0xc3d07787, 0x955e4ec6, -116 },
701 { 0x84ec3c97, 0xda624ab4, 0xbd5af13b, -112 },
702 { 0xa6274bbd, 0xd0fadd61, 0xecb1ad8a, -109 },
703 { 0xcfb11ead, 0x453994ba, 0x67de18ed, -106 },
704 { 0x81ceb32c, 0x4b43fcf4, 0x80eacf94, -102 },
705 { 0xa2425ff7, 0x5e14fc31, 0xa1258379, -99 },
706 { 0xcad2f7f5, 0x359a3b3e, 0x096ee458, -96 },
707 { 0xfd87b5f2, 0x8300ca0d, 0x8bca9d6e, -93 },
708 { 0x9e74d1b7, 0x91e07e48, 0x775ea264, -89 },
709 { 0xc6120625, 0x76589dda, 0x95364afe, -86 },
710 { 0xf79687ae, 0xd3eec551, 0x3a83ddbd, -83 },
711 { 0x9abe14cd, 0x44753b52, 0xc4926a96, -79 },
712 { 0xc16d9a00, 0x95928a27, 0x75b7053c, -76 },
713 { 0xf1c90080, 0xbaf72cb1, 0x5324c68b, -73 },
714 { 0x971da050, 0x74da7bee, 0xd3f6fc16, -69 },
715 { 0xbce50864, 0x92111aea, 0x88f4bb1c, -66 },
716 { 0xec1e4a7d, 0xb69561a5, 0x2b31e9e3, -63 },
717 { 0x9392ee8e, 0x921d5d07, 0x3aff322e, -59 },
718 { 0xb877aa32, 0x36a4b449, 0x09befeb9, -56 },
719 { 0xe69594be, 0xc44de15b, 0x4c2ebe68, -53 },
720 { 0x901d7cf7, 0x3ab0acd9, 0x0f9d3701, -49 },
721 { 0xb424dc35, 0x095cd80f, 0x538484c1, -46 },
722 { 0xe12e1342, 0x4bb40e13, 0x2865a5f2, -43 },
723 { 0x8cbccc09, 0x6f5088cb, 0xf93f87b7, -39 },
724 { 0xafebff0b, 0xcb24aafe, 0xf78f69a5, -36 },
725 { 0xdbe6fece, 0xbdedd5be, 0xb573440e, -33 },
726 { 0x89705f41, 0x36b4a597, 0x31680a88, -29 },
727 { 0xabcc7711, 0x8461cefc, 0xfdc20d2b, -26 },
728 { 0xd6bf94d5, 0xe57a42bc, 0x3d329076, -23 },
729 { 0x8637bd05, 0xaf6c69b5, 0xa63f9a49, -19 },
730 { 0xa7c5ac47, 0x1b478423, 0x0fcf80dc, -16 },
731 { 0xd1b71758, 0xe219652b, 0xd3c36113, -13 },
732 { 0x83126e97, 0x8d4fdf3b, 0x645a1cac, -9 },
733 { 0xa3d70a3d, 0x70a3d70a, 0x3d70a3d7, -6 },
734 { 0xcccccccc, 0xcccccccc, 0xcccccccc, -3 },
735 { 0x80000000, 0x00000000, 0x00000000, 1 },
736 { 0xa0000000, 0x00000000, 0x00000000, 4 },
737 { 0xc8000000, 0x00000000, 0x00000000, 7 },
738 { 0xfa000000, 0x00000000, 0x00000000, 10 },
739 { 0x9c400000, 0x00000000, 0x00000000, 14 },
740 { 0xc3500000, 0x00000000, 0x00000000, 17 },
741 { 0xf4240000, 0x00000000, 0x00000000, 20 },
742 { 0x98968000, 0x00000000, 0x00000000, 24 },
743 { 0xbebc2000, 0x00000000, 0x00000000, 27 },
744 { 0xee6b2800, 0x00000000, 0x00000000, 30 },
745 { 0x9502f900, 0x00000000, 0x00000000, 34 },
746 { 0xba43b740, 0x00000000, 0x00000000, 37 },
747 { 0xe8d4a510, 0x00000000, 0x00000000, 40 },
748 { 0x9184e72a, 0x00000000, 0x00000000, 44 },
749 { 0xb5e620f4, 0x80000000, 0x00000000, 47 },
750 { 0xe35fa931, 0xa0000000, 0x00000000, 50 },
751 { 0x8e1bc9bf, 0x04000000, 0x00000000, 54 },
752 { 0xb1a2bc2e, 0xc5000000, 0x00000000, 57 },
753 { 0xde0b6b3a, 0x76400000, 0x00000000, 60 },
754 { 0x8ac72304, 0x89e80000, 0x00000000, 64 },
755 { 0xad78ebc5, 0xac620000, 0x00000000, 67 },
756 { 0xd8d726b7, 0x177a8000, 0x00000000, 70 },
757 { 0x87867832, 0x6eac9000, 0x00000000, 74 },
758 { 0xa968163f, 0x0a57b400, 0x00000000, 77 },
759 { 0xd3c21bce, 0xcceda100, 0x00000000, 80 },
760 { 0x84595161, 0x401484a0, 0x00000000, 84 },
761 { 0xa56fa5b9, 0x9019a5c8, 0x00000000, 87 },
762 { 0xcecb8f27, 0xf4200f3a, 0x00000000, 90 },
763 { 0x813f3978, 0xf8940984, 0x40000000, 94 },
764 { 0xa18f07d7, 0x36b90be5, 0x50000000, 97 },
765 { 0xc9f2c9cd, 0x04674ede, 0xa4000000, 100 },
766 { 0xfc6f7c40, 0x45812296, 0x4d000000, 103 },
767 { 0x9dc5ada8, 0x2b70b59d, 0xf0200000, 107 },
768 { 0xc5371912, 0x364ce305, 0x6c280000, 110 },
769 { 0xf684df56, 0xc3e01bc6, 0xc7320000, 113 },
770 { 0x9a130b96, 0x3a6c115c, 0x3c7f4000, 117 },
771 { 0xc097ce7b, 0xc90715b3, 0x4b9f1000, 120 },
772 { 0xf0bdc21a, 0xbb48db20, 0x1e86d400, 123 },
773 { 0x96769950, 0xb50d88f4, 0x13144480, 127 },
774 { 0xbc143fa4, 0xe250eb31, 0x17d955a0, 130 },
775 { 0xeb194f8e, 0x1ae525fd, 0x5dcfab08, 133 },
776 { 0x92efd1b8, 0xd0cf37be, 0x5aa1cae5, 137 },
777 { 0xb7abc627, 0x050305ad, 0xf14a3d9e, 140 },
778 { 0xe596b7b0, 0xc643c719, 0x6d9ccd05, 143 },
779 { 0x8f7e32ce, 0x7bea5c6f, 0xe4820023, 147 },
780 { 0xb35dbf82, 0x1ae4f38b, 0xdda2802c, 150 },
781 { 0xe0352f62, 0xa19e306e, 0xd50b2037, 153 },
782 { 0x8c213d9d, 0xa502de45, 0x4526f422, 157 },
783 { 0xaf298d05, 0x0e4395d6, 0x9670b12b, 160 },
784 { 0xdaf3f046, 0x51d47b4c, 0x3c0cdd76, 163 },
785 { 0x88d8762b, 0xf324cd0f, 0xa5880a69, 167 },
786 { 0xab0e93b6, 0xefee0053, 0x8eea0d04, 170 },
787 { 0xd5d238a4, 0xabe98068, 0x72a49045, 173 },
788 { 0x85a36366, 0xeb71f041, 0x47a6da2b, 177 },
789 { 0xa70c3c40, 0xa64e6c51, 0x999090b6, 180 },
790 { 0xd0cf4b50, 0xcfe20765, 0xfff4b4e3, 183 },
791 { 0x82818f12, 0x81ed449f, 0xbff8f10e, 187 },
792 { 0xa321f2d7, 0x226895c7, 0xaff72d52, 190 },
793 { 0xcbea6f8c, 0xeb02bb39, 0x9bf4f8a6, 193 },
794 { 0xfee50b70, 0x25c36a08, 0x02f236d0, 196 },
795 { 0x9f4f2726, 0x179a2245, 0x01d76242, 200 },
796 { 0xc722f0ef, 0x9d80aad6, 0x424d3ad2, 203 },
797 { 0xf8ebad2b, 0x84e0d58b, 0xd2e08987, 206 },
798 { 0x9b934c3b, 0x330c8577, 0x63cc55f4, 210 },
799 { 0xc2781f49, 0xffcfa6d5, 0x3cbf6b71, 213 },
800 { 0xf316271c, 0x7fc3908a, 0x8bef464e, 216 },
801 { 0x97edd871, 0xcfda3a56, 0x97758bf0, 220 },
802 { 0xbde94e8e, 0x43d0c8ec, 0x3d52eeed, 223 },
803 { 0xed63a231, 0xd4c4fb27, 0x4ca7aaa8, 226 },
804 { 0x945e455f, 0x24fb1cf8, 0x8fe8caa9, 230 },
805 { 0xb975d6b6, 0xee39e436, 0xb3e2fd53, 233 },
806 { 0xe7d34c64, 0xa9c85d44, 0x60dbbca8, 236 },
807 { 0x90e40fbe, 0xea1d3a4a, 0xbc8955e9, 240 },
808 { 0xb51d13ae, 0xa4a488dd, 0x6babab63, 243 },
809 { 0xe264589a, 0x4dcdab14, 0xc696963c, 246 },
810 { 0x8d7eb760, 0x70a08aec, 0xfc1e1de5, 250 },
811 { 0xb0de6538, 0x8cc8ada8, 0x3b25a55f, 253 },
812 { 0xdd15fe86, 0xaffad912, 0x49ef0eb7, 256 },
813 { 0x8a2dbf14, 0x2dfcc7ab, 0x6e356932, 260 },
814 { 0xacb92ed9, 0x397bf996, 0x49c2c37f, 263 },
815 { 0xd7e77a8f, 0x87daf7fb, 0xdc33745e, 266 },
816 { 0x86f0ac99, 0xb4e8dafd, 0x69a028bb, 270 },
817 { 0xa8acd7c0, 0x222311bc, 0xc40832ea, 273 },
818 { 0xd2d80db0, 0x2aabd62b, 0xf50a3fa4, 276 },
819 { 0x83c7088e, 0x1aab65db, 0x792667c6, 280 },
820 { 0xa4b8cab1, 0xa1563f52, 0x577001b8, 283 },
821 { 0xcde6fd5e, 0x09abcf26, 0xed4c0226, 286 },
822 { 0x80b05e5a, 0xc60b6178, 0x544f8158, 290 },
823 { 0xa0dc75f1, 0x778e39d6, 0x696361ae, 293 },
824 { 0xc913936d, 0xd571c84c, 0x03bc3a19, 296 },
825 { 0xfb587849, 0x4ace3a5f, 0x04ab48a0, 299 },
826 { 0x9d174b2d, 0xcec0e47b, 0x62eb0d64, 303 },
827 { 0xc45d1df9, 0x42711d9a, 0x3ba5d0bd, 306 },
828 { 0xf5746577, 0x930d6500, 0xca8f44ec, 309 },
829 { 0x9968bf6a, 0xbbe85f20, 0x7e998b13, 313 },
830 { 0xbfc2ef45, 0x6ae276e8, 0x9e3fedd8, 316 },
831 { 0xefb3ab16, 0xc59b14a2, 0xc5cfe94e, 319 },
832 { 0x95d04aee, 0x3b80ece5, 0xbba1f1d1, 323 },
833 { 0xbb445da9, 0xca61281f, 0x2a8a6e45, 326 },
834 { 0xea157514, 0x3cf97226, 0xf52d09d7, 329 },
835 { 0x924d692c, 0xa61be758, 0x593c2626, 333 },
836 { 0xb6e0c377, 0xcfa2e12e, 0x6f8b2fb0, 336 },
837 { 0xe498f455, 0xc38b997a, 0x0b6dfb9c, 339 },
838 { 0x8edf98b5, 0x9a373fec, 0x4724bd41, 343 },
839 { 0xb2977ee3, 0x00c50fe7, 0x58edec91, 346 },
840 { 0xdf3d5e9b, 0xc0f653e1, 0x2f2967b6, 349 },
841 { 0x8b865b21, 0x5899f46c, 0xbd79e0d2, 353 },
842 { 0xae67f1e9, 0xaec07187, 0xecd85906, 356 },
843 { 0xda01ee64, 0x1a708de9, 0xe80e6f48, 359 },
844 { 0x884134fe, 0x908658b2, 0x3109058d, 363 },
845 { 0xaa51823e, 0x34a7eede, 0xbd4b46f0, 366 },
846 { 0xd4e5e2cd, 0xc1d1ea96, 0x6c9e18ac, 369 },
847 { 0x850fadc0, 0x9923329e, 0x03e2cf6b, 373 },
848 { 0xa6539930, 0xbf6bff45, 0x84db8346, 376 },
849 { 0xcfe87f7c, 0xef46ff16, 0xe6126418, 379 },
850 { 0x81f14fae, 0x158c5f6e, 0x4fcb7e8f, 383 },
851 { 0xa26da399, 0x9aef7749, 0xe3be5e33, 386 },
852 { 0xcb090c80, 0x01ab551c, 0x5cadf5bf, 389 },
853 { 0xfdcb4fa0, 0x02162a63, 0x73d9732f, 392 },
854 { 0x9e9f11c4, 0x014dda7e, 0x2867e7fd, 396 },
855 { 0xc646d635, 0x01a1511d, 0xb281e1fd, 399 },
856 { 0xf7d88bc2, 0x4209a565, 0x1f225a7c, 402 },
857 { 0x9ae75759, 0x6946075f, 0x3375788d, 406 },
858 { 0xc1a12d2f, 0xc3978937, 0x0052d6b1, 409 },
859 { 0xf209787b, 0xb47d6b84, 0xc0678c5d, 412 },
860 { 0x9745eb4d, 0x50ce6332, 0xf840b7ba, 416 },
861 { 0xbd176620, 0xa501fbff, 0xb650e5a9, 419 },
862 { 0xec5d3fa8, 0xce427aff, 0xa3e51f13, 422 },
863 { 0x93ba47c9, 0x80e98cdf, 0xc66f336c, 426 },
864 { 0xb8a8d9bb, 0xe123f017, 0xb80b0047, 429 },
865 { 0xe6d3102a, 0xd96cec1d, 0xa60dc059, 432 },
866 { 0x9043ea1a, 0xc7e41392, 0x87c89837, 436 },
867 { 0xb454e4a1, 0x79dd1877, 0x29babe45, 439 },
868 { 0xe16a1dc9, 0xd8545e94, 0xf4296dd6, 442 },
869 { 0x8ce2529e, 0x2734bb1d, 0x1899e4a6, 446 },
870 { 0xb01ae745, 0xb101e9e4, 0x5ec05dcf, 449 },
871 { 0xdc21a117, 0x1d42645d, 0x76707543, 452 },
872 { 0x899504ae, 0x72497eba, 0x6a06494a, 456 },
873 { 0xabfa45da, 0x0edbde69, 0x0487db9d, 459 },
874 { 0xd6f8d750, 0x9292d603, 0x45a9d284, 462 },
875 { 0x865b8692, 0x5b9bc5c2, 0x0b8a2392, 466 },
876 { 0xa7f26836, 0xf282b732, 0x8e6cac77, 469 },
877 { 0xd1ef0244, 0xaf2364ff, 0x3207d795, 472 },
878 { 0x8335616a, 0xed761f1f, 0x7f44e6bd, 476 },
879 { 0xa402b9c5, 0xa8d3a6e7, 0x5f16206c, 479 },
880 { 0xcd036837, 0x130890a1, 0x36dba887, 482 },
881 { 0x80222122, 0x6be55a64, 0xc2494954, 486 },
882 { 0xa02aa96b, 0x06deb0fd, 0xf2db9baa, 489 },
883 { 0xc83553c5, 0xc8965d3d, 0x6f928294, 492 },
884 { 0xfa42a8b7, 0x3abbf48c, 0xcb772339, 495 },
885 { 0x9c69a972, 0x84b578d7, 0xff2a7604, 499 },
886 { 0xc38413cf, 0x25e2d70d, 0xfef51385, 502 },
887 { 0xf46518c2, 0xef5b8cd1, 0x7eb25866, 505 },
888 { 0x98bf2f79, 0xd5993802, 0xef2f773f, 509 },
889 { 0xbeeefb58, 0x4aff8603, 0xaafb550f, 512 },
890 { 0xeeaaba2e, 0x5dbf6784, 0x95ba2a53, 515 },
891 { 0x952ab45c, 0xfa97a0b2, 0xdd945a74, 519 },
892 { 0xba756174, 0x393d88df, 0x94f97111, 522 },
893 { 0xe912b9d1, 0x478ceb17, 0x7a37cd56, 525 },
894 { 0x91abb422, 0xccb812ee, 0xac62e055, 529 },
895 { 0xb616a12b, 0x7fe617aa, 0x577b986b, 532 },
896 { 0xe39c4976, 0x5fdf9d94, 0xed5a7e85, 535 },
897 { 0x8e41ade9, 0xfbebc27d, 0x14588f13, 539 },
898 { 0xb1d21964, 0x7ae6b31c, 0x596eb2d8, 542 },
899 { 0xde469fbd, 0x99a05fe3, 0x6fca5f8e, 545 },
900 { 0x8aec23d6, 0x80043bee, 0x25de7bb9, 549 },
901 { 0xada72ccc, 0x20054ae9, 0xaf561aa7, 552 },
902 { 0xd910f7ff, 0x28069da4, 0x1b2ba151, 555 },
903 { 0x87aa9aff, 0x79042286, 0x90fb44d2, 559 },
904 { 0xa99541bf, 0x57452b28, 0x353a1607, 562 },
905 { 0xd3fa922f, 0x2d1675f2, 0x42889b89, 565 },
906 { 0x847c9b5d, 0x7c2e09b7, 0x69956135, 569 },
907 { 0xa59bc234, 0xdb398c25, 0x43fab983, 572 },
908 { 0xcf02b2c2, 0x1207ef2e, 0x94f967e4, 575 },
909 { 0x8161afb9, 0x4b44f57d, 0x1d1be0ee, 579 },
910 { 0xa1ba1ba7, 0x9e1632dc, 0x6462d92a, 582 },
911 { 0xca28a291, 0x859bbf93, 0x7d7b8f75, 585 },
912 { 0xfcb2cb35, 0xe702af78, 0x5cda7352, 588 },
913 { 0x9defbf01, 0xb061adab, 0x3a088813, 592 },
914 { 0xc56baec2, 0x1c7a1916, 0x088aaa18, 595 },
915 { 0xf6c69a72, 0xa3989f5b, 0x8aad549e, 598 },
916 { 0x9a3c2087, 0xa63f6399, 0x36ac54e2, 602 },
917 { 0xc0cb28a9, 0x8fcf3c7f, 0x84576a1b, 605 },
918 { 0xf0fdf2d3, 0xf3c30b9f, 0x656d44a2, 608 },
919 { 0x969eb7c4, 0x7859e743, 0x9f644ae5, 612 },
920 { 0xbc4665b5, 0x96706114, 0x873d5d9f, 615 },
921 { 0xeb57ff22, 0xfc0c7959, 0xa90cb506, 618 },
922 { 0x9316ff75, 0xdd87cbd8, 0x09a7f124, 622 },
923 { 0xb7dcbf53, 0x54e9bece, 0x0c11ed6d, 625 },
924 { 0xe5d3ef28, 0x2a242e81, 0x8f1668c8, 628 },
925 { 0x8fa47579, 0x1a569d10, 0xf96e017d, 632 },
926 { 0xb38d92d7, 0x60ec4455, 0x37c981dc, 635 },
927 { 0xe070f78d, 0x3927556a, 0x85bbe253, 638 },
928 { 0x8c469ab8, 0x43b89562, 0x93956d74, 642 },
929 { 0xaf584166, 0x54a6babb, 0x387ac8d1, 645 },
930 { 0xdb2e51bf, 0xe9d0696a, 0x06997b05, 648 },
931 { 0x88fcf317, 0xf22241e2, 0x441fece3, 652 },
932 { 0xab3c2fdd, 0xeeaad25a, 0xd527e81c, 655 },
933 { 0xd60b3bd5, 0x6a5586f1, 0x8a71e223, 658 },
934 { 0x85c70565, 0x62757456, 0xf6872d56, 662 },
935 { 0xa738c6be, 0xbb12d16c, 0xb428f8ac, 665 },
936 { 0xd106f86e, 0x69d785c7, 0xe13336d7, 668 },
937 { 0x82a45b45, 0x0226b39c, 0xecc00246, 672 },
938 { 0xa34d7216, 0x42b06084, 0x27f002d7, 675 },
939 { 0xcc20ce9b, 0xd35c78a5, 0x31ec038d, 678 },
940 { 0xff290242, 0xc83396ce, 0x7e670471, 681 },
941 { 0x9f79a169, 0xbd203e41, 0x0f0062c6, 685 },
942 { 0xc75809c4, 0x2c684dd1, 0x52c07b78, 688 },
943 { 0xf92e0c35, 0x37826145, 0xa7709a56, 691 },
944 { 0x9bbcc7a1, 0x42b17ccb, 0x88a66076, 695 },
945 { 0xc2abf989, 0x935ddbfe, 0x6acff893, 698 },
946 { 0xf356f7eb, 0xf83552fe, 0x0583f6b8, 701 },
947 { 0x98165af3, 0x7b2153de, 0xc3727a33, 705 },
948 { 0xbe1bf1b0, 0x59e9a8d6, 0x744f18c0, 708 },
949 { 0xeda2ee1c, 0x7064130c, 0x1162def0, 711 },
950 { 0x9485d4d1, 0xc63e8be7, 0x8addcb56, 715 },
951 { 0xb9a74a06, 0x37ce2ee1, 0x6d953e2b, 718 },
952 { 0xe8111c87, 0xc5c1ba99, 0xc8fa8db6, 721 },
953 { 0x910ab1d4, 0xdb9914a0, 0x1d9c9892, 725 },
954 { 0xb54d5e4a, 0x127f59c8, 0x2503beb6, 728 },
955 { 0xe2a0b5dc, 0x971f303a, 0x2e44ae64, 731 },
956 { 0x8da471a9, 0xde737e24, 0x5ceaecfe, 735 },
957 { 0xb10d8e14, 0x56105dad, 0x7425a83e, 738 },
958 { 0xdd50f199, 0x6b947518, 0xd12f124e, 741 },
959 { 0x8a5296ff, 0xe33cc92f, 0x82bd6b70, 745 },
960 { 0xace73cbf, 0xdc0bfb7b, 0x636cc64d, 748 },
961 { 0xd8210bef, 0xd30efa5a, 0x3c47f7e0, 751 },
962 { 0x8714a775, 0xe3e95c78, 0x65acfaec, 755 },
963 { 0xa8d9d153, 0x5ce3b396, 0x7f1839a7, 758 },
964 { 0xd31045a8, 0x341ca07c, 0x1ede4811, 761 },
965 { 0x83ea2b89, 0x2091e44d, 0x934aed0a, 765 },
966 { 0xa4e4b66b, 0x68b65d60, 0xf81da84d, 768 },
967 { 0xce1de406, 0x42e3f4b9, 0x36251260, 771 },
968 { 0x80d2ae83, 0xe9ce78f3, 0xc1d72b7c, 775 },
969 { 0xa1075a24, 0xe4421730, 0xb24cf65b, 778 },
970 { 0xc94930ae, 0x1d529cfc, 0xdee033f2, 781 },
971 { 0xfb9b7cd9, 0xa4a7443c, 0x169840ef, 784 },
972 { 0x9d412e08, 0x06e88aa5, 0x8e1f2895, 788 },
973 { 0xc491798a, 0x08a2ad4e, 0xf1a6f2ba, 791 },
974 { 0xf5b5d7ec, 0x8acb58a2, 0xae10af69, 794 },
975 { 0x9991a6f3, 0xd6bf1765, 0xacca6da1, 798 },
976 { 0xbff610b0, 0xcc6edd3f, 0x17fd090a, 801 },
977 { 0xeff394dc, 0xff8a948e, 0xddfc4b4c, 804 },
978 { 0x95f83d0a, 0x1fb69cd9, 0x4abdaf10, 808 },
979 { 0xbb764c4c, 0xa7a4440f, 0x9d6d1ad4, 811 },
980 { 0xea53df5f, 0xd18d5513, 0x84c86189, 814 },
981 { 0x92746b9b, 0xe2f8552c, 0x32fd3cf5, 818 },
982 { 0xb7118682, 0xdbb66a77, 0x3fbc8c33, 821 },
983 { 0xe4d5e823, 0x92a40515, 0x0fabaf3f, 824 },
984 { 0x8f05b116, 0x3ba6832d, 0x29cb4d87, 828 },
985 { 0xb2c71d5b, 0xca9023f8, 0x743e20e9, 831 },
986 { 0xdf78e4b2, 0xbd342cf6, 0x914da924, 834 },
987 { 0x8bab8eef, 0xb6409c1a, 0x1ad089b6, 838 },
988 { 0xae9672ab, 0xa3d0c320, 0xa184ac24, 841 },
989 { 0xda3c0f56, 0x8cc4f3e8, 0xc9e5d72d, 844 },
990 { 0x88658996, 0x17fb1871, 0x7e2fa67c, 848 },
991 { 0xaa7eebfb, 0x9df9de8d, 0xddbb901b, 851 },
992 { 0xd51ea6fa, 0x85785631, 0x552a7422, 854 },
993 { 0x8533285c, 0x936b35de, 0xd53a8895, 858 },
994 { 0xa67ff273, 0xb8460356, 0x8a892aba, 861 },
995 { 0xd01fef10, 0xa657842c, 0x2d2b7569, 864 },
996 { 0x8213f56a, 0x67f6b29b, 0x9c3b2962, 868 },
997 { 0xa298f2c5, 0x01f45f42, 0x8349f3ba, 871 },
998 { 0xcb3f2f76, 0x42717713, 0x241c70a9, 874 },
999 { 0xfe0efb53, 0xd30dd4d7, 0xed238cd3, 877 },
1000 { 0x9ec95d14, 0x63e8a506, 0xf4363804, 881 },
1001 { 0xc67bb459, 0x7ce2ce48, 0xb143c605, 884 },
1002 { 0xf81aa16f, 0xdc1b81da, 0xdd94b786, 887 },
1003 { 0x9b10a4e5, 0xe9913128, 0xca7cf2b4, 891 },
1004 { 0xc1d4ce1f, 0x63f57d72, 0xfd1c2f61, 894 },
1005 { 0xf24a01a7, 0x3cf2dccf, 0xbc633b39, 897 },
1006 { 0x976e4108, 0x8617ca01, 0xd5be0503, 901 },
1007 { 0xbd49d14a, 0xa79dbc82, 0x4b2d8644, 904 },
1008 { 0xec9c459d, 0x51852ba2, 0xddf8e7d6, 907 },
1009 { 0x93e1ab82, 0x52f33b45, 0xcabb90e5, 911 },
1010 { 0xb8da1662, 0xe7b00a17, 0x3d6a751f, 914 },
1011 { 0xe7109bfb, 0xa19c0c9d, 0x0cc51267, 917 },
1012 { 0x906a617d, 0x450187e2, 0x27fb2b80, 921 },
1013 { 0xb484f9dc, 0x9641e9da, 0xb1f9f660, 924 },
1014 { 0xe1a63853, 0xbbd26451, 0x5e7873f8, 927 },
1015 { 0x8d07e334, 0x55637eb2, 0xdb0b487b, 931 },
1016 { 0xb049dc01, 0x6abc5e5f, 0x91ce1a9a, 934 },
1017 { 0xdc5c5301, 0xc56b75f7, 0x7641a140, 937 },
1018 { 0x89b9b3e1, 0x1b6329ba, 0xa9e904c8, 941 },
1019 { 0xac2820d9, 0x623bf429, 0x546345fa, 944 },
1020 { 0xd732290f, 0xbacaf133, 0xa97c1779, 947 },
1021 { 0x867f59a9, 0xd4bed6c0, 0x49ed8eab, 951 },
1022 { 0xa81f3014, 0x49ee8c70, 0x5c68f256, 954 },
1023 { 0xd226fc19, 0x5c6a2f8c, 0x73832eec, 957 },
1024 { 0x83585d8f, 0xd9c25db7, 0xc831fd53, 961 },
1025 { 0xa42e74f3, 0xd032f525, 0xba3e7ca8, 964 },
1026 { 0xcd3a1230, 0xc43fb26f, 0x28ce1bd2, 967 },
1027 { 0x80444b5e, 0x7aa7cf85, 0x7980d163, 971 },
1028 { 0xa0555e36, 0x1951c366, 0xd7e105bc, 974 },
1029 { 0xc86ab5c3, 0x9fa63440, 0x8dd9472b, 977 },
1030 { 0xfa856334, 0x878fc150, 0xb14f98f6, 980 },
1031 { 0x9c935e00, 0xd4b9d8d2, 0x6ed1bf9a, 984 },
1032 { 0xc3b83581, 0x09e84f07, 0x0a862f80, 987 },
1033 { 0xf4a642e1, 0x4c6262c8, 0xcd27bb61, 990 },
1034 { 0x98e7e9cc, 0xcfbd7dbd, 0x8038d51c, 994 },
1035 { 0xbf21e440, 0x03acdd2c, 0xe0470a63, 997 },
1036 { 0xeeea5d50, 0x04981478, 0x1858ccfc, 1000 },
1037 { 0x95527a52, 0x02df0ccb, 0x0f37801e, 1004 },
1038 { 0xbaa718e6, 0x8396cffd, 0xd3056025, 1007 },
1039 { 0xe950df20, 0x247c83fd, 0x47c6b82e, 1010 },
1040 { 0x91d28b74, 0x16cdd27e, 0x4cdc331d, 1014 },
1041 { 0xb6472e51, 0x1c81471d, 0xe0133fe4, 1017 },
1042 { 0xe3d8f9e5, 0x63a198e5, 0x58180fdd, 1020 },
1043 { 0x8e679c2f, 0x5e44ff8f, 0x570f09ea, 1024 },
1044 { 0xb201833b, 0x35d63f73, 0x2cd2cc65, 1027 },
1045 { 0xde81e40a, 0x034bcf4f, 0xf8077f7e, 1030 },
1046 { 0x8b112e86, 0x420f6191, 0xfb04afaf, 1034 },
1047 { 0xadd57a27, 0xd29339f6, 0x79c5db9a, 1037 },
1048 { 0xd94ad8b1, 0xc7380874, 0x18375281, 1040 },
1049 { 0x87cec76f, 0x1c830548, 0x8f229391, 1044 },
1050 { 0xa9c2794a, 0xe3a3c69a, 0xb2eb3875, 1047 },
1051 { 0xd433179d, 0x9c8cb841, 0x5fa60692, 1050 },
1052 { 0x849feec2, 0x81d7f328, 0xdbc7c41b, 1054 },
1053 { 0xa5c7ea73, 0x224deff3, 0x12b9b522, 1057 },
1054 { 0xcf39e50f, 0xeae16bef, 0xd768226b, 1060 },
1055 { 0x81842f29, 0xf2cce375, 0xe6a11583, 1064 },
1056 { 0xa1e53af4, 0x6f801c53, 0x60495ae3, 1067 },
1057 { 0xca5e89b1, 0x8b602368, 0x385bb19c, 1070 },
1058 { 0xfcf62c1d, 0xee382c42, 0x46729e03, 1073 },
1059 { 0x9e19db92, 0xb4e31ba9, 0x6c07a2c2, 1077 }
1060 };
1061 static short int Lhint[2098] = {
1062 /*18,*/19, 19, 19, 19, 20, 20, 20, 21, 21,
1063 21, 22, 22, 22, 23, 23, 23, 23, 24, 24,
1064 24, 25, 25, 25, 26, 26, 26, 26, 27, 27,
1065 27, 28, 28, 28, 29, 29, 29, 29, 30, 30,
1066 30, 31, 31, 31, 32, 32, 32, 32, 33, 33,
1067 33, 34, 34, 34, 35, 35, 35, 35, 36, 36,
1068 36, 37, 37, 37, 38, 38, 38, 38, 39, 39,
1069 39, 40, 40, 40, 41, 41, 41, 41, 42, 42,
1070 42, 43, 43, 43, 44, 44, 44, 44, 45, 45,
1071 45, 46, 46, 46, 47, 47, 47, 47, 48, 48,
1072 48, 49, 49, 49, 50, 50, 50, 51, 51, 51,
1073 51, 52, 52, 52, 53, 53, 53, 54, 54, 54,
1074 54, 55, 55, 55, 56, 56, 56, 57, 57, 57,
1075 57, 58, 58, 58, 59, 59, 59, 60, 60, 60,
1076 60, 61, 61, 61, 62, 62, 62, 63, 63, 63,
1077 63, 64, 64, 64, 65, 65, 65, 66, 66, 66,
1078 66, 67, 67, 67, 68, 68, 68, 69, 69, 69,
1079 69, 70, 70, 70, 71, 71, 71, 72, 72, 72,
1080 72, 73, 73, 73, 74, 74, 74, 75, 75, 75,
1081 75, 76, 76, 76, 77, 77, 77, 78, 78, 78,
1082 78, 79, 79, 79, 80, 80, 80, 81, 81, 81,
1083 82, 82, 82, 82, 83, 83, 83, 84, 84, 84,
1084 85, 85, 85, 85, 86, 86, 86, 87, 87, 87,
1085 88, 88, 88, 88, 89, 89, 89, 90, 90, 90,
1086 91, 91, 91, 91, 92, 92, 92, 93, 93, 93,
1087 94, 94, 94, 94, 95, 95, 95, 96, 96, 96,
1088 97, 97, 97, 97, 98, 98, 98, 99, 99, 99,
1089 100, 100, 100, 100, 101, 101, 101, 102, 102, 102,
1090 103, 103, 103, 103, 104, 104, 104, 105, 105, 105,
1091 106, 106, 106, 106, 107, 107, 107, 108, 108, 108,
1092 109, 109, 109, 110, 110, 110, 110, 111, 111, 111,
1093 112, 112, 112, 113, 113, 113, 113, 114, 114, 114,
1094 115, 115, 115, 116, 116, 116, 116, 117, 117, 117,
1095 118, 118, 118, 119, 119, 119, 119, 120, 120, 120,
1096 121, 121, 121, 122, 122, 122, 122, 123, 123, 123,
1097 124, 124, 124, 125, 125, 125, 125, 126, 126, 126,
1098 127, 127, 127, 128, 128, 128, 128, 129, 129, 129,
1099 130, 130, 130, 131, 131, 131, 131, 132, 132, 132,
1100 133, 133, 133, 134, 134, 134, 134, 135, 135, 135,
1101 136, 136, 136, 137, 137, 137, 137, 138, 138, 138,
1102 139, 139, 139, 140, 140, 140, 141, 141, 141, 141,
1103 142, 142, 142, 143, 143, 143, 144, 144, 144, 144,
1104 145, 145, 145, 146, 146, 146, 147, 147, 147, 147,
1105 148, 148, 148, 149, 149, 149, 150, 150, 150, 150,
1106 151, 151, 151, 152, 152, 152, 153, 153, 153, 153,
1107 154, 154, 154, 155, 155, 155, 156, 156, 156, 156,
1108 157, 157, 157, 158, 158, 158, 159, 159, 159, 159,
1109 160, 160, 160, 161, 161, 161, 162, 162, 162, 162,
1110 163, 163, 163, 164, 164, 164, 165, 165, 165, 165,
1111 166, 166, 166, 167, 167, 167, 168, 168, 168, 169,
1112 169, 169, 169, 170, 170, 170, 171, 171, 171, 172,
1113 172, 172, 172, 173, 173, 173, 174, 174, 174, 175,
1114 175, 175, 175, 176, 176, 176, 177, 177, 177, 178,
1115 178, 178, 178, 179, 179, 179, 180, 180, 180, 181,
1116 181, 181, 181, 182, 182, 182, 183, 183, 183, 184,
1117 184, 184, 184, 185, 185, 185, 186, 186, 186, 187,
1118 187, 187, 187, 188, 188, 188, 189, 189, 189, 190,
1119 190, 190, 190, 191, 191, 191, 192, 192, 192, 193,
1120 193, 193, 193, 194, 194, 194, 195, 195, 195, 196,
1121 196, 196, 197, 197, 197, 197, 198, 198, 198, 199,
1122 199, 199, 200, 200, 200, 200, 201, 201, 201, 202,
1123 202, 202, 203, 203, 203, 203, 204, 204, 204, 205,
1124 205, 205, 206, 206, 206, 206, 207, 207, 207, 208,
1125 208, 208, 209, 209, 209, 209, 210, 210, 210, 211,
1126 211, 211, 212, 212, 212, 212, 213, 213, 213, 214,
1127 214, 214, 215, 215, 215, 215, 216, 216, 216, 217,
1128 217, 217, 218, 218, 218, 218, 219, 219, 219, 220,
1129 220, 220, 221, 221, 221, 221, 222, 222, 222, 223,
1130 223, 223, 224, 224, 224, 224, 225, 225, 225, 226,
1131 226, 226, 227, 227, 227, 228, 228, 228, 228, 229,
1132 229, 229, 230, 230, 230, 231, 231, 231, 231, 232,
1133 232, 232, 233, 233, 233, 234, 234, 234, 234, 235,
1134 235, 235, 236, 236, 236, 237, 237, 237, 237, 238,
1135 238, 238, 239, 239, 239, 240, 240, 240, 240, 241,
1136 241, 241, 242, 242, 242, 243, 243, 243, 243, 244,
1137 244, 244, 245, 245, 245, 246, 246, 246, 246, 247,
1138 247, 247, 248, 248, 248, 249, 249, 249, 249, 250,
1139 250, 250, 251, 251, 251, 252, 252, 252, 252, 253,
1140 253, 253, 254, 254, 254, 255, 255, 255, 256, 256,
1141 256, 256, 257, 257, 257, 258, 258, 258, 259, 259,
1142 259, 259, 260, 260, 260, 261, 261, 261, 262, 262,
1143 262, 262, 263, 263, 263, 264, 264, 264, 265, 265,
1144 265, 265, 266, 266, 266, 267, 267, 267, 268, 268,
1145 268, 268, 269, 269, 269, 270, 270, 270, 271, 271,
1146 271, 271, 272, 272, 272, 273, 273, 273, 274, 274,
1147 274, 274, 275, 275, 275, 276, 276, 276, 277, 277,
1148 277, 277, 278, 278, 278, 279, 279, 279, 280, 280,
1149 280, 280, 281, 281, 281, 282, 282, 282, 283, 283,
1150 283, 283, 284, 284, 284, 285, 285, 285, 286, 286,
1151 286, 287, 287, 287, 287, 288, 288, 288, 289, 289,
1152 289, 290, 290, 290, 290, 291, 291, 291, 292, 292,
1153 292, 293, 293, 293, 293, 294, 294, 294, 295, 295,
1154 295, 296, 296, 296, 296, 297, 297, 297, 298, 298,
1155 298, 299, 299, 299, 299, 300, 300, 300, 301, 301,
1156 301, 302, 302, 302, 302, 303, 303, 303, 304, 304,
1157 304, 305, 305, 305, 305, 306, 306, 306, 307, 307,
1158 307, 308, 308, 308, 308, 309, 309, 309, 310, 310,
1159 310, 311, 311, 311, 311, 312, 312, 312, 313, 313,
1160 313, 314, 314, 314, 315, 315, 315, 315, 316, 316,
1161 316, 317, 317, 317, 318, 318, 318, 318, 319, 319,
1162 319, 320, 320, 320, 321, 321, 321, 321, 322, 322,
1163 322, 323, 323, 323, 324, 324, 324, 324, 325, 325,
1164 325, 326, 326, 326, 327, 327, 327, 327, 328, 328,
1165 328, 329, 329, 329, 330, 330, 330, 330, 331, 331,
1166 331, 332, 332, 332, 333, 333, 333, 333, 334, 334,
1167 334, 335, 335, 335, 336, 336, 336, 336, 337, 337,
1168 337, 338, 338, 338, 339, 339, 339, 339, 340, 340,
1169 340, 341, 341, 341, 342, 342, 342, 342, 343, 343,
1170 343, 344, 344, 344, 345, 345, 345, 346, 346, 346,
1171 346, 347, 347, 347, 348, 348, 348, 349, 349, 349,
1172 349, 350, 350, 350, 351, 351, 351, 352, 352, 352,
1173 352, 353, 353, 353, 354, 354, 354, 355, 355, 355,
1174 355, 356, 356, 356, 357, 357, 357, 358, 358, 358,
1175 358, 359, 359, 359, 360, 360, 360, 361, 361, 361,
1176 361, 362, 362, 362, 363, 363, 363, 364, 364, 364,
1177 364, 365, 365, 365, 366, 366, 366, 367, 367, 367,
1178 367, 368, 368, 368, 369, 369, 369, 370, 370, 370,
1179 370, 371, 371, 371, 372, 372, 372, 373, 373, 373,
1180 374, 374, 374, 374, 375, 375, 375, 376, 376, 376,
1181 377, 377, 377, 377, 378, 378, 378, 379, 379, 379,
1182 380, 380, 380, 380, 381, 381, 381, 382, 382, 382,
1183 383, 383, 383, 383, 384, 384, 384, 385, 385, 385,
1184 386, 386, 386, 386, 387, 387, 387, 388, 388, 388,
1185 389, 389, 389, 389, 390, 390, 390, 391, 391, 391,
1186 392, 392, 392, 392, 393, 393, 393, 394, 394, 394,
1187 395, 395, 395, 395, 396, 396, 396, 397, 397, 397,
1188 398, 398, 398, 398, 399, 399, 399, 400, 400, 400,
1189 401, 401, 401, 402, 402, 402, 402, 403, 403, 403,
1190 404, 404, 404, 405, 405, 405, 405, 406, 406, 406,
1191 407, 407, 407, 408, 408, 408, 408, 409, 409, 409,
1192 410, 410, 410, 411, 411, 411, 411, 412, 412, 412,
1193 413, 413, 413, 414, 414, 414, 414, 415, 415, 415,
1194 416, 416, 416, 417, 417, 417, 417, 418, 418, 418,
1195 419, 419, 419, 420, 420, 420, 420, 421, 421, 421,
1196 422, 422, 422, 423, 423, 423, 423, 424, 424, 424,
1197 425, 425, 425, 426, 426, 426, 426, 427, 427, 427,
1198 428, 428, 428, 429, 429, 429, 429, 430, 430, 430,
1199 431, 431, 431, 432, 432, 432, 433, 433, 433, 433,
1200 434, 434, 434, 435, 435, 435, 436, 436, 436, 436,
1201 437, 437, 437, 438, 438, 438, 439, 439, 439, 439,
1202 440, 440, 440, 441, 441, 441, 442, 442, 442, 442,
1203 443, 443, 443, 444, 444, 444, 445, 445, 445, 445,
1204 446, 446, 446, 447, 447, 447, 448, 448, 448, 448,
1205 449, 449, 449, 450, 450, 450, 451, 451, 451, 451,
1206 452, 452, 452, 453, 453, 453, 454, 454, 454, 454,
1207 455, 455, 455, 456, 456, 456, 457, 457, 457, 457,
1208 458, 458, 458, 459, 459, 459, 460, 460, 460, 461,
1209 461, 461, 461, 462, 462, 462, 463, 463, 463, 464,
1210 464, 464, 464, 465, 465, 465, 466, 466, 466, 467,
1211 467, 467, 467, 468, 468, 468, 469, 469, 469, 470,
1212 470, 470, 470, 471, 471, 471, 472, 472, 472, 473,
1213 473, 473, 473, 474, 474, 474, 475, 475, 475, 476,
1214 476, 476, 476, 477, 477, 477, 478, 478, 478, 479,
1215 479, 479, 479, 480, 480, 480, 481, 481, 481, 482,
1216 482, 482, 482, 483, 483, 483, 484, 484, 484, 485,
1217 485, 485, 485, 486, 486, 486, 487, 487, 487, 488,
1218 488, 488, 488, 489, 489, 489, 490, 490, 490, 491,
1219 491, 491, 492, 492, 492, 492, 493, 493, 493, 494,
1220 494, 494, 495, 495, 495, 495, 496, 496, 496, 497,
1221 497, 497, 498, 498, 498, 498, 499, 499, 499, 500,
1222 500, 500, 501, 501, 501, 501, 502, 502, 502, 503,
1223 503, 503, 504, 504, 504, 504, 505, 505, 505, 506,
1224 506, 506, 507, 507, 507, 507, 508, 508, 508, 509,
1225 509, 509, 510, 510, 510, 510, 511, 511, 511, 512,
1226 512, 512, 513, 513, 513, 513, 514, 514, 514, 515,
1227 515, 515, 516, 516, 516, 516, 517, 517, 517, 518,
1228 518, 518, 519, 519, 519, 520, 520, 520, 520, 521,
1229 521, 521, 522, 522, 522, 523, 523, 523, 523, 524,
1230 524, 524, 525, 525, 525, 526, 526, 526, 526, 527,
1231 527, 527, 528, 528, 528, 529, 529, 529, 529, 530,
1232 530, 530, 531, 531, 531, 532, 532, 532, 532, 533,
1233 533, 533, 534, 534, 534, 535, 535, 535, 535, 536,
1234 536, 536, 537, 537, 537, 538, 538, 538, 538, 539,
1235 539, 539, 540, 540, 540, 541, 541, 541, 541, 542,
1236 542, 542, 543, 543, 543, 544, 544, 544, 544, 545,
1237 545, 545, 546, 546, 546, 547, 547, 547, 548, 548,
1238 548, 548, 549, 549, 549, 550, 550, 550, 551, 551,
1239 551, 551, 552, 552, 552, 553, 553, 553, 554, 554,
1240 554, 554, 555, 555, 555, 556, 556, 556, 557, 557,
1241 557, 557, 558, 558, 558, 559, 559, 559, 560, 560,
1242 560, 560, 561, 561, 561, 562, 562, 562, 563, 563,
1243 563, 563, 564, 564, 564, 565, 565, 565, 566, 566,
1244 566, 566, 567, 567, 567, 568, 568, 568, 569, 569,
1245 569, 569, 570, 570, 570, 571, 571, 571, 572, 572,
1246 572, 572, 573, 573, 573, 574, 574, 574, 575, 575,
1247 575, 575, 576, 576, 576, 577, 577, 577, 578, 578,
1248 578, 579, 579, 579, 579, 580, 580, 580, 581, 581,
1249 581, 582, 582, 582, 582, 583, 583, 583, 584, 584,
1250 584, 585, 585, 585, 585, 586, 586, 586, 587, 587,
1251 587, 588, 588, 588, 588, 589, 589, 589, 590, 590,
1252 590, 591, 591, 591, 591, 592, 592, 592, 593, 593,
1253 593, 594, 594, 594, 594, 595, 595, 595, 596, 596,
1254 596, 597, 597, 597, 597, 598, 598, 598, 599, 599,
1255 599, 600, 600, 600, 600, 601, 601, 601, 602, 602,
1256 602, 603, 603, 603, 603, 604, 604, 604, 605, 605,
1257 605, 606, 606, 606, 607, 607, 607, 607, 608, 608,
1258 608, 609, 609, 609, 610, 610, 610, 610, 611, 611,
1259 611, 612, 612, 612, 613, 613, 613, 613, 614, 614,
1260 614, 615, 615, 615, 616, 616, 616, 616, 617, 617,
1261 617, 618, 618, 618, 619, 619, 619, 619, 620, 620,
1262 620, 621, 621, 621, 622, 622, 622, 622, 623, 623,
1263 623, 624, 624, 624, 625, 625, 625, 625, 626, 626,
1264 626, 627, 627, 627, 628, 628, 628, 628, 629, 629,
1265 629, 630, 630, 630, 631, 631, 631, 631, 632, 632,
1266 632, 633, 633, 633, 634, 634, 634, 634, 635, 635,
1267 635, 636, 636, 636, 637, 637, 637, 638, 638, 638,
1268 638, 639, 639, 639, 640, 640, 640, 641, 641, 641,
1269 641, 642, 642, 642, 643, 643, 643, 644, 644, 644,
1270 644, 645, 645, 645, 646, 646, 646, 647, 647, 647,
1271 647, 648, 648, 648, 649, 649, 649, 650, 650 };
1272 static ULLongunsigned long long pfive[27] = {
1273 5ll,
1274 25ll,
1275 125ll,
1276 625ll,
1277 3125ll,
1278 15625ll,
1279 78125ll,
1280 390625ll,
1281 1953125ll,
1282 9765625ll,
1283 48828125ll,
1284 244140625ll,
1285 1220703125ll,
1286 6103515625ll,
1287 30517578125ll,
1288 152587890625ll,
1289 762939453125ll,
1290 3814697265625ll,
1291 19073486328125ll,
1292 95367431640625ll,
1293 476837158203125ll,
1294 2384185791015625ll,
1295 11920928955078125ll,
1296 59604644775390625ll,
1297 298023223876953125ll,
1298 1490116119384765625ll,
1299 7450580596923828125ll
1300 };
1301
1302 static int pfivebits[25] = {3, 5, 7, 10, 12, 14, 17, 19, 21, 24, 26, 28, 31,
1303 33, 35, 38, 40, 42, 45, 47, 49, 52, 54, 56, 59};
1304#endif /*}*/
1305#endif /*}} NO_LONG_LONG */
1306
1307typedef union { double d; ULong L[2];
1308#ifdef USE_BF96
1309 ULLongunsigned long long LL;
1310#endif
1311 } U;
1312
1313#ifdef IEEE_8087
1314#define word0(x)(x)->L[1] (x)->L[1]
1315#define word1(x)(x)->L[0] (x)->L[0]
1316#else
1317#define word0(x)(x)->L[1] (x)->L[0]
1318#define word1(x)(x)->L[0] (x)->L[1]
1319#endif
1320#define dval(x)(x)->d (x)->d
1321#define LLval(x)(x)->LL (x)->LL
1322
1323#ifndef STRTOD_DIGLIM40
1324#define STRTOD_DIGLIM40 40
1325#endif
1326
1327#ifdef DIGLIM_DEBUG
1328extern int strtod_diglim40;
1329#else
1330#define strtod_diglim40 STRTOD_DIGLIM40
1331#endif
1332
1333/* The following definition of Storeinc is appropriate for MIPS processors.
1334 * An alternative that might be better on some machines is
1335 * #define Storeinc(a,b,c) (*a++ = b << 16 | c & 0xffff)
1336 */
1337#if defined(IEEE_8087) + defined(VAX)
1338#define Storeinc(a,b,c)(((unsigned short *)a)[1] = (unsigned short)b, ((unsigned short
*)a)[0] = (unsigned short)c, a++) (((unsigned short *)a)[1] = (unsigned short)b, \
1339((unsigned short *)a)[0] = (unsigned short)c, a++)
1340#else
1341#define Storeinc(a,b,c)(((unsigned short *)a)[1] = (unsigned short)b, ((unsigned short
*)a)[0] = (unsigned short)c, a++) (((unsigned short *)a)[0] = (unsigned short)b, \
1342((unsigned short *)a)[1] = (unsigned short)c, a++)
1343#endif
1344
1345/* #define P DBL_MANT_DIG */
1346/* Ten_pmax = floor(P*log(2)/log(5)) */
1347/* Bletch = (highest power of 2 < DBL_MAX_10_EXP) / 16 */
1348/* Quick_max = floor((P-1)*log(FLT_RADIX)/log(10) - 1) */
1349/* Int_max = floor(P*log(FLT_RADIX)/log(10) - 1) */
1350
1351#ifdef IEEE_Arith
1352#define Exp_shift20 20
1353#define Exp_shift120 20
1354#define Exp_msk10x100000 0x100000
1355#define Exp_msk110x100000 0x100000
1356#define Exp_mask0x7ff00000 0x7ff00000
1357#define P53 53
1358#define Nbits53 53
1359#define Bias1023 1023
1360#define Emax1023 1023
1361#define Emin(-1022) (-1022)
1362#define Exp_10x3ff00000 0x3ff00000
1363#define Exp_110x3ff00000 0x3ff00000
1364#define Ebits11 11
1365#define Frac_mask0xfffff 0xfffff
1366#define Frac_mask10xfffff 0xfffff
1367#define Ten_pmax22 22
1368#define Bletch0x10 0x10
1369#define Bndry_mask0xfffff 0xfffff
1370#define Bndry_mask10xfffff 0xfffff
1371#define LSB1 1
1372#define Sign_bit0x80000000 0x80000000
1373#define Log2P1 1
1374#define Tiny00 0
1375#define Tiny11 1
1376#define Quick_max14 14
1377#define Int_max14 14
1378#ifndef NO_IEEE_Scale
1379#define Avoid_Underflow
1380#ifdef Flush_Denorm /* debugging option */
1381#undef Sudden_Underflow
1382#endif
1383#endif
1384
1385#ifndef Flt_Rounds(__builtin_flt_rounds())
1386#ifdef FLT_ROUNDS(__builtin_flt_rounds())
1387#define Flt_Rounds(__builtin_flt_rounds()) FLT_ROUNDS(__builtin_flt_rounds())
1388#else
1389#define Flt_Rounds(__builtin_flt_rounds()) 1
1390#endif
1391#endif /*Flt_Rounds*/
1392
1393#ifdef Honor_FLT_ROUNDS
1394#undef Check_FLT_ROUNDS
1395#define Check_FLT_ROUNDS
1396#else
1397#define Rounding(__builtin_flt_rounds()) Flt_Rounds(__builtin_flt_rounds())
1398#endif
1399
1400#else /* ifndef IEEE_Arith */
1401#undef Check_FLT_ROUNDS
1402#undef Honor_FLT_ROUNDS
1403#undef SET_INEXACT
1404#undef Sudden_Underflow
1405#define Sudden_Underflow
1406#ifdef IBM
1407#undef Flt_Rounds(__builtin_flt_rounds())
1408#define Flt_Rounds(__builtin_flt_rounds()) 0
1409#define Exp_shift20 24
1410#define Exp_shift120 24
1411#define Exp_msk10x100000 0x1000000
1412#define Exp_msk110x100000 0x1000000
1413#define Exp_mask0x7ff00000 0x7f000000
1414#define P53 14
1415#define Nbits53 56
1416#define Bias1023 65
1417#define Emax1023 248
1418#define Emin(-1022) (-260)
1419#define Exp_10x3ff00000 0x41000000
1420#define Exp_110x3ff00000 0x41000000
1421#define Ebits11 8 /* exponent has 7 bits, but 8 is the right value in b2d */
1422#define Frac_mask0xfffff 0xffffff
1423#define Frac_mask10xfffff 0xffffff
1424#define Bletch0x10 4
1425#define Ten_pmax22 22
1426#define Bndry_mask0xfffff 0xefffff
1427#define Bndry_mask10xfffff 0xffffff
1428#define LSB1 1
1429#define Sign_bit0x80000000 0x80000000
1430#define Log2P1 4
1431#define Tiny00 0x100000
1432#define Tiny11 0
1433#define Quick_max14 14
1434#define Int_max14 15
1435#else /* VAX */
1436#undef Flt_Rounds(__builtin_flt_rounds())
1437#define Flt_Rounds(__builtin_flt_rounds()) 1
1438#define Exp_shift20 23
1439#define Exp_shift120 7
1440#define Exp_msk10x100000 0x80
1441#define Exp_msk110x100000 0x800000
1442#define Exp_mask0x7ff00000 0x7f80
1443#define P53 56
1444#define Nbits53 56
1445#define Bias1023 129
1446#define Emax1023 126
1447#define Emin(-1022) (-129)
1448#define Exp_10x3ff00000 0x40800000
1449#define Exp_110x3ff00000 0x4080
1450#define Ebits11 8
1451#define Frac_mask0xfffff 0x7fffff
1452#define Frac_mask10xfffff 0xffff007f
1453#define Ten_pmax22 24
1454#define Bletch0x10 2
1455#define Bndry_mask0xfffff 0xffff007f
1456#define Bndry_mask10xfffff 0xffff007f
1457#define LSB1 0x10000
1458#define Sign_bit0x80000000 0x8000
1459#define Log2P1 1
1460#define Tiny00 0x80
1461#define Tiny11 0
1462#define Quick_max14 15
1463#define Int_max14 15
1464#endif /* IBM, VAX */
1465#endif /* IEEE_Arith */
1466
1467#ifndef IEEE_Arith
1468#define ROUND_BIASED
1469#else
1470#ifdef ROUND_BIASED_without_Round_Up
1471#undef ROUND_BIASED
1472#define ROUND_BIASED
1473#endif
1474#endif
1475
1476#ifdef RND_PRODQUOT
1477#define rounded_product(a,b)a *= b a = rnd_prod(a, b)
1478#define rounded_quotient(a,b)a /= b a = rnd_quot(a, b)
1479extern double rnd_prod(double, double), rnd_quot(double, double);
1480#else
1481#define rounded_product(a,b)a *= b a *= b
1482#define rounded_quotient(a,b)a /= b a /= b
1483#endif
1484
1485#define Big0(0xfffff | 0x100000*(1024 +1023 -1)) (Frac_mask10xfffff | Exp_msk10x100000*(DBL_MAX_EXP1024+Bias1023-1))
1486#define Big10xffffffff 0xffffffff
1487
1488#ifndef Pack_32
1489#define Pack_32
1490#endif
1491
1492typedef struct BCinfo BCinfo;
1493 struct
1494BCinfo { int dp0, dp1, dplen, dsign, e0, inexact, nd, nd0, rounding, scale, uflchk; };
1495
1496#define FFFFFFFF0xffffffffUL 0xffffffffUL
1497
1498#ifdef MULTIPLE_THREADS
1499#define MTa , PTI
1500#define MTb , &TI
1501#define MTd , ThInfo **PTI
1502static unsigned int maxthreads = 0;
1503#else
1504#define MTa /*nothing*/
1505#define MTb /*nothing*/
1506#define MTd /*nothing*/
1507#endif
1508
1509#define Kmax7 7
1510
1511#ifdef __cplusplus
1512extern "C" char *dtoa(double d, int mode, int ndigits,
1513 int *decpt, int *sign, char **rve);
1514#endif
1515
1516 struct
1517Bigint {
1518 struct Bigint *next;
1519 int k, maxwds, sign, wds;
1520 ULong x[1];
1521 };
1522
1523 typedef struct Bigint Bigint;
1524 typedef struct
1525ThInfo {
1526 Bigint *Freelist[Kmax7+1];
1527 Bigint *P5s;
1528 } ThInfo;
1529
1530 static ThInfo TI0;
1531
1532#ifdef MULTIPLE_THREADS
1533 static ThInfo *TI1;
1534 static int TI0_used;
1535
1536 void
1537set_max_dtoa_threads(unsigned int n)
1538{
1539 size_t L;
1540
1541 if (n > maxthreads) {
1542 L = n*sizeof(ThInfo);
1543 if (TI1) {
1544 TI1 = (ThInfo*)REALLOCg_realloc(TI1, L);
1545 memset(TI1 + maxthreads, 0, (n-maxthreads)*sizeof(ThInfo));
1546 }
1547 else {
1548 TI1 = (ThInfo*)MALLOCg_malloc(L);
1549 if (TI0_used) {
1550 memcpy(TI1, &TI0, sizeof(ThInfo));
1551 if (n > 1)
1552 memset(TI1 + 1, 0, L - sizeof(ThInfo));
1553 memset(&TI0, 0, sizeof(ThInfo));
1554 }
1555 else
1556 memset(TI1, 0, L);
1557 }
1558 maxthreads = n;
1559 }
1560 }
1561
1562 static ThInfo*
1563get_TI(void)
1564{
1565 unsigned int thno = dtoa_get_threadno();
1566 if (thno < maxthreads)
1567 return TI1 + thno;
1568 if (thno == 0)
1569 TI0_used = 1;
1570 return &TI0;
1571 }
1572#define freelistTI0.Freelist TI->Freelist
1573#define p5sTI0.P5s TI->P5s
1574#else
1575#define freelistTI0.Freelist TI0.Freelist
1576#define p5sTI0.P5s TI0.P5s
1577#endif
1578
1579 static Bigint *
1580Balloc(int k MTd)
1581{
1582 int x;
1583 Bigint *rv;
1584#ifndef Omit_Private_Memory
1585 unsigned int len;
1586#endif
1587#ifdef MULTIPLE_THREADS
1588 ThInfo *TI;
1589
1590 if (!(TI = *PTI))
1591 *PTI = TI = get_TI();
1592 if (TI == &TI0)
1593 ACQUIRE_DTOA_LOCK(0);
1594#endif
1595 /* The k > Kmax case does not need ACQUIRE_DTOA_LOCK(0), */
1596 /* but this case seems very unlikely. */
1597 if (k <= Kmax7 && (rv = freelistTI0.Freelist[k]))
1598 freelistTI0.Freelist[k] = rv->next;
1599 else {
1600 x = 1 << k;
1601#ifdef Omit_Private_Memory
1602 rv = (Bigint *)MALLOCg_malloc(sizeof(Bigint) + (x-1)*sizeof(ULong));
1603#else
1604 len = (sizeof(Bigint) + (x-1)*sizeof(ULong) + sizeof(double) - 1)
1605 /sizeof(double);
1606 if (k <= Kmax7 && pmem_next - private_mem + len <= (ssize_t)PRIVATE_mem((2304 +sizeof(double)-1)/sizeof(double))
1607#ifdef MULTIPLE_THREADS
1608 && TI == TI1
1609#endif
1610 ) {
1611 rv = (Bigint*)pmem_next;
1612 pmem_next += len;
1613 }
1614 else
1615 rv = (Bigint*)MALLOCg_malloc(len*sizeof(double));
1616#endif
1617 rv->k = k;
1618 rv->maxwds = x;
1619 }
1620#ifdef MULTIPLE_THREADS
1621 if (TI == &TI0)
1622 FREE_DTOA_LOCK(0);
1623#endif
1624 rv->sign = rv->wds = 0;
1625 return rv;
1626 }
1627
1628 static void
1629Bfree(Bigint *v MTd)
1630{
1631#ifdef MULTIPLE_THREADS
1632 ThInfo *TI;
1633#endif
1634 if (v) {
1635 if (v->k > Kmax7)
1636 FREEg_free((void*)v);
1637 else {
1638#ifdef MULTIPLE_THREADS
1639 if (!(TI = *PTI))
1640 *PTI = TI = get_TI();
1641 if (TI == &TI0)
1642 ACQUIRE_DTOA_LOCK(0);
1643#endif
1644 v->next = freelistTI0.Freelist[v->k];
1645 freelistTI0.Freelist[v->k] = v;
1646#ifdef MULTIPLE_THREADS
1647 if (TI == &TI0)
1648 FREE_DTOA_LOCK(0);
1649#endif
1650 }
1651 }
1652 }
1653
1654#define Bcopy(x,y)memcpy((char *)&x->sign, (char *)&y->sign, y->
wds*sizeof(int) + 2*sizeof(int)) memcpy((char *)&x->sign, (char *)&y->sign, \
1655y->wds*sizeof(Longint) + 2*sizeof(int))
1656
1657 static Bigint *
1658multadd(Bigint *b, int m, int a MTd) /* multiply by m and add a */
1659{
1660 int i, wds;
1661#ifdef ULLongunsigned long long
1662 ULong *x;
1663 ULLongunsigned long long carry, y;
1664#else
1665 ULong carry, *x, y;
1666#ifdef Pack_32
1667 ULong xi, z;
1668#endif
1669#endif
1670 Bigint *b1;
1671
1672 wds = b->wds;
1673 x = b->x;
1674 i = 0;
1675 carry = a;
1676 do {
1677#ifdef ULLongunsigned long long
1678 y = *x * (ULLongunsigned long long)m + carry;
1679 carry = y >> 32;
1680 *x++ = y & FFFFFFFF0xffffffffUL;
1681#else
1682#ifdef Pack_32
1683 xi = *x;
1684 y = (xi & 0xffff) * m + carry;
1685 z = (xi >> 16) * m + (y >> 16);
1686 carry = z >> 16;
1687 *x++ = (z << 16) + (y & 0xffff);
1688#else
1689 y = *x * m + carry;
1690 carry = y >> 16;
1691 *x++ = y & 0xffff;
1692#endif
1693#endif
1694 }
1695 while(++i < wds);
1696 if (carry) {
1697 if (wds >= b->maxwds) {
1698 b1 = Balloc(b->k+1 MTa);
1699 Bcopy(b1, b)memcpy((char *)&b1->sign, (char *)&b->sign, b->
wds*sizeof(int) + 2*sizeof(int));
1700 Bfree(b MTa);
1701 b = b1;
1702 }
1703 b->x[wds++] = (ULong)carry;
1704 b->wds = wds;
1705 }
1706 return b;
1707 }
1708
1709 static int
1710hi0bits(ULong x)
1711{
1712 int k = 0;
1713
1714 if (!(x & 0xffff0000)) {
1715 k = 16;
1716 x <<= 16;
1717 }
1718 if (!(x & 0xff000000)) {
1719 k += 8;
1720 x <<= 8;
1721 }
1722 if (!(x & 0xf0000000)) {
1723 k += 4;
1724 x <<= 4;
1725 }
1726 if (!(x & 0xc0000000)) {
1727 k += 2;
1728 x <<= 2;
1729 }
1730 if (!(x & 0x80000000)) {
1731 k++;
1732 if (!(x & 0x40000000))
1733 return 32;
1734 }
1735 return k;
1736 }
1737
1738 static int
1739lo0bits(ULong *y)
1740{
1741 int k;
1742 ULong x = *y;
1743
1744 if (x & 7) {
1745 if (x & 1)
1746 return 0;
1747 if (x & 2) {
1748 *y = x >> 1;
1749 return 1;
1750 }
1751 *y = x >> 2;
1752 return 2;
1753 }
1754 k = 0;
1755 if (!(x & 0xffff)) {
1756 k = 16;
1757 x >>= 16;
1758 }
1759 if (!(x & 0xff)) {
1760 k += 8;
1761 x >>= 8;
1762 }
1763 if (!(x & 0xf)) {
1764 k += 4;
1765 x >>= 4;
1766 }
1767 if (!(x & 0x3)) {
1768 k += 2;
1769 x >>= 2;
1770 }
1771 if (!(x & 1)) {
1772 k++;
1773 x >>= 1;
1774 if (!x)
1775 return 32;
1776 }
1777 *y = x;
1778 return k;
1779 }
1780
1781 static Bigint *
1782i2b(int i MTd)
1783{
1784 Bigint *b;
1785
1786 b = Balloc(1 MTa);
1787 b->x[0] = i;
1788 b->wds = 1;
1789 return b;
1790 }
1791
1792 static Bigint *
1793mult(Bigint *a, Bigint *b MTd)
1794{
1795 Bigint *c;
1796 int k, wa, wb, wc;
1797 ULong *x, *xa, *xae, *xb, *xbe, *xc, *xc0;
1798 ULong y;
1799#ifdef ULLongunsigned long long
1800 ULLongunsigned long long carry, z;
1801#else
1802 ULong carry, z;
1803#ifdef Pack_32
1804 ULong z2;
1805#endif
1806#endif
1807
1808 if (a->wds < b->wds) {
1809 c = a;
1810 a = b;
1811 b = c;
1812 }
1813 k = a->k;
1814 wa = a->wds;
1815 wb = b->wds;
1816 wc = wa + wb;
1817 if (wc > a->maxwds)
1818 k++;
1819 c = Balloc(k MTa);
1820 for(x = c->x, xa = x + wc; x < xa; x++)
1821 *x = 0;
1822 xa = a->x;
1823 xae = xa + wa;
1824 xb = b->x;
1825 xbe = xb + wb;
1826 xc0 = c->x;
1827#ifdef ULLongunsigned long long
1828 for(; xb < xbe; xc0++) {
1829 if ((y = *xb++)) {
1830 x = xa;
1831 xc = xc0;
1832 carry = 0;
1833 do {
1834 z = *x++ * (ULLongunsigned long long)y + *xc + carry;
1835 carry = z >> 32;
1836 *xc++ = z & FFFFFFFF0xffffffffUL;
1837 }
1838 while(x < xae);
1839 *xc = (ULong)carry;
1840 }
1841 }
1842#else
1843#ifdef Pack_32
1844 for(; xb < xbe; xb++, xc0++) {
1845 if ((y = *xb & 0xffff)) {
1846 x = xa;
1847 xc = xc0;
1848 carry = 0;
1849 do {
1850 z = (*x & 0xffff) * y + (*xc & 0xffff) + carry;
1851 carry = z >> 16;
1852 z2 = (*x++ >> 16) * y + (*xc >> 16) + carry;
1853 carry = z2 >> 16;
1854 Storeinc(xc, z2, z)(((unsigned short *)xc)[1] = (unsigned short)z2, ((unsigned short
*)xc)[0] = (unsigned short)z, xc++);
1855 }
1856 while(x < xae);
1857 *xc = carry;
1858 }
1859 if ((y = *xb >> 16)) {
1860 x = xa;
1861 xc = xc0;
1862 carry = 0;
1863 z2 = *xc;
1864 do {
1865 z = (*x & 0xffff) * y + (*xc >> 16) + carry;
1866 carry = z >> 16;
1867 Storeinc(xc, z, z2)(((unsigned short *)xc)[1] = (unsigned short)z, ((unsigned short
*)xc)[0] = (unsigned short)z2, xc++);
1868 z2 = (*x++ >> 16) * y + (*xc & 0xffff) + carry;
1869 carry = z2 >> 16;
1870 }
1871 while(x < xae);
1872 *xc = z2;
1873 }
1874 }
1875#else
1876 for(; xb < xbe; xc0++) {
1877 if (y = *xb++) {
1878 x = xa;
1879 xc = xc0;
1880 carry = 0;
1881 do {
1882 z = *x++ * y + *xc + carry;
1883 carry = z >> 16;
1884 *xc++ = z & 0xffff;
1885 }
1886 while(x < xae);
1887 *xc = carry;
1888 }
1889 }
1890#endif
1891#endif
1892 for(xc0 = c->x, xc = xc0 + wc; wc > 0 && !*--xc; --wc) ;
1893 c->wds = wc;
1894 return c;
1895 }
1896
1897 static Bigint *
1898pow5mult(Bigint *b, int k MTd)
1899{
1900 Bigint *b1, *p5, *p51;
1901#ifdef MULTIPLE_THREADS
1902 ThInfo *TI;
1903#endif
1904 int i;
1905 static int p05[3] = { 5, 25, 125 };
1906
1907 if ((i = k & 3))
1908 b = multadd(b, p05[i-1], 0 MTa);
1909
1910 if (!(k >>= 2))
1911 return b;
1912#ifdef MULTIPLE_THREADS
1913 if (!(TI = *PTI))
1914 *PTI = TI = get_TI();
1915#endif
1916 if (!(p5 = p5sTI0.P5s)) {
1917 /* first time */
1918#ifdef MULTIPLE_THREADS
1919 if (!(TI = *PTI))
1920 *PTI = TI = get_TI();
1921 if (TI == &TI0)
1922 ACQUIRE_DTOA_LOCK(1);
1923 if (!(p5 = p5sTI0.P5s)) {
1924 p5 = p5sTI0.P5s = i2b(625 MTa);
1925 p5->next = 0;
1926 }
1927 if (TI == &TI0)
1928 FREE_DTOA_LOCK(1);
1929#else
1930 p5 = p5sTI0.P5s = i2b(625 MTa);
1931 p5->next = 0;
1932#endif
1933 }
1934 for(;;) {
1935 if (k & 1) {
1936 b1 = mult(b, p5 MTa);
1937 Bfree(b MTa);
1938 b = b1;
1939 }
1940 if (!(k >>= 1))
1941 break;
1942 if (!(p51 = p5->next)) {
1943#ifdef MULTIPLE_THREADS
1944 if (!TI && !(TI = *PTI))
1945 *PTI = TI = get_TI();
1946 if (TI == &TI0)
1947 ACQUIRE_DTOA_LOCK(1);
1948 if (!(p51 = p5->next)) {
1949 p51 = p5->next = mult(p5,p5 MTa);
1950 p51->next = 0;
1951 }
1952 if (TI == &TI0)
1953 FREE_DTOA_LOCK(1);
1954#else
1955 p51 = p5->next = mult(p5,p5);
1956 p51->next = 0;
1957#endif
1958 }
1959 p5 = p51;
1960 }
1961 return b;
1962 }
1963
1964 static Bigint *
1965lshift(Bigint *b, int k MTd)
1966{
1967 int i, k1, n, n1;
1968 Bigint *b1;
1969 ULong *x, *x1, *xe, z;
1970
1971#ifdef Pack_32
1972 n = k >> 5;
1973#else
1974 n = k >> 4;
1975#endif
1976 k1 = b->k;
1977 n1 = n + b->wds + 1;
1978 for(i = b->maxwds; n1 > i; i <<= 1)
1979 k1++;
1980 b1 = Balloc(k1 MTa);
1981 x1 = b1->x;
1982 for(i = 0; i < n; i++)
1983 *x1++ = 0;
1984 x = b->x;
1985 xe = x + b->wds;
1986#ifdef Pack_32
1987 if (k &= 0x1f) {
1988 k1 = 32 - k;
1989 z = 0;
1990 do {
1991 *x1++ = *x << k | z;
1992 z = *x++ >> k1;
1993 }
1994 while(x < xe);
1995 if ((*x1 = z))
1996 ++n1;
1997 }
1998#else
1999 if (k &= 0xf) {
2000 k1 = 16 - k;
2001 z = 0;
2002 do {
2003 *x1++ = *x << k & 0xffff | z;
2004 z = *x++ >> k1;
2005 }
2006 while(x < xe);
2007 if (*x1 = z)
2008 ++n1;
2009 }
2010#endif
2011 else do
2012 *x1++ = *x++;
2013 while(x < xe);
2014 b1->wds = n1 - 1;
2015 Bfree(b MTa);
2016 return b1;
2017 }
2018
2019 static int
2020cmp(Bigint *a, Bigint *b)
2021{
2022 ULong *xa, *xa0, *xb, *xb0;
2023 int i, j;
2024
2025 i = a->wds;
2026 j = b->wds;
2027#ifdef DEBUG
2028 if (i > 1 && !a->x[i-1])
2029 Bug("cmp called with a->x[a->wds-1] == 0");
2030 if (j > 1 && !b->x[j-1])
2031 Bug("cmp called with b->x[b->wds-1] == 0");
2032#endif
2033 if (i -= j)
2034 return i;
2035 xa0 = a->x;
2036 xa = xa0 + j;
2037 xb0 = b->x;
2038 xb = xb0 + j;
2039 for(;;) {
2040 if (*--xa != *--xb)
2041 return *xa < *xb ? -1 : 1;
2042 if (xa <= xa0)
2043 break;
2044 }
2045 return 0;
2046 }
2047
2048 static Bigint *
2049diff(Bigint *a, Bigint *b MTd)
2050{
2051 Bigint *c;
2052 int i, wa, wb;
2053 ULong *xa, *xae, *xb, *xbe, *xc;
2054#ifdef ULLongunsigned long long
2055 ULLongunsigned long long borrow, y;
2056#else
2057 ULong borrow, y;
2058#ifdef Pack_32
2059 ULong z;
2060#endif
2061#endif
2062
2063 i = cmp(a,b);
2064 if (!i) {
2065 c = Balloc(0 MTa);
2066 c->wds = 1;
2067 c->x[0] = 0;
2068 return c;
2069 }
2070 if (i < 0) {
2071 c = a;
2072 a = b;
2073 b = c;
2074 i = 1;
2075 }
2076 else
2077 i = 0;
2078 c = Balloc(a->k MTa);
2079 c->sign = i;
2080 wa = a->wds;
2081 xa = a->x;
2082 xae = xa + wa;
2083 wb = b->wds;
2084 xb = b->x;
2085 xbe = xb + wb;
2086 xc = c->x;
2087 borrow = 0;
2088#ifdef ULLongunsigned long long
2089 do {
2090 y = (ULLongunsigned long long)*xa++ - *xb++ - borrow;
2091 borrow = y >> 32 & (ULong)1;
2092 *xc++ = y & FFFFFFFF0xffffffffUL;
2093 }
2094 while(xb < xbe);
2095 while(xa < xae) {
2096 y = *xa++ - borrow;
2097 borrow = y >> 32 & (ULong)1;
2098 *xc++ = y & FFFFFFFF0xffffffffUL;
2099 }
2100#else
2101#ifdef Pack_32
2102 do {
2103 y = (*xa & 0xffff) - (*xb & 0xffff) - borrow;
2104 borrow = (y & 0x10000) >> 16;
2105 z = (*xa++ >> 16) - (*xb++ >> 16) - borrow;
2106 borrow = (z & 0x10000) >> 16;
2107 Storeinc(xc, z, y)(((unsigned short *)xc)[1] = (unsigned short)z, ((unsigned short
*)xc)[0] = (unsigned short)y, xc++);
2108 }
2109 while(xb < xbe);
2110 while(xa < xae) {
2111 y = (*xa & 0xffff) - borrow;
2112 borrow = (y & 0x10000) >> 16;
2113 z = (*xa++ >> 16) - borrow;
2114 borrow = (z & 0x10000) >> 16;
2115 Storeinc(xc, z, y)(((unsigned short *)xc)[1] = (unsigned short)z, ((unsigned short
*)xc)[0] = (unsigned short)y, xc++);
2116 }
2117#else
2118 do {
2119 y = *xa++ - *xb++ - borrow;
2120 borrow = (y & 0x10000) >> 16;
2121 *xc++ = y & 0xffff;
2122 }
2123 while(xb < xbe);
2124 while(xa < xae) {
2125 y = *xa++ - borrow;
2126 borrow = (y & 0x10000) >> 16;
2127 *xc++ = y & 0xffff;
2128 }
2129#endif
2130#endif
2131 while(!*--xc)
2132 wa--;
2133 c->wds = wa;
2134 return c;
2135 }
2136
2137 static Bigint *
2138d2b(U *d, int *e, int *bits MTd)
2139{
2140 Bigint *b;
2141 int de, k;
2142 ULong *x, y, z;
2143#ifndef Sudden_Underflow
2144 int i;
2145#endif
2146#ifdef VAX
2147 ULong d0, d1;
2148 d0 = word0(d)(d)->L[1] >> 16 | word0(d)(d)->L[1] << 16;
2149 d1 = word1(d)(d)->L[0] >> 16 | word1(d)(d)->L[0] << 16;
2150#else
2151#define d0 word0(d)(d)->L[1]
2152#define d1 word1(d)(d)->L[0]
2153#endif
2154
2155#ifdef Pack_32
2156 b = Balloc(1 MTa);
2157#else
2158 b = Balloc(2 MTa);
2159#endif
2160 x = b->x;
2161
2162 z = d0 & Frac_mask0xfffff;
2163 d0 &= 0x7fffffff; /* clear sign bit, which we ignore */
2164#ifdef Sudden_Underflow
2165 de = (int)(d0 >> Exp_shift20);
2166#ifndef IBM
2167 z |= Exp_msk110x100000;
2168#endif
2169#else
2170 if ((de = (int)(d0 >> Exp_shift20)))
2171 z |= Exp_msk10x100000;
2172#endif
2173#ifdef Pack_32
2174 if ((y = d1)) {
2175 if ((k = lo0bits(&y))) {
2176 x[0] = y | z << (32 - k);
2177 z >>= k;
2178 }
2179 else
2180 x[0] = y;
2181#ifndef Sudden_Underflow
2182 i =
2183#endif
2184 b->wds = (x[1] = z) ? 2 : 1;
2185 }
2186 else {
2187 k = lo0bits(&z);
2188 x[0] = z;
2189#ifndef Sudden_Underflow
2190 i =
2191#endif
2192 b->wds = 1;
2193 k += 32;
2194 }
2195#else
2196 if (y = d1) {
2197 if (k = lo0bits(&y))
2198 if (k >= 16) {
2199 x[0] = y | z << 32 - k & 0xffff;
2200 x[1] = z >> k - 16 & 0xffff;
2201 x[2] = z >> k;
2202 i = 2;
2203 }
2204 else {
2205 x[0] = y & 0xffff;
2206 x[1] = y >> 16 | z << 16 - k & 0xffff;
2207 x[2] = z >> k & 0xffff;
2208 x[3] = z >> k+16;
2209 i = 3;
2210 }
2211 else {
2212 x[0] = y & 0xffff;
2213 x[1] = y >> 16;
2214 x[2] = z & 0xffff;
2215 x[3] = z >> 16;
2216 i = 3;
2217 }
2218 }
2219 else {
2220#ifdef DEBUG
2221 if (!z)
2222 Bug("Zero passed to d2b");
2223#endif
2224 k = lo0bits(&z);
2225 if (k >= 16) {
2226 x[0] = z;
2227 i = 0;
2228 }
2229 else {
2230 x[0] = z & 0xffff;
2231 x[1] = z >> 16;
2232 i = 1;
2233 }
2234 k += 32;
2235 }
2236 while(!x[i])
2237 --i;
2238 b->wds = i + 1;
2239#endif
2240#ifndef Sudden_Underflow
2241 if (de) {
2242#endif
2243#ifdef IBM
2244 *e = (de - Bias1023 - (P53-1) << 2) + k;
2245 *bits = 4*P53 + 8 - k - hi0bits(word0(d)(d)->L[1] & Frac_mask0xfffff);
2246#else
2247 *e = de - Bias1023 - (P53-1) + k;
2248 *bits = P53 - k;
2249#endif
2250#ifndef Sudden_Underflow
2251 }
2252 else {
2253 *e = de - Bias1023 - (P53-1) + 1 + k;
2254#ifdef Pack_32
2255 *bits = 32*i - hi0bits(x[i-1]);
2256#else
2257 *bits = (i+2)*16 - hi0bits(x[i]);
2258#endif
2259 }
2260#endif
2261 return b;
2262 }
2263#undef d0
2264#undef d1
2265
2266#undef Need_Hexdig
2267#ifdef INFNAN_CHECK
2268#ifndef No_Hex_NaN
2269#define Need_Hexdig
2270#endif
2271#endif
2272
2273#ifndef Need_Hexdig
2274#ifndef NO_HEX_FP
2275#define Need_Hexdig
2276#endif
2277#endif
2278
2279#ifdef INFNAN_CHECK
2280
2281#ifndef NAN_WORD00x7ff80000
2282#define NAN_WORD00x7ff80000 0x7ff80000
2283#endif
2284
2285#ifndef NAN_WORD10
2286#define NAN_WORD10 0
2287#endif
2288
2289#endif /* INFNAN_CHECK */
2290
2291#ifdef Pack_32
2292#define ULbits32 32
2293#define kshift5 5
2294#define kmask31 31
2295#else
2296#define ULbits32 16
2297#define kshift5 4
2298#define kmask31 15
2299#endif
2300
2301#if !defined(NO_HEX_FP) || defined(Honor_FLT_ROUNDS) /*{*/
2302 static Bigint *
2303increment(Bigint *b MTd)
2304{
2305 ULong *x, *xe;
2306 Bigint *b1;
2307
2308 x = b->x;
2309 xe = x + b->wds;
2310 do {
2311 if (*x < (ULong)0xffffffffL) {
2312 ++*x;
2313 return b;
2314 }
2315 *x++ = 0;
2316 } while(x < xe);
2317 {
2318 if (b->wds >= b->maxwds) {
2319 b1 = Balloc(b->k+1 MTa);
2320 Bcopy(b1,b)memcpy((char *)&b1->sign, (char *)&b->sign, b->
wds*sizeof(int) + 2*sizeof(int));
2321 Bfree(b MTa);
2322 b = b1;
2323 }
2324 b->x[b->wds++] = 1;
2325 }
2326 return b;
2327 }
2328
2329#endif /*}*/
2330
2331 static int
2332dshift(Bigint *b, int p2)
2333{
2334 int rv = hi0bits(b->x[b->wds-1]) - 4;
2335 if (p2 > 0)
2336 rv -= p2;
2337 return rv & kmask31;
2338 }
2339
2340 static int
2341quorem(Bigint *b, Bigint *S)
2342{
2343 int n;
2344 ULong *bx, *bxe, q, *sx, *sxe;
2345#ifdef ULLongunsigned long long
2346 ULLongunsigned long long borrow, carry, y, ys;
2347#else
2348 ULong borrow, carry, y, ys;
2349#ifdef Pack_32
2350 ULong si, z, zs;
2351#endif
2352#endif
2353
2354 n = S->wds;
2355#ifdef DEBUG
2356 /*debug*/ if (b->wds > n)
2357 /*debug*/ Bug("oversize b in quorem");
2358#endif
2359 if (b->wds < n)
2360 return 0;
2361 sx = S->x;
2362 sxe = sx + --n;
2363 bx = b->x;
2364 bxe = bx + n;
2365 q = *bxe / (*sxe + 1); /* ensure q <= true quotient */
2366#ifdef DEBUG
2367#ifdef NO_STRTOD_BIGCOMP
2368 /*debug*/ if (q > 9)
2369#else
2370 /* An oversized q is possible when quorem is called from bigcomp and */
2371 /* the input is near, e.g., twice the smallest denormalized number. */
2372 /*debug*/ if (q > 15)
2373#endif
2374 /*debug*/ Bug("oversized quotient in quorem");
2375#endif
2376 if (q) {
2377 borrow = 0;
2378 carry = 0;
2379 do {
2380#ifdef ULLongunsigned long long
2381 ys = *sx++ * (ULLongunsigned long long)q + carry;
2382 carry = ys >> 32;
2383 y = *bx - (ys & FFFFFFFF0xffffffffUL) - borrow;
2384 borrow = y >> 32 & (ULong)1;
2385 *bx++ = y & FFFFFFFF0xffffffffUL;
2386#else
2387#ifdef Pack_32
2388 si = *sx++;
2389 ys = (si & 0xffff) * q + carry;
2390 zs = (si >> 16) * q + (ys >> 16);
2391 carry = zs >> 16;
2392 y = (*bx & 0xffff) - (ys & 0xffff) - borrow;
2393 borrow = (y & 0x10000) >> 16;
2394 z = (*bx >> 16) - (zs & 0xffff) - borrow;
2395 borrow = (z & 0x10000) >> 16;
2396 Storeinc(bx, z, y)(((unsigned short *)bx)[1] = (unsigned short)z, ((unsigned short
*)bx)[0] = (unsigned short)y, bx++);
2397#else
2398 ys = *sx++ * q + carry;
2399 carry = ys >> 16;
2400 y = *bx - (ys & 0xffff) - borrow;
2401 borrow = (y & 0x10000) >> 16;
2402 *bx++ = y & 0xffff;
2403#endif
2404#endif
2405 }
2406 while(sx <= sxe);
2407 if (!*bxe) {
2408 bx = b->x;
2409 while(--bxe > bx && !*bxe)
2410 --n;
2411 b->wds = n;
2412 }
2413 }
2414 if (cmp(b, S) >= 0) {
2415 q++;
2416 borrow = 0;
2417 carry = 0;
2418 bx = b->x;
2419 sx = S->x;
2420 do {
2421#ifdef ULLongunsigned long long
2422 ys = *sx++ + carry;
2423 carry = ys >> 32;
2424 y = *bx - (ys & FFFFFFFF0xffffffffUL) - borrow;
2425 borrow = y >> 32 & (ULong)1;
2426 *bx++ = y & FFFFFFFF0xffffffffUL;
2427#else
2428#ifdef Pack_32
2429 si = *sx++;
2430 ys = (si & 0xffff) + carry;
2431 zs = (si >> 16) + (ys >> 16);
2432 carry = zs >> 16;
2433 y = (*bx & 0xffff) - (ys & 0xffff) - borrow;
2434 borrow = (y & 0x10000) >> 16;
2435 z = (*bx >> 16) - (zs & 0xffff) - borrow;
2436 borrow = (z & 0x10000) >> 16;
2437 Storeinc(bx, z, y)(((unsigned short *)bx)[1] = (unsigned short)z, ((unsigned short
*)bx)[0] = (unsigned short)y, bx++);
2438#else
2439 ys = *sx++ + carry;
2440 carry = ys >> 16;
2441 y = *bx - (ys & 0xffff) - borrow;
2442 borrow = (y & 0x10000) >> 16;
2443 *bx++ = y & 0xffff;
2444#endif
2445#endif
2446 }
2447 while(sx <= sxe);
2448 bx = b->x;
2449 bxe = bx + n;
2450 if (!*bxe) {
2451 while(--bxe > bx && !*bxe)
2452 --n;
2453 b->wds = n;
2454 }
2455 }
2456 return q;
2457 }
2458
2459#ifndef MULTIPLE_THREADS
2460 static char *dtoa_result;
2461#endif
2462
2463 static char *
2464rv_alloc(size_t i MTd)
2465{
2466 int j, k, *r;
2467
2468 j = sizeof(ULong);
2469 for(k = 0;
2470 sizeof(Bigint) - sizeof(ULong) - sizeof(int) + j <= i;
2471 j <<= 1)
2472 k++;
2473 r = (int*)Balloc(k MTa);
2474 *r = k;
2475 return
2476#ifndef MULTIPLE_THREADS
2477 dtoa_result =
2478#endif
2479 (char *)(r+1);
2480 }
2481
2482 static char *
2483nrv_alloc(const char *s, char *s0, size_t s0len, char **rve, size_t n MTd)
2484{
2485 char *rv, *t;
2486
2487 if (!s0)
2488 s0 = rv_alloc(n MTa);
2489 else if (s0len <= n) {
2490 rv = 0;
2491 t = rv + n;
2492 goto rve_chk;
2493 }
2494 t = rv = s0;
2495 while((*t = *s++))
2496 ++t;
2497 rve_chk:
2498 if (rve)
2499 *rve = t;
2500 return rv;
2501 }
2502
2503/* freedtoa(s) must be used to free values s returned by dtoa
2504 * when MULTIPLE_THREADS is #defined. It should be used in all cases,
2505 * but for consistency with earlier versions of dtoa, it is optional
2506 * when MULTIPLE_THREADS is not defined.
2507 */
2508
2509 void
2510freedtoa(char *s)
2511{
2512#ifdef MULTIPLE_THREADS
2513 ThInfo *TI = 0;
2514#endif
2515 Bigint *b = (Bigint *)((int *)s - 1);
2516 b->maxwds = 1 << (b->k = *(int*)b);
2517 Bfree(b MTb);
2518#ifndef MULTIPLE_THREADS
2519 if (s == dtoa_result)
2520 dtoa_result = 0;
2521#endif
2522 }
2523
2524/* dtoa for IEEE arithmetic (dmg): convert double to ASCII string.
2525 *
2526 * Inspired by "How to Print Floating-Point Numbers Accurately" by
2527 * Guy L. Steele, Jr. and Jon L. White [Proc. ACM SIGPLAN '90, pp. 112-126].
2528 *
2529 * Modifications:
2530 * 1. Rather than iterating, we use a simple numeric overestimate
2531 * to determine k = floor(log10(d)). We scale relevant
2532 * quantities using O(log2(k)) rather than O(k) multiplications.
2533 * 2. For some modes > 2 (corresponding to ecvt and fcvt), we don't
2534 * try to generate digits strictly left to right. Instead, we
2535 * compute with fewer bits and propagate the carry if necessary
2536 * when rounding the final digit up. This is often faster.
2537 * 3. Under the assumption that input will be rounded nearest,
2538 * mode 0 renders 1e23 as 1e23 rather than 9.999999999999999e22.
2539 * That is, we allow equality in stopping tests when the
2540 * round-nearest rule will give the same floating-point value
2541 * as would satisfaction of the stopping test with strict
2542 * inequality.
2543 * 4. We remove common factors of powers of 2 from relevant
2544 * quantities.
2545 * 5. When converting floating-point integers less than 1e16,
2546 * we use floating-point arithmetic rather than resorting
2547 * to multiple-precision integers.
2548 * 6. When asked to produce fewer than 15 digits, we first try
2549 * to get by with floating-point arithmetic; we resort to
2550 * multiple-precision integer arithmetic only if we cannot
2551 * guarantee that the floating-point calculation has given
2552 * the correctly rounded result. For k requested digits and
2553 * "uniformly" distributed input, the probability is
2554 * something like 10^(k-15) that we must resort to the Long
2555 * calculation.
2556 */
2557
2558 char *
2559dtoa_r(double dd, int mode, int ndigits, int *decpt, int *sign, char **rve, char *buf, size_t blen)
2560{
2561 /* Arguments ndigits, decpt, sign are similar to those
2562 of ecvt and fcvt; trailing zeros are suppressed from
2563 the returned string. If not null, *rve is set to point
2564 to the end of the return value. If d is +-Infinity or NaN,
2565 then *decpt is set to 9999.
2566
2567 mode:
2568 0 ==> shortest string that yields d when read in
2569 and rounded to nearest.
2570 1 ==> like 0, but with Steele & White stopping rule;
2571 e.g. with IEEE P754 arithmetic , mode 0 gives
2572 1e23 whereas mode 1 gives 9.999999999999999e22.
2573 2 ==> max(1,ndigits) significant digits. This gives a
2574 return value similar to that of ecvt, except
2575 that trailing zeros are suppressed.
2576 3 ==> through ndigits past the decimal point. This
2577 gives a return value similar to that from fcvt,
2578 except that trailing zeros are suppressed, and
2579 ndigits can be negative.
2580 4,5 ==> similar to 2 and 3, respectively, but (in
2581 round-nearest mode) with the tests of mode 0 to
2582 possibly return a shorter string that rounds to d.
2583 With IEEE arithmetic and compilation with
2584 -DHonor_FLT_ROUNDS, modes 4 and 5 behave the same
2585 as modes 2 and 3 when FLT_ROUNDS != 1.
2586 6-9 ==> Debugging modes similar to mode - 4: don't try
2587 fast floating-point estimate (if applicable).
2588
2589 Values of mode other than 0-9 are treated as mode 0.
2590
2591 When not NULL, buf is an output buffer of length blen, which must
2592 be large enough to accommodate suppressed trailing zeros and a trailing
2593 null byte. If blen is too small, rv = NULL is returned, in which case
2594 if rve is not NULL, a subsequent call with blen >= (*rve - rv) + 1
2595 should succeed in returning buf.
2596
2597 When buf is NULL, sufficient space is allocated for the return value,
2598 which, when done using, the caller should pass to freedtoa().
2599
2600 USE_BF is automatically defined when neither NO_LONG_LONG nor NO_BF96
2601 is defined.
2602 */
2603
2604#ifdef MULTIPLE_THREADS
2605 ThInfo *TI = 0;
2606#endif
2607 int bbits, b2, b5, be, dig, i, ilim, ilim1,
2608 j, j1, k, leftright, m2, m5, s2, s5, spec_case;
2609#if !defined(Sudden_Underflow) || defined(USE_BF96)
2610 int denorm;
2611#endif
2612 Bigint *b, *b1, *delta, *mlo, *mhi, *S;
2613 U u;
2614 char *s;
2615#ifdef SET_INEXACT
2616 int inexact, oldinexact;
2617#endif
2618#ifdef USE_BF96 /*{{*/
2619 BF96 *p10;
2620 ULLongunsigned long long dbhi, dbits, dblo, den, hb, rb, rblo, res, res0, res3, reslo, sres,
2621 sulp, tv0, tv1, tv2, tv3, ulp, ulplo, ulpmask, ures, ureslo, zb;
2622 int eulp, k1, n2, ulpadj, ulpshift;
2623#else /*}{*/
2624#ifndef Sudden_Underflow
2625 ULong x;
2626#endif
2627 Longint L;
2628 U d2, eps;
2629 double ds;
2630 int ieps, ilim0, k0, k_check, try_quick;
2631#ifndef No_leftright
2632#ifdef IEEE_Arith
2633 U eps1;
2634#endif
2635#endif
2636#endif /*}}*/
2637#ifdef Honor_FLT_ROUNDS /*{*/
2638 int Rounding(__builtin_flt_rounds());
2639#ifdef Trust_FLT_ROUNDS /*{{ only define this if FLT_ROUNDS really works! */
2640 Rounding(__builtin_flt_rounds()) = Flt_Rounds(__builtin_flt_rounds());
2641#else /*}{*/
2642 Rounding(__builtin_flt_rounds()) = 1;
2643 switch(fegetround()) {
2644 case FE_TOWARDZERO: Rounding(__builtin_flt_rounds()) = 0; break;
2645 case FE_UPWARD: Rounding(__builtin_flt_rounds()) = 2; break;
2646 case FE_DOWNWARD: Rounding(__builtin_flt_rounds()) = 3;
2647 }
2648#endif /*}}*/
2649#endif /*}*/
2650
2651 u.d = dd;
2652 if (word0(&u)(&u)->L[1] & Sign_bit0x80000000) {
1
Assuming the condition is false
→
2
←
Taking false branch
→
2653 /* set sign for everything, including 0's and NaNs */
2654 *sign = 1;
2655 word0(&u)(&u)->L[1] &= ~Sign_bit0x80000000; /* clear sign bit */
2656 }
2657 else
2658 *sign = 0;
2659
2660#if defined(IEEE_Arith) + defined(VAX)
2661#ifdef IEEE_Arith
2662 if ((word0(&u)(&u)->L[1] & Exp_mask0x7ff00000) == Exp_mask0x7ff00000)
3
←
Assuming the condition is false
→
4
←
Taking false branch
→
2663#else
2664 if (word0(&u)(&u)->L[1] == 0x8000)
2665#endif
2666 {
2667 /* Infinity or NaN */
2668 *decpt = 9999;
2669#ifdef IEEE_Arith
2670 if (!word1(&u)(&u)->L[0] && !(word0(&u)(&u)->L[1] & 0xfffff))
2671 return nrv_alloc("Infinity", buf, blen, rve, 8 MTb);
2672#endif
2673 return nrv_alloc("NaN", buf, blen, rve, 3 MTb);
2674 }
2675#endif
2676#ifdef IBM
2677 dval(&u)(&u)->d += 0; /* normalize */
2678#endif
2679 if (!dval(&u)(&u)->d) {
5
←
Assuming the condition is false
→
6
←
Taking false branch
→
2680 *decpt = 1;
2681 return nrv_alloc("0", buf, blen, rve, 1 MTb);
2682 }
2683
2684#ifdef SET_INEXACT
2685#ifndef USE_BF96
2686 try_quick =
2687#endif
2688 oldinexact = get_inexact();
2689 inexact = 1;
2690#endif
2691#ifdef Honor_FLT_ROUNDS
2692 if (Rounding(__builtin_flt_rounds()) >= 2) {
2693 if (*sign)
2694 Rounding(__builtin_flt_rounds()) = Rounding(__builtin_flt_rounds()) == 2 ? 0 : 2;
2695 else
2696 if (Rounding(__builtin_flt_rounds()) != 2)
2697 Rounding(__builtin_flt_rounds()) = 0;
2698 }
2699#endif
2700#ifdef USE_BF96 /*{{*/
2701 dbits = (u.LL & 0xfffffffffffffull) << 11; /* fraction bits */
2702 if ((be = u.LL >> 52)) /* biased exponent; nonzero ==> normal */ {
7
←
Assuming 'be' is 0
→
8
←
Taking false branch
→
2703 dbits |= 0x8000000000000000ull;
2704 denorm = ulpadj = 0;
2705 }
2706 else {
2707 denorm = 1;
2708 ulpadj = be + 1;
2709 dbits <<= 1;
2710 if (!(dbits & 0xffffffff00000000ull)) {
9
←
Assuming the condition is false
→
10
←
Taking false branch
→
2711 dbits <<= 32;
2712 be -= 32;
2713 }
2714 if (!(dbits & 0xffff000000000000ull)) {
11
←
Assuming the condition is false
→
12
←
Taking false branch
→
2715 dbits <<= 16;
2716 be -= 16;
2717 }
2718 if (!(dbits & 0xff00000000000000ull)) {
13
←
Assuming the condition is false
→
14
←
Taking false branch
→
2719 dbits <<= 8;
2720 be -= 8;
2721 }
2722 if (!(dbits & 0xf000000000000000ull)) {
15
←
Assuming the condition is false
→
16
←
Taking false branch
→
2723 dbits <<= 4;
2724 be -= 4;
2725 }
2726 if (!(dbits & 0xc000000000000000ull)) {
17
←
Assuming the condition is false
→
18
←
Taking false branch
→
2727 dbits <<= 2;
2728 be -= 2;
2729 }
2730 if (!(dbits & 0x8000000000000000ull)) {
19
←
Assuming the condition is false
→
20
←
Taking false branch
→
2731 dbits <<= 1;
2732 be -= 1;
2733 }
2734 assert(be >= -51);
2735 ulpadj -= be;
2736 }
2737 j = Lhint[be + 51];
2738 p10 = &pten[j];
2739 dbhi = dbits >> 32;
2740 dblo = dbits & 0xffffffffull;
2741 i = be - 0x3fe;
2742 if (i < p10->e
21
←
Assuming 'i' is >= field 'e'
→
2743 || (i == p10->e && (dbhi < p10->b0 || (dbhi == p10->b0 && dblo < p10->b1))))
22
←
Assuming 'i' is not equal to field 'e'
→
2744 --j;
2745 k = j - 342;
23
←
Value assigned to 'k'
→
2746
2747 /* now 10^k <= dd < 10^(k+1) */
2748
2749#else /*}{*/
2750
2751 b = d2b(&u, &be, &bbits MTb);
2752#ifdef Sudden_Underflow
2753 i = (int)(word0(&u)(&u)->L[1] >> Exp_shift120 & (Exp_mask0x7ff00000>>Exp_shift120));
2754#else
2755 if ((i = (int)(word0(&u)(&u)->L[1] >> Exp_shift120 & (Exp_mask0x7ff00000>>Exp_shift120)))) {
2756#endif
2757 dval(&d2)(&d2)->d = dval(&u)(&u)->d;
2758 word0(&d2)(&d2)->L[1] &= Frac_mask10xfffff;
2759 word0(&d2)(&d2)->L[1] |= Exp_110x3ff00000;
2760#ifdef IBM
2761 if (j = 11 - hi0bits(word0(&d2)(&d2)->L[1] & Frac_mask0xfffff))
2762 dval(&d2)(&d2)->d /= 1 << j;
2763#endif
2764
2765 /* log(x) ~=~ log(1.5) + (x-1.5)/1.5
2766 * log10(x) = log(x) / log(10)
2767 * ~=~ log(1.5)/log(10) + (x-1.5)/(1.5*log(10))
2768 * log10(d) = (i-Bias)*log(2)/log(10) + log10(d2)
2769 *
2770 * This suggests computing an approximation k to log10(d) by
2771 *
2772 * k = (i - Bias)*0.301029995663981
2773 * + ( (d2-1.5)*0.289529654602168 + 0.176091259055681 );
2774 *
2775 * We want k to be too large rather than too small.
2776 * The error in the first-order Taylor series approximation
2777 * is in our favor, so we just round up the constant enough
2778 * to compensate for any error in the multiplication of
2779 * (i - Bias) by 0.301029995663981; since |i - Bias| <= 1077,
2780 * and 1077 * 0.30103 * 2^-52 ~=~ 7.2e-14,
2781 * adding 1e-13 to the constant term more than suffices.
2782 * Hence we adjust the constant term to 0.1760912590558.
2783 * (We could get a more accurate k by invoking log10,
2784 * but this is probably not worthwhile.)
2785 */
2786
2787 i -= Bias1023;
2788#ifdef IBM
2789 i <<= 2;
2790 i += j;
2791#endif
2792#ifndef Sudden_Underflow
2793 denorm = 0;
2794 }
2795 else {
2796 /* d is denormalized */
2797
2798 i = bbits + be + (Bias1023 + (P53-1) - 1);
2799 x = i > 32 ? word0(&u)(&u)->L[1] << (64 - i) | word1(&u)(&u)->L[0] >> (i - 32)
2800 : word1(&u)(&u)->L[0] << (32 - i);
2801 dval(&d2)(&d2)->d = x;
2802 word0(&d2)(&d2)->L[1] -= 31*Exp_msk10x100000; /* adjust exponent */
2803 i -= (Bias1023 + (P53-1) - 1) + 1;
2804 denorm = 1;
2805 }
2806#endif
2807 ds = (dval(&d2)(&d2)->d-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981;
2808 k = (int)ds;
2809 if (ds < 0. && ds != k)
2810 k--; /* want k = floor(ds) */
2811 k_check = 1;
2812 if (k >= 0 && k <= Ten_pmax22) {
2813 if (dval(&u)(&u)->d < tens[k])
2814 k--;
2815 k_check = 0;
2816 }
2817 j = bbits - i - 1;
2818 if (j >= 0) {
2819 b2 = 0;
2820 s2 = j;
2821 }
2822 else {
2823 b2 = -j;
2824 s2 = 0;
2825 }
2826 if (k >= 0) {
2827 b5 = 0;
2828 s5 = k;
2829 s2 += k;
2830 }
2831 else {
2832 b2 -= k;
2833 b5 = -k;
2834 s5 = 0;
2835 }
2836#endif /*}}*/
2837 if (mode < 0 || mode > 9)
24
←
Assuming 'mode' is >= 0
→
25
←
Assuming 'mode' is <= 9
→
26
←
Taking false branch
→
2838 mode = 0;
2839
2840#ifndef USE_BF96
2841#ifndef SET_INEXACT
2842#ifdef Check_FLT_ROUNDS
2843 try_quick = Rounding(__builtin_flt_rounds()) == 1;
2844#else
2845 try_quick = 1;
2846#endif
2847#endif /*SET_INEXACT*/
2848#endif /*USE_BF96*/
2849
2850 if (mode > 5) {
27
←
Assuming 'mode' is <= 5
→
28
←
Taking false branch
→
2851 mode -= 4;
2852#ifndef USE_BF96
2853 try_quick = 0;
2854#endif
2855 }
2856 leftright = 1;
2857 ilim = ilim1 = -1; /* Values for cases 0 and 1; done here to */
2858 /* silence erroneous "gcc -Wall" warning. */
2859 switch(mode) {
29
←
Control jumps to 'case 5:' at line 2876
→
2860 case 0:
2861 case 1:
2862 i = 18;
2863 ndigits = 0;
2864 break;
2865 case 2:
2866 leftright = 0;
2867 /* FALLTHROUGH */
2868 case 4:
2869 if (ndigits <= 0)
2870 ndigits = 1;
2871 ilim = ilim1 = i = ndigits;
2872 break;
2873 case 3:
2874 leftright = 0;
2875 /* FALLTHROUGH */
2876 case 5:
2877 i = ndigits + k + 1;
2878 ilim = i;
2879 ilim1 = i - 1;
2880 if (i <= 0)
30
←
Assuming 'i' is <= 0
→
31
←
Taking true branch
→
2881 i = 1;
2882 }
2883 if (!buf) {
32
←
Assuming 'buf' is non-null
→
33
←
Taking false branch
→
2884 buf = rv_alloc(i MTb);
2885 blen = sizeof(Bigint) + ((1 << ((int*)buf)[-1]) - 1)*sizeof(ULong) - sizeof(int);
2886 }
2887 else if (blen <= (size_t)i) {
34
←
Assuming 'blen' is > 'i'
→
35
←
Taking false branch
→
2888 buf = 0;
2889 if (rve)
2890 *rve = buf + i;
2891 return buf;
2892 }
2893 s = buf;
2894
2895 /* Check for special case that d is a normalized power of 2. */
2896
2897 spec_case = 0;
2898 if (mode
35.1
'mode' is >= 2
 < 2 || (leftright
35.2
'leftright' is 1
2899#ifdef Honor_FLT_ROUNDS 2900 && Rounding(__builtin_flt_rounds()) == 1 2901#endif 2902 )) { 2903 if (!word1(&u)(&u)->L[0] && !(word0(&u)(&u)->L[1] & Bndry_mask0xfffff)
36
←
Assuming the condition is false
→
2904#ifndef Sudden_Underflow 2905 && word0(&u)(&u)->L[1] & (Exp_mask0x7ff00000 & ~Exp_msk10x100000) 2906#endif 2907 ) { 2908 /* The special case */ 2909 spec_case = 1; 2910 } 2911 } 2912 2913#ifdef USE_BF96 /*{*/ 2914 b = 0; 2915 if (ilim < 0 && (mode == 3 || mode == 5)) {
37
←
Assuming 'ilim' is >= 0
→
2916 S = mhi = 0; 2917 goto no_digits; 2918 } 2919 i = 1; 2920 j = 52 + 0x3ff - be; 2921 ulpshift = 0; 2922 ulplo = 0; 2923 /* Can we do an exact computation with 64-bit integer arithmetic? */ 2924 if (k < 0) {
38
←
Assuming 'k' is < 0
→
39
←
Taking true branch
→
2925 if (k < -25)
40
←
Assuming the condition is false
→
41
←
Taking false branch
→
2926 goto toobig; 2927 res = dbits >> 11; 2928 n2 = pfivebits[k1 = -(k + 1)] + 53; 2929 j1 = j; 2930 if (n2 > 61) {
42
←
Assuming 'n2' is <= 61
→
43
←
Taking false branch
→
2931 ulpshift = n2 - 61; 2932 if (res & (ulpmask = (1ull << ulpshift) - 1)) 2933 goto toobig; 2934 j -= ulpshift; 2935 res >>= ulpshift; 2936 } 2937 /* Yes. */ 2938 res *= ulp = pfive[k1]; 2939 if (ulpshift
43.1
'ulpshift' is 0
) {
44
←
Taking false branch
→
2940 ulplo = ulp; 2941 ulp >>= ulpshift; 2942 } 2943 j += k;
45
←
Value assigned to 'j'
→
2944 if (ilim
45.1
'ilim' is equal to 0
 == 0) {
46
←
Taking true branch
→
2945 S = mhi = 0; 2946 if (res > (5ull << j))
47
←
The result of left shift is undefined because the right operand is not smaller than 64, the capacity of 'unsigned long long'
2947 goto one_digit; 2948 goto no_digits; 2949 } 2950 goto no_div; 2951 } 2952 if (ilim == 0 && j + k >= 0) { 2953 S = mhi = 0; 2954 if ((dbits >> 11) > (pfive[k-1] << j)) 2955 goto one_digit; 2956 goto no_digits; 2957 } 2958 if (k <= dtoa_divmax && j + k >= 0) { 2959 /* Another "yes" case -- we will use exact integer arithmetic. */ 2960 use_exact: 2961 Debug(++dtoa_stats[3]); 2962 res = dbits >> 11; /* residual */ 2963 ulp = 1; 2964 if (k <= 0) 2965 goto no_div; 2966 j1 = j + k + 1; 2967 den = pfive[k-i] << (j1 - i); 2968 for(;;) { 2969 dig = (int)(res / den); 2970 *s++ = '0' + dig; 2971 if (!(res -= dig*den)) { 2972#ifdef SET_INEXACT 2973 inexact = 0; 2974 oldinexact = 1; 2975#endif 2976 goto retc; 2977 } 2978 if (ilim < 0) { 2979 ures = den - res; 2980 if (2*res <= ulp 2981 && (spec_case ? 4*res <= ulp : (2*res < ulp || dig & 1))) 2982 goto ulp_reached; 2983 if (2*ures < ulp) 2984 goto Roundup; 2985 } 2986 else if (i == ilim) { 2987 switch(Rounding(__builtin_flt_rounds())) { 2988 case 0: goto retc; 2989 case 2: goto Roundup; 2990 } 2991 ures = 2*res; 2992 if (ures > den 2993 || (ures == den && dig & 1) 2994 || (spec_case && res <= ulp && 2*res >= ulp)) 2995 goto Roundup; 2996 goto retc; 2997 } 2998 if (j1 < ++i) { 2999 res *= 10; 3000 ulp *= 10; 3001 } 3002 else { 3003 if (i > k) 3004 break; 3005 den = pfive[k-i] << (j1 - i); 3006 } 3007 } 3008 no_div: 3009 for(;;) { 3010 den = res >> j; 3011 dig = (int)den; 3012 *s++ = '0' + dig; 3013 if (!(res -= den << j)) { 3014#ifdef SET_INEXACT 3015 inexact = 0; 3016 oldinexact = 1; 3017#endif 3018 goto retc; 3019 } 3020 if (ilim < 0) { 3021 ures = (1ull << j) - res; 3022 if (2*res <= ulp 3023 && (spec_case ? 4*res <= ulp : (2*res < ulp || dig & 1))) { 3024 ulp_reached: 3025 if (ures < res 3026 || (ures == res && dig & 1) 3027 || (dig == 9 && 2*ures <= ulp)) 3028 goto Roundup; 3029 goto retc; 3030 } 3031 if (2*ures < ulp) 3032 goto Roundup; 3033 } 3034 --j; 3035 if (i == ilim) { 3036#ifdef Honor_FLT_ROUNDS 3037 switch(Rounding(__builtin_flt_rounds())) { 3038 case 0: goto retc; 3039 case 2: goto Roundup; 3040 } 3041#endif 3042 hb = 1ull << j; 3043 if (res & hb && (dig & 1 || res & (hb-1))) 3044 goto Roundup; 3045 if (spec_case && res <= ulp && 2*res >= ulp) { 3046 Roundup: 3047 while(*--s == '9') 3048 if (s == buf) { 3049 ++k; 3050 *s++ = '1'; 3051 goto ret1; 3052 } 3053 ++*s++; 3054 goto ret1; 3055 } 3056 goto retc; 3057 } 3058 ++i; 3059 res *= 5; 3060 if (ulpshift) { 3061 ulplo = 5*(ulplo & ulpmask); 3062 ulp = 5*ulp + (ulplo >> ulpshift); 3063 } 3064 else 3065 ulp *= 5; 3066 } 3067 } 3068 toobig: 3069 if (ilim > 28) 3070 goto Fast_failed1; 3071 /* Scale by 10^-k */ 3072 p10 = &pten[342-k]; 3073 tv0 = p10->b2 * dblo; /* rarely matters, but does, e.g., for 9.862818194192001e18 */ 3074 tv1 = p10->b1 * dblo + (tv0 >> 32); 3075 tv2 = p10->b2 * dbhi + (tv1 & 0xffffffffull); 3076 tv3 = p10->b0 * dblo + (tv1>>32) + (tv2>>32); 3077 res3 = p10->b1 * dbhi + (tv3 & 0xffffffffull); 3078 res = p10->b0 * dbhi + (tv3>>32) + (res3>>32); 3079 be += p10->e - 0x3fe; 3080 eulp = j1 = be - 54 + ulpadj; 3081 if (!(res & 0x8000000000000000ull)) { 3082 --be; 3083 res3 <<= 1; 3084 res = (res << 1) | ((res3 & 0x100000000ull) >> 32); 3085 } 3086 res0 = res; /* save for Fast_failed */ 3087#if !defined(SET_INEXACT) && !defined(NO_DTOA_64) /*{*/ 3088 if (ilim > 19) 3089 goto Fast_failed; 3090 Debug(++dtoa_stats[4]); 3091 assert(be >= 0 && be <= 4); /* be = 0 is rare, but possible, e.g., for 1e20 */ 3092 res >>= 4 - be; 3093 ulp = p10->b0; /* ulp */ 3094 ulp = (ulp << 29) | (p10->b1 >> 3); 3095 /* scaled ulp = ulp * 2^(eulp - 60) */ 3096 /* We maintain 61 bits of the scaled ulp. */ 3097 if (ilim == 0) { 3098 if (!(res & 0x7fffffffffffffeull) 3099 || !((~res) & 0x7fffffffffffffeull)) 3100 goto Fast_failed1; 3101 S = mhi = 0; 3102 if (res >= 0x5000000000000000ull) 3103 goto one_digit; 3104 goto no_digits; 3105 } 3106 rb = 1; /* upper bound on rounding error */ 3107 for(;;++i) { 3108 dig = res >> 60; 3109 *s++ = '0' + dig; 3110 res &= 0xfffffffffffffffull; 3111 if (ilim < 0) { 3112 ures = 0x1000000000000000ull - res; 3113 if (eulp > 0) { 3114 assert(eulp <= 4); 3115 sulp = ulp << (eulp - 1); 3116 if (res <= ures) { 3117 if (res + rb > ures - rb) 3118 goto Fast_failed; 3119 if (res < sulp) 3120 goto retc; 3121 } 3122 else { 3123 if (res - rb <= ures + rb) 3124 goto Fast_failed; 3125 if (ures < sulp) 3126 goto Roundup; 3127 } 3128 } 3129 else { 3130 zb = -(1ull << (eulp + 63)); 3131 if (!(zb & res)) { 3132 sres = res << (1 - eulp); 3133 if (sres < ulp && (!spec_case || 2*sres < ulp)) { 3134 if ((res+rb) << (1 - eulp) >= ulp) 3135 goto Fast_failed; 3136 if (ures < res) { 3137 if (ures + rb >= res - rb) 3138 goto Fast_failed; 3139 goto Roundup; 3140 } 3141 if (ures - rb < res + rb) 3142 goto Fast_failed; 3143 goto retc; 3144 } 3145 } 3146 if (!(zb & ures) && ures << -eulp < ulp) { 3147 if (ures << (1 - eulp) < ulp) 3148 goto Roundup; 3149 goto Fast_failed; 3150 } 3151 } 3152 } 3153 else if (i == ilim) { 3154 ures = 0x1000000000000000ull - res; 3155 if (ures < res) { 3156 if (ures <= rb || res - rb <= ures + rb) { 3157 if (j + k >= 0 && k >= 0 && k <= 27) 3158 goto use_exact1; 3159 goto Fast_failed; 3160 } 3161#ifdef Honor_FLT_ROUNDS 3162 if (Rounding(__builtin_flt_rounds()) == 0) 3163 goto retc; 3164#endif 3165 goto Roundup; 3166 } 3167 if (res <= rb || ures - rb <= res + rb) { 3168 if (j + k >= 0 && k >= 0 && k <= 27) { 3169 use_exact1: 3170 s = buf; 3171 i = 1; 3172 goto use_exact; 3173 } 3174 goto Fast_failed; 3175 } 3176#ifdef Honor_FLT_ROUNDS 3177 if (Rounding(__builtin_flt_rounds()) == 2) 3178 goto Roundup; 3179#endif 3180 goto retc; 3181 } 3182 rb *= 10; 3183 if (rb >= 0x1000000000000000ull) 3184 goto Fast_failed; 3185 res *= 10; 3186 ulp *= 5; 3187 if (ulp & 0x8000000000000000ull) { 3188 eulp += 4; 3189 ulp >>= 3; 3190 } 3191 else { 3192 eulp += 3; 3193 ulp >>= 2; 3194 } 3195 } 3196#endif /*}*/ 3197#ifndef NO_BF96 3198 Fast_failed: 3199#endif 3200 Debug(++dtoa_stats[5]); 3201 s = buf; 3202 i = 4 - be; 3203 res = res0 >> i; 3204 reslo = 0xffffffffull & res3; 3205 if (i) 3206 reslo = (res0 << (64 - i)) >> 32 | (reslo >> i); 3207 rb = 0; 3208 rblo = 4; /* roundoff bound */ 3209 ulp = p10->b0; /* ulp */ 3210 ulp = (ulp << 29) | (p10->b1 >> 3); 3211 eulp = j1; 3212 for(i = 1;;++i) { 3213 dig = res >> 60; 3214 *s++ = '0' + dig; 3215 res &= 0xfffffffffffffffull; 3216#ifdef SET_INEXACT 3217 if (!res && !reslo) { 3218 if (!(res3 & 0xffffffffull)) { 3219 inexact = 0; 3220 oldinexact = 1; 3221 } 3222 goto retc; 3223 } 3224#endif 3225 if (ilim < 0) { 3226 ures = 0x1000000000000000ull - res; 3227 ureslo = 0; 3228 if (reslo) { 3229 ureslo = 0x100000000ull - reslo; 3230 --ures; 3231 } 3232 if (eulp > 0) { 3233 assert(eulp <= 4); 3234 sulp = (ulp << (eulp - 1)) - rb; 3235 if (res <= ures) { 3236 if (res < sulp) { 3237 if (res+rb < ures-rb) 3238 goto retc; 3239 } 3240 } 3241 else if (ures < sulp) { 3242 if (res-rb > ures+rb) 3243 goto Roundup; 3244 } 3245 goto Fast_failed1; 3246 } 3247 else { 3248 zb = -(1ull << (eulp + 60)); 3249 if (!(zb & (res + rb))) { 3250 sres = (res - rb) << (1 - eulp); 3251 if (sres < ulp && (!spec_case || 2*sres < ulp)) { 3252 sres = res << (1 - eulp); 3253 if ((j = eulp + 31) > 0) 3254 sres += (rblo + reslo) >> j; 3255 else 3256 sres += (rblo + reslo) << -j; 3257 if (sres + (rb << (1 - eulp)) >= ulp) 3258 goto Fast_failed1; 3259 if (sres >= ulp) 3260 goto more96; 3261 if (ures < res 3262 || (ures == res && ureslo < reslo)) { 3263 if (ures + rb >= res - rb) 3264 goto Fast_failed1; 3265 goto Roundup; 3266 } 3267 if (ures - rb <= res + rb) 3268 goto Fast_failed1; 3269 goto retc; 3270 } 3271 } 3272 if (!(zb & ures) && (ures-rb) << (1 - eulp) < ulp) { 3273 if ((ures + rb) << (2 - eulp) < ulp) 3274 goto Roundup; 3275 goto Fast_failed1; 3276 } 3277 } 3278 } 3279 else if (i == ilim) { 3280 ures = 0x1000000000000000ull - res; 3281 sres = ureslo = 0; 3282 if (reslo) { 3283 ureslo = 0x100000000ull - reslo; 3284 --ures; 3285 sres = (reslo + rblo) >> 31; 3286 } 3287 sres += 2*rb; 3288 if (ures <= res) { 3289 if (ures <=sres || res - ures <= sres) 3290 goto Fast_failed1; 3291#ifdef Honor_FLT_ROUNDS 3292 if (Rounding(__builtin_flt_rounds()) == 0) 3293 goto retc; 3294#endif 3295 goto Roundup; 3296 } 3297 if (res <= sres || ures - res <= sres) 3298 goto Fast_failed1; 3299#ifdef Honor_FLT_ROUNDS 3300 if (Rounding(__builtin_flt_rounds()) == 2) 3301 goto Roundup; 3302#endif 3303 goto retc; 3304 } 3305 more96: 3306 rblo *= 10; 3307 rb = 10*rb + (rblo >> 32); 3308 rblo &= 0xffffffffull; 3309 if (rb >= 0x1000000000000000ull) 3310 goto Fast_failed1; 3311 reslo *= 10; 3312 res = 10*res + (reslo >> 32); 3313 reslo &= 0xffffffffull; 3314 ulp *= 5; 3315 if (ulp & 0x8000000000000000ull) { 3316 eulp += 4; 3317 ulp >>= 3; 3318 } 3319 else { 3320 eulp += 3; 3321 ulp >>= 2; 3322 } 3323 } 3324 Fast_failed1: 3325 Debug(++dtoa_stats[6]); 3326 S = mhi = mlo = 0; 3327#ifdef USE_BF96 3328 b = d2b(&u, &be, &bbits MTb); 3329#endif 3330 s = buf; 3331 i = (int)(word0(&u)(&u)->L[1] >> Exp_shift120 & (Exp_mask0x7ff00000>>Exp_shift120)); 3332 i -= Bias1023; 3333 if (ulpadj) 3334 i -= ulpadj - 1; 3335 j = bbits - i - 1; 3336 if (j >= 0) { 3337 b2 = 0; 3338 s2 = j; 3339 } 3340 else { 3341 b2 = -j; 3342 s2 = 0; 3343 } 3344 if (k >= 0) { 3345 b5 = 0; 3346 s5 = k; 3347 s2 += k; 3348 } 3349 else { 3350 b2 -= k; 3351 b5 = -k; 3352 s5 = 0; 3353 } 3354#endif /*}*/ 3355 3356#ifdef Honor_FLT_ROUNDS 3357 if (mode > 1 && Rounding(__builtin_flt_rounds()) != 1) 3358 leftright = 0; 3359#endif 3360 3361#ifndef USE_BF96 /*{*/ 3362 if (ilim >= 0 && ilim <= Quick_max14 && try_quick) { 3363 3364 /* Try to get by with floating-point arithmetic. */ 3365 3366 i = 0; 3367 dval(&d2)(&d2)->d = dval(&u)(&u)->d; 3368 j1 = -(k0 = k); 3369 ilim0 = ilim; 3370 ieps = 2; /* conservative */ 3371 if (k > 0) { 3372 ds = tens[k&0xf]; 3373 j = k >> 4; 3374 if (j & Bletch0x10) { 3375 /* prevent overflows */ 3376 j &= Bletch0x10 - 1; 3377 dval(&u)(&u)->d /= bigtens[n_bigtens-1]; 3378 ieps++; 3379 } 3380 for(; j; j >>= 1, i++) 3381 if (j & 1) { 3382 ieps++; 3383 ds *= bigtens[i]; 3384 } 3385 dval(&u)(&u)->d /= ds; 3386 } 3387 else if (j1 > 0) { 3388 dval(&u)(&u)->d *= tens[j1 & 0xf]; 3389 for(j = j1 >> 4; j; j >>= 1, i++) 3390 if (j & 1) { 3391 ieps++; 3392 dval(&u)(&u)->d *= bigtens[i]; 3393 } 3394 } 3395 if (k_check && dval(&u)(&u)->d < 1. && ilim > 0) { 3396 if (ilim1 <= 0) 3397 goto fast_failed; 3398 ilim = ilim1; 3399 k--; 3400 dval(&u)(&u)->d *= 10.; 3401 ieps++; 3402 } 3403 dval(&eps)(&eps)->d = ieps*dval(&u)(&u)->d + 7.; 3404 word0(&eps)(&eps)->L[1] -= (P53-1)*Exp_msk10x100000; 3405 if (ilim == 0) { 3406 S = mhi = 0; 3407 dval(&u)(&u)->d -= 5.; 3408 if (dval(&u)(&u)->d > dval(&eps)(&eps)->d) 3409 goto one_digit; 3410 if (dval(&u)(&u)->d < -dval(&eps)(&eps)->d) 3411 goto no_digits; 3412 goto fast_failed; 3413 } 3414#ifndef No_leftright 3415 if (leftright) { 3416 /* Use Steele & White method of only 3417 * generating digits needed. 3418 */ 3419 dval(&eps)(&eps)->d = 0.5/tens[ilim-1] - dval(&eps)(&eps)->d; 3420#ifdef IEEE_Arith 3421 if (j1 >= 307) { 3422 eps1.d = 1.01e256; /* 1.01 allows roundoff in the next few lines */ 3423 word0(&eps1)(&eps1)->L[1] -= Exp_msk10x100000 * (Bias1023+P53-1); 3424 dval(&eps1)(&eps1)->d *= tens[j1 & 0xf]; 3425 for(i = 0, j = (j1-256) >> 4; j; j >>= 1, i++) 3426 if (j & 1) 3427 dval(&eps1)(&eps1)->d *= bigtens[i]; 3428 if (eps.d < eps1.d) 3429 eps.d = eps1.d; 3430 if (10. - u.d < 10.*eps.d && eps.d < 1.) { 3431 /* eps.d < 1. excludes trouble with the tiniest denormal */ 3432 *s++ = '1'; 3433 ++k; 3434 goto ret1; 3435 } 3436 } 3437#endif 3438 for(i = 0;;) { 3439 L = dval(&u)(&u)->d; 3440 dval(&u)(&u)->d -= L; 3441 *s++ = '0' + (int)L; 3442 if (1. - dval(&u)(&u)->d < dval(&eps)(&eps)->d) 3443 goto bump_up; 3444 if (dval(&u)(&u)->d < dval(&eps)(&eps)->d) 3445 goto retc; 3446 if (++i >= ilim) 3447 break; 3448 dval(&eps)(&eps)->d *= 10.; 3449 dval(&u)(&u)->d *= 10.; 3450 } 3451 } 3452 else { 3453#endif 3454 /* Generate ilim digits, then fix them up. */ 3455 dval(&eps)(&eps)->d *= tens[ilim-1]; 3456 for(i = 1;; i++, dval(&u)(&u)->d *= 10.) { 3457 L = (Longint)(dval(&u)(&u)->d); 3458 if (!(dval(&u)(&u)->d -= L)) 3459 ilim = i; 3460 *s++ = '0' + (int)L; 3461 if (i == ilim) { 3462 if (dval(&u)(&u)->d > 0.5 + dval(&eps)(&eps)->d) 3463 goto bump_up; 3464 else if (dval(&u)(&u)->d < 0.5 - dval(&eps)(&eps)->d) 3465 goto retc; 3466 break; 3467 } 3468 } 3469#ifndef No_leftright 3470 } 3471#endif 3472 fast_failed: 3473 s = buf; 3474 dval(&u)(&u)->d = dval(&d2)(&d2)->d; 3475 k = k0; 3476 ilim = ilim0; 3477 } 3478 3479 /* Do we have a "small" integer? */ 3480 3481 if (be >= 0 && k <= Int_max14) { 3482 /* Yes. */ 3483 ds = tens[k]; 3484 if (ndigits < 0 && ilim <= 0) { 3485 S = mhi = 0; 3486 if (ilim < 0 || dval(&u)(&u)->d <= 5*ds) 3487 goto no_digits; 3488 goto one_digit; 3489 } 3490 for(i = 1;; i++, dval(&u)(&u)->d *= 10.) { 3491 L = (Longint)(dval(&u)(&u)->d / ds); 3492 dval(&u)(&u)->d -= L*ds; 3493#ifdef Check_FLT_ROUNDS 3494 /* If FLT_ROUNDS == 2, L will usually be high by 1 */ 3495 if (dval(&u)(&u)->d < 0) { 3496 L--; 3497 dval(&u)(&u)->d += ds; 3498 } 3499#endif 3500 *s++ = '0' + (int)L; 3501 if (!dval(&u)(&u)->d) { 3502#ifdef SET_INEXACT 3503 inexact = 0; 3504#endif 3505 break; 3506 } 3507 if (i == ilim) { 3508#ifdef Honor_FLT_ROUNDS 3509 if (mode > 1) 3510 switch(Rounding(__builtin_flt_rounds())) { 3511 case 0: goto retc; 3512 case 2: goto bump_up; 3513 } 3514#endif 3515 dval(&u)(&u)->d += dval(&u)(&u)->d; 3516#ifdef ROUND_BIASED 3517 if (dval(&u)(&u)->d >= ds) 3518#else 3519 if (dval(&u)(&u)->d > ds || (dval(&u)(&u)->d == ds && L & 1)) 3520#endif 3521 { 3522 bump_up: 3523 while(*--s == '9') 3524 if (s == buf) { 3525 k++; 3526 *s = '0'; 3527 break; 3528 } 3529 ++*s++; 3530 } 3531 break; 3532 } 3533 } 3534 goto retc; 3535 } 3536 3537#endif /*}*/ 3538 m2 = b2; 3539 m5 = b5; 3540 mhi = mlo = 0; 3541 if (leftright) { 3542 i = 3543#ifndef Sudden_Underflow 3544 denorm ? be + (Bias1023 + (P53-1) - 1 + 1) : 3545#endif 3546#ifdef IBM 3547 1 + 4*P53 - 3 - bbits + ((bbits + be - 1) & 3); 3548#else 3549 1 + P53 - bbits; 3550#endif 3551 b2 += i; 3552 s2 += i; 3553 mhi = i2b(1 MTb); 3554 } 3555 if (m2 > 0 && s2 > 0) { 3556 i = m2 < s2 ? m2 : s2; 3557 b2 -= i; 3558 m2 -= i; 3559 s2 -= i; 3560 } 3561 if (b5 > 0) { 3562 if (leftright) { 3563 if (m5 > 0) { 3564 mhi = pow5mult(mhi, m5 MTb); 3565 b1 = mult(mhi, b MTb); 3566 Bfree(b MTb); 3567 b = b1; 3568 } 3569 if ((j = b5 - m5)) 3570 b = pow5mult(b, j MTb); 3571 } 3572 else 3573 b = pow5mult(b, b5 MTb); 3574 } 3575 S = i2b(1 MTb); 3576 if (s5 > 0) 3577 S = pow5mult(S, s5 MTb); 3578 3579 if (spec_case) { 3580 b2 += Log2P1; 3581 s2 += Log2P1; 3582 } 3583 3584 /* Arrange for convenient computation of quotients: 3585 * shift left if necessary so divisor has 4 leading 0 bits. 3586 * 3587 * Perhaps we should just compute leading 28 bits of S once 3588 * and for all and pass them and a shift to quorem, so it 3589 * can do shifts and ors to compute the numerator for q. 3590 */ 3591 i = dshift(S, s2); 3592 b2 += i; 3593 m2 += i; 3594 s2 += i; 3595 if (b2 > 0) 3596 b = lshift(b, b2 MTb); 3597 if (s2 > 0) 3598 S = lshift(S, s2 MTb); 3599#ifndef USE_BF96 3600 if (k_check) { 3601 if (cmp(b,S) < 0) { 3602 k--; 3603 b = multadd(b, 10, 0 MTb); /* we botched the k estimate */ 3604 if (leftright) 3605 mhi = multadd(mhi, 10, 0 MTb); 3606 ilim = ilim1; 3607 } 3608 } 3609#endif 3610 if (ilim <= 0 && (mode == 3 || mode == 5)) { 3611 if (ilim < 0 || cmp(b,S = multadd(S,5,0 MTb)) <= 0) { 3612 /* no digits, fcvt style */ 3613 no_digits: 3614 k = -1 - ndigits; 3615 goto ret; 3616 } 3617 one_digit: 3618 *s++ = '1'; 3619 ++k; 3620 goto ret; 3621 } 3622 if (leftright) { 3623 if (m2 > 0) 3624 mhi = lshift(mhi, m2 MTb); 3625 3626 /* Compute mlo -- check for special case 3627 * that d is a normalized power of 2. 3628 */ 3629 3630 mlo = mhi; 3631 if (spec_case) { 3632 mhi = Balloc(mhi->k MTb); 3633 Bcopy(mhi, mlo)memcpy((char *)&mhi->sign, (char *)&mlo->sign, mlo
->wds*sizeof(int) + 2*sizeof(int)); 3634 mhi = lshift(mhi, Log2P1 MTb); 3635 } 3636 3637 for(i = 1;;i++) { 3638 dig = quorem(b,S) + '0'; 3639 /* Do we yet have the shortest decimal string 3640 * that will round to d? 3641 */ 3642 j = cmp(b, mlo); 3643 delta = diff(S, mhi MTb); 3644 j1 = delta->sign ? 1 : cmp(b, delta); 3645 Bfree(delta MTb); 3646#ifndef ROUND_BIASED 3647 if (j1 == 0 && mode != 1 && !(word1(&u)(&u)->L[0] & 1) 3648#ifdef Honor_FLT_ROUNDS 3649 && (mode <= 1 || Rounding(__builtin_flt_rounds()) >= 1) 3650#endif 3651 ) { 3652 if (dig == '9') 3653 goto round_9_up; 3654 if (j > 0) 3655 dig++; 3656#ifdef SET_INEXACT 3657 else if (!b->x[0] && b->wds <= 1) 3658 inexact = 0; 3659#endif 3660 *s++ = dig; 3661 goto ret; 3662 } 3663#endif 3664 if (j < 0 || (j == 0 && mode != 1 3665#ifndef ROUND_BIASED 3666 && !(word1(&u)(&u)->L[0] & 1) 3667#endif 3668 )) { 3669 if (!b->x[0] && b->wds <= 1) { 3670#ifdef SET_INEXACT 3671 inexact = 0; 3672#endif 3673 goto accept_dig; 3674 } 3675#ifdef Honor_FLT_ROUNDS 3676 if (mode > 1) 3677 switch(Rounding(__builtin_flt_rounds())) { 3678 case 0: goto accept_dig; 3679 case 2: goto keep_dig; 3680 } 3681#endif /*Honor_FLT_ROUNDS*/ 3682 if (j1 > 0) { 3683 b = lshift(b, 1 MTb); 3684 j1 = cmp(b, S); 3685#ifdef ROUND_BIASED 3686 if (j1 >= 0 /*)*/ 3687#else 3688 if ((j1 > 0 || (j1 == 0 && dig & 1)) 3689#endif 3690 && dig++ == '9') 3691 goto round_9_up; 3692 } 3693 accept_dig: 3694 *s++ = dig; 3695 goto ret; 3696 } 3697 if (j1 > 0) { 3698#ifdef Honor_FLT_ROUNDS 3699 if (!Rounding(__builtin_flt_rounds()) && mode > 1) 3700 goto accept_dig; 3701#endif 3702 if (dig == '9') { /* possible if i == 1 */ 3703 round_9_up: 3704 *s++ = '9'; 3705 goto roundoff; 3706 } 3707 *s++ = dig + 1; 3708 goto ret; 3709 } 3710#ifdef Honor_FLT_ROUNDS 3711 keep_dig: 3712#endif 3713 *s++ = dig; 3714 if (i == ilim) 3715 break; 3716 b = multadd(b, 10, 0 MTb); 3717 if (mlo == mhi) 3718 mlo = mhi = multadd(mhi, 10, 0 MTb); 3719 else { 3720 mlo = multadd(mlo, 10, 0 MTb); 3721 mhi = multadd(mhi, 10, 0 MTb); 3722 } 3723 } 3724 } 3725 else 3726 for(i = 1;; i++) { 3727 dig = quorem(b,S) + '0'; 3728 *s++ = dig; 3729 if (!b->x[0] && b->wds <= 1) { 3730#ifdef SET_INEXACT 3731 inexact = 0; 3732#endif 3733 goto ret; 3734 } 3735 if (i >= ilim) 3736 break; 3737 b = multadd(b, 10, 0 MTb); 3738 } 3739 3740 /* Round off last digit */ 3741 3742#ifdef Honor_FLT_ROUNDS 3743 if (mode > 1) 3744 switch(Rounding(__builtin_flt_rounds())) { 3745 case 0: goto ret; 3746 case 2: goto roundoff; 3747 } 3748#endif 3749 b = lshift(b, 1 MTb); 3750 j = cmp(b, S); 3751#ifdef ROUND_BIASED 3752 if (j >= 0) 3753#else 3754 if (j > 0 || (j == 0 && dig & 1)) 3755#endif 3756 { 3757 roundoff: 3758 while(*--s == '9') 3759 if (s == buf) { 3760 k++; 3761 *s++ = '1'; 3762 goto ret; 3763 } 3764 ++*s++; 3765 } 3766 ret: 3767 Bfree(S MTb); 3768 if (mhi) { 3769 if (mlo && mlo != mhi) 3770 Bfree(mlo MTb); 3771 Bfree(mhi MTb); 3772 } 3773 retc: 3774 while(s > buf && s[-1] == '0') 3775 --s; 3776 ret1: 3777 if (b) 3778 Bfree(b MTb); 3779 *s = 0; 3780 *decpt = k + 1; 3781 if (rve) 3782 *rve = s; 3783#ifdef SET_INEXACT 3784 if (inexact) { 3785 if (!oldinexact) { 3786 word0(&u)(&u)->L[1] = Exp_10x3ff00000 + (70 << Exp_shift20); 3787 word1(&u)(&u)->L[0] = 0; 3788 dval(&u)(&u)->d += 1.; 3789 } 3790 } 3791 else if (!oldinexact) 3792 clear_inexact(); 3793#endif 3794 return buf; 3795 } 3796 3797 char * 3798dtoa(double dd, int mode, int ndigits, int *decpt, int *sign, char **rve) 3799{ 3800 /* Sufficient space is allocated to the return value 3801 to hold the suppressed trailing zeros. 3802 See dtoa_r() above for details on the other arguments. 3803 */ 3804#ifndef MULTIPLE_THREADS 3805 if (dtoa_result) 3806 freedtoa(dtoa_result); 3807#endif 3808 return dtoa_r(dd, mode, ndigits, decpt, sign, rve, 0, 0); 3809 } 3810 3811 3812 char * 3813dtoa_g_fmt(register char *b, double x) 3814{ 3815 register int i, k; 3816 register char *s; 3817 int decpt, j, sign; 3818 char *b0, *s0, *se; 3819 3820 b0 = b; 3821#ifdef IGNORE_ZERO_SIGN 3822 if (!x) { 3823 *b++ = '0'; 3824 *b = 0; 3825 goto done; 3826 } 3827#endif 3828 s = s0 = dtoa(x, 0, 0, &decpt, &sign, &se); 3829 if (sign) 3830 *b++ = '-'; 3831 if (decpt == 9999) /* Infinity or Nan */ { 3832 while((*b++ = *s++)); 3833 goto done0; 3834 } 3835 if (decpt <= -4 || decpt > se - s + 5) { 3836 *b++ = *s++; 3837 if (*s) { 3838 *b++ = '.'; 3839 while((*b = *s++)) 3840 b++; 3841 } 3842 *b++ = 'e'; 3843 /* sprintf(b, "%+.2d", decpt - 1); */ 3844 if (--decpt < 0) { 3845 *b++ = '-'; 3846 decpt = -decpt; 3847 } 3848 else 3849 *b++ = '+'; 3850 for(j = 2, k = 10; 10*k <= decpt; j++, k *= 10); 3851 for(;;) { 3852 i = decpt / k; 3853 *b++ = i + '0'; 3854 if (--j <= 0) 3855 break; 3856 decpt -= i*k; 3857 decpt *= 10; 3858 } 3859 *b = 0; 3860 } 3861 else if (decpt <= 0) { 3862 *b++ = '0'; // Add leading zero, not in dmg's original 3863 *b++ = '.'; 3864 for(; decpt < 0; decpt++) 3865 *b++ = '0'; 3866 while((*b++ = *s++)); 3867 } 3868 else { 3869 while((*b = *s++)) { 3870 b++; 3871 if (--decpt == 0 && *s) 3872 *b++ = '.'; 3873 } 3874 for(; decpt > 0; decpt--) 3875 *b++ = '0'; 3876 *b = 0; 3877 } 3878 done0: 3879 freedtoa(s0); 3880#ifdef IGNORE_ZERO_SIGN 3881 done: 3882#endif 3883 return b0; 3884 } 3885 3886 3887#ifdef __cplusplus 3888} 3889#endif