1 /* mpfr_get_str -- output a floating-point number to a string
2
3 Copyright 1999-2023 Free Software Foundation, Inc.
4 Contributed by the AriC and Caramba projects, INRIA.
5
6 This file is part of the GNU MPFR Library.
7
8 The GNU MPFR Library is free software; you can redistribute it and/or modify
9 it under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or (at your
11 option) any later version.
12
13 The GNU MPFR Library is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
16 License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with the GNU MPFR Library; see the file COPYING.LESSER. If not, see
20 https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc.,
21 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. */
22
23 #define MPFR_NEED_LONGLONG_H
24 #define MPFR_NEED_INTMAX_H
25 #include "mpfr-impl.h"
26
27 static int mpfr_get_str_aux (char *const, mpfr_exp_t *const, mp_limb_t *const,
28 mp_size_t, mpfr_exp_t, long, int, size_t, mpfr_rnd_t);
29
30 /* The implicit \0 is useless, but we do not write num_to_text[62] otherwise
31 g++ complains. */
32 static const char num_to_text36[] = "0123456789abcdefghijklmnopqrstuvwxyz";
33 static const char num_to_text62[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
34 "abcdefghijklmnopqrstuvwxyz";
35
36 /* copy most important limbs of {op, n2} in {rp, n1} */
37 /* if n1 > n2 put 0 in low limbs of {rp, n1} */
38 #define MPN_COPY2(rp, n1, op, n2) \
39 if ((n1) <= (n2)) \
40 { \
41 MPN_COPY ((rp), (op) + (n2) - (n1), (n1)); \
42 } \
43 else \
44 { \
45 MPN_COPY ((rp) + (n1) - (n2), (op), (n2)); \
46 MPN_ZERO ((rp), (n1) - (n2)); \
47 }
48
49 #define MPFR_ROUND_FAILED 3
50
51 /* Input: an approximation r*2^f to a real Y, with |r*2^f - Y| <= 2^(e+f).
52
53 If rounding is possible, returns:
54 - in s: a string representing the significand corresponding to
55 the integer nearest to Y, within the direction rnd;
56 - in exp: the exponent.
57
58 n is the number of limbs of r.
59 e represents the maximal error in the approximation to Y (see above),
60 (e < 0 means that the approximation is known to be exact, i.e.,
61 r*2^f = Y).
62 b is the wanted base (2 <= b <= 62 or -36 <= b <= -2).
63 m is the number of wanted digits in the significand.
64 rnd is the rounding mode.
65 It is assumed that b^(m-1) <= Y < b^(m+1), thus the returned value
66 satisfies b^(m-1) <= rnd(Y) < b^(m+1).
67
68 Rounding may fail for two reasons:
69 - the error is too large to determine the integer N nearest to Y
70 - either the number of digits of N in base b is too large (m+1),
71 N=2*N1+(b/2) and the rounding mode is to nearest. This can
72 only happen when b is even.
73
74 Return value:
75 - the direction of rounding (-1, 0, 1) if rounding is possible
76 - -MPFR_ROUND_FAILED if rounding not possible because m+1 digits
77 - MPFR_ROUND_FAILED otherwise (too large error)
78 */
79 static int
80 mpfr_get_str_aux (char *const str, mpfr_exp_t *const exp, mp_limb_t *const r,
81 mp_size_t n, mpfr_exp_t f, long e, int b, size_t m,
82 mpfr_rnd_t rnd)
83 {
84 const char *num_to_text;
85 int b0 = b; /* initial base (might be negative) */
86 int dir; /* direction of the rounded result */
87 mp_limb_t ret = 0; /* possible carry in addition */
88 mp_size_t i0, j0; /* number of limbs and bits of Y */
89 unsigned char *str1; /* string of m+2 characters */
90 size_t size_s1; /* length of str1 */
91 mpfr_rnd_t rnd1;
92 size_t i;
93 int exact = (e < 0);
94 MPFR_TMP_DECL(marker);
95
96 /* if f > 0, then the maximal error 2^(e+f) is larger than 2 so we can't
97 determine the integer Y */
98 MPFR_ASSERTN(f <= 0);
99 /* if f is too small, then r*2^f is smaller than 1 */
100 MPFR_ASSERTN(f > (-n * GMP_NUMB_BITS));
101
102 MPFR_TMP_MARK(marker);
103
104 num_to_text = (2 <= b0 && b0 <= 36) ? num_to_text36 : num_to_text62;
105 b = (b0 > 0) ? b0 : -b0;
106
107 /* R = 2^f sum r[i]K^(i)
108 r[i] = (r_(i,k-1)...r_(i,0))_2
109 R = sum r(i,j)2^(j+ki+f)
110 the bits from R are referenced by pairs (i,j) */
111
112 /* check if is possible to round r with rnd mode
113 where |r*2^f - Y| <= 2^(e+f)
114 the exponent of R is: f + n*GMP_NUMB_BITS
115 we must have e + f == f + n*GMP_NUMB_BITS - err
116 err = n*GMP_NUMB_BITS - e
117 R contains exactly -f bits after the integer point:
118 to determine the nearest integer, we thus need a precision of
119 n * GMP_NUMB_BITS + f */
120
121 if (exact || mpfr_round_p (r, n, n * GMP_NUMB_BITS - e,
122 n * GMP_NUMB_BITS + f + (rnd == MPFR_RNDN)))
123 {
124 /* compute the nearest integer to R */
125
126 /* bit of weight 0 in R has position j0 in limb r[i0] */
127 i0 = (-f) / GMP_NUMB_BITS;
128 j0 = (-f) % GMP_NUMB_BITS;
129
130 ret = mpfr_round_raw (r + i0, r, n * GMP_NUMB_BITS, 0,
131 n * GMP_NUMB_BITS + f, rnd, &dir);
132 MPFR_ASSERTD(dir != MPFR_ROUND_FAILED);
133
134 if (ret) /* Y is a power of 2 */
135 {
136 if (j0)
137 r[n - 1] = MPFR_LIMB_HIGHBIT >> (j0 - 1);
138 else /* j0=0, necessarily i0 >= 1 otherwise f=0 and r is exact */
139 {
140 r[n - 1] = ret;
141 r[--i0] = 0; /* set to zero the new low limb */
142 }
143 }
144 else /* shift r to the right by (-f) bits (i0 already done) */
145 {
146 if (j0)
147 mpn_rshift (r + i0, r + i0, n - i0, j0);
148 }
149
150 /* now the rounded value Y is in {r+i0, n-i0} */
151
152 /* convert r+i0 into base b: we use b0 which might be in -36..-2 */
153 str1 = (unsigned char*) MPFR_TMP_ALLOC (m + 3); /* need one extra character for mpn_get_str */
154 size_s1 = mpn_get_str (str1, b, r + i0, n - i0);
155
156 /* round str1 */
157 MPFR_ASSERTN(size_s1 >= m);
158 *exp = size_s1 - m; /* number of superfluous characters */
159
160 /* if size_s1 = m + 2, necessarily we have b^(m+1) as result,
161 and the result will not change */
162
163 /* so we have to double-round only when size_s1 = m + 1 and
164 (i) the result is inexact
165 (ii) or the last digit is non-zero */
166 if ((size_s1 == m + 1) && ((dir != 0) || (str1[size_s1 - 1] != 0)))
167 {
168 /* rounding mode */
169 rnd1 = rnd;
170
171 /* round to nearest case */
172 if (rnd == MPFR_RNDN)
173 {
174 if (2 * str1[size_s1 - 1] == b)
175 {
176 if (dir == 0 && exact) /* exact: even rounding */
177 {
178 rnd1 = ((str1[size_s1 - 2] & 1) == 0)
179 ? MPFR_RNDD : MPFR_RNDU;
180 }
181 else
182 {
183 /* otherwise we cannot round correctly: for example
184 if b=10, we might have a mantissa of
185 xxxxxxx5.00000000 which can be rounded to nearest
186 to 8 digits but not to 7 */
187 dir = -MPFR_ROUND_FAILED;
188 MPFR_ASSERTD(dir != MPFR_EVEN_INEX);
189 goto free_and_return;
190 }
191 }
192 else if (2 * str1[size_s1 - 1] < b)
193 rnd1 = MPFR_RNDD;
194 else
195 rnd1 = MPFR_RNDU;
196 }
197
198 /* now rnd1 is either
199 MPFR_RNDD or MPFR_RNDZ -> truncate, or
200 MPFR_RNDU or MPFR_RNDA -> round toward infinity */
201
202 /* round away from zero */
203 if (rnd1 == MPFR_RNDU || rnd1 == MPFR_RNDA)
204 {
205 if (str1[size_s1 - 1] != 0)
206 {
207 /* the carry cannot propagate to the whole string, since
208 Y = x*b^(m-g) < 2*b^m <= b^(m+1)-b
209 where x is the input float */
210 MPFR_ASSERTN(size_s1 >= 2);
211 i = size_s1 - 2;
212 while (str1[i] == b - 1)
213 {
214 MPFR_ASSERTD(i > 0);
215 str1[i--] = 0;
216 }
217 str1[i]++;
218 }
219 dir = 1;
220 }
221 /* round toward zero (truncate) */
222 else
223 dir = -1;
224 }
225
226 /* copy str1 into str and convert to characters (digits and
227 lowercase letters from the source character set) */
228 for (i = 0; i < m; i++)
229 str[i] = num_to_text[(int) str1[i]]; /* str1[i] is an unsigned char */
230 str[m] = 0;
231 }
232 /* mpfr_can_round_raw failed: rounding is not possible */
233 else
234 {
235 dir = MPFR_ROUND_FAILED; /* should be different from MPFR_EVEN_INEX */
236 MPFR_ASSERTD(dir != MPFR_EVEN_INEX);
237 }
238
239 free_and_return:
240 MPFR_TMP_FREE(marker);
241
242 return dir;
243 }
244
245 /***************************************************************************
246 * __gmpfr_l2b[b-2][0] is a 23-bit upper approximation to log(b)/log(2), *
247 * __gmpfr_l2b[b-2][1] is a 77-bit upper approximation to log(2)/log(b). *
248 * The following code is generated by tests/tl2b (with an argument). *
249 ***************************************************************************/
250
251 #ifndef UINT64_C
252 # define UINT64_C(c) c
253 #endif
254
255 #if 0
256 #elif GMP_NUMB_BITS == 8
257 const mp_limb_t mpfr_l2b_2_0__tab[] = { 0x00, 0x00, 0x80 };
258 #elif GMP_NUMB_BITS == 16
259 const mp_limb_t mpfr_l2b_2_0__tab[] = { 0x0000, 0x8000 };
260 #elif GMP_NUMB_BITS == 32
261 const mp_limb_t mpfr_l2b_2_0__tab[] = { 0x80000000 };
262 #elif GMP_NUMB_BITS == 64
263 const mp_limb_t mpfr_l2b_2_0__tab[] = { UINT64_C(0x8000000000000000) };
264 #elif GMP_NUMB_BITS == 96
265 const mp_limb_t mpfr_l2b_2_0__tab[] = { 0x800000000000000000000000 };
266 #elif GMP_NUMB_BITS == 128
267 const mp_limb_t mpfr_l2b_2_0__tab[] = { 0x80000000000000000000000000000000 };
268 #elif GMP_NUMB_BITS == 256
269 const mp_limb_t mpfr_l2b_2_0__tab[] = { 0x8000000000000000000000000000000000000000000000000000000000000000 };
270 #endif
271
272 #if 0
273 #elif GMP_NUMB_BITS == 8
274 const mp_limb_t mpfr_l2b_2_1__tab[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 };
275 #elif GMP_NUMB_BITS == 16
276 const mp_limb_t mpfr_l2b_2_1__tab[] = { 0x0000, 0x0000, 0x0000, 0x0000, 0x8000 };
277 #elif GMP_NUMB_BITS == 32
278 const mp_limb_t mpfr_l2b_2_1__tab[] = { 0x00000000, 0x00000000, 0x80000000 };
279 #elif GMP_NUMB_BITS == 64
280 const mp_limb_t mpfr_l2b_2_1__tab[] = { UINT64_C(0x0000000000000000), UINT64_C(0x8000000000000000) };
281 #elif GMP_NUMB_BITS == 96
282 const mp_limb_t mpfr_l2b_2_1__tab[] = { 0x800000000000000000000000 };
283 #elif GMP_NUMB_BITS == 128
284 const mp_limb_t mpfr_l2b_2_1__tab[] = { 0x80000000000000000000000000000000 };
285 #elif GMP_NUMB_BITS == 256
286 const mp_limb_t mpfr_l2b_2_1__tab[] = { 0x8000000000000000000000000000000000000000000000000000000000000000 };
287 #endif
288
289 #if 0
290 #elif GMP_NUMB_BITS == 8
291 const mp_limb_t mpfr_l2b_3_0__tab[] = { 0x0e, 0xe0, 0xca };
292 #elif GMP_NUMB_BITS == 16
293 const mp_limb_t mpfr_l2b_3_0__tab[] = { 0x0e00, 0xcae0 };
294 #elif GMP_NUMB_BITS == 32
295 const mp_limb_t mpfr_l2b_3_0__tab[] = { 0xcae00e00 };
296 #elif GMP_NUMB_BITS == 64
297 const mp_limb_t mpfr_l2b_3_0__tab[] = { UINT64_C(0xcae00e0000000000) };
298 #elif GMP_NUMB_BITS == 96
299 const mp_limb_t mpfr_l2b_3_0__tab[] = { 0xcae00e000000000000000000 };
300 #elif GMP_NUMB_BITS == 128
301 const mp_limb_t mpfr_l2b_3_0__tab[] = { 0xcae00e00000000000000000000000000 };
302 #elif GMP_NUMB_BITS == 256
303 const mp_limb_t mpfr_l2b_3_0__tab[] = { 0xcae00e0000000000000000000000000000000000000000000000000000000000 };
304 #endif
305
306 #if 0
307 #elif GMP_NUMB_BITS == 8
308 const mp_limb_t mpfr_l2b_3_1__tab[] = { 0x48, 0x04, 0x4e, 0xe9, 0xa9, 0xa9, 0xc1, 0x9c, 0x84, 0xa1 };
309 #elif GMP_NUMB_BITS == 16
310 const mp_limb_t mpfr_l2b_3_1__tab[] = { 0x0448, 0xe94e, 0xa9a9, 0x9cc1, 0xa184 };
311 #elif GMP_NUMB_BITS == 32
312 const mp_limb_t mpfr_l2b_3_1__tab[] = { 0x04480000, 0xa9a9e94e, 0xa1849cc1 };
313 #elif GMP_NUMB_BITS == 64
314 const mp_limb_t mpfr_l2b_3_1__tab[] = { UINT64_C(0x0448000000000000), UINT64_C(0xa1849cc1a9a9e94e) };
315 #elif GMP_NUMB_BITS == 96
316 const mp_limb_t mpfr_l2b_3_1__tab[] = { 0xa1849cc1a9a9e94e04480000 };
317 #elif GMP_NUMB_BITS == 128
318 const mp_limb_t mpfr_l2b_3_1__tab[] = { 0xa1849cc1a9a9e94e0448000000000000 };
319 #elif GMP_NUMB_BITS == 256
320 const mp_limb_t mpfr_l2b_3_1__tab[] = { 0xa1849cc1a9a9e94e044800000000000000000000000000000000000000000000 };
321 #endif
322
323 #if 0
324 #elif GMP_NUMB_BITS == 8
325 const mp_limb_t mpfr_l2b_4_0__tab[] = { 0x00, 0x00, 0x80 };
326 #elif GMP_NUMB_BITS == 16
327 const mp_limb_t mpfr_l2b_4_0__tab[] = { 0x0000, 0x8000 };
328 #elif GMP_NUMB_BITS == 32
329 const mp_limb_t mpfr_l2b_4_0__tab[] = { 0x80000000 };
330 #elif GMP_NUMB_BITS == 64
331 const mp_limb_t mpfr_l2b_4_0__tab[] = { UINT64_C(0x8000000000000000) };
332 #elif GMP_NUMB_BITS == 96
333 const mp_limb_t mpfr_l2b_4_0__tab[] = { 0x800000000000000000000000 };
334 #elif GMP_NUMB_BITS == 128
335 const mp_limb_t mpfr_l2b_4_0__tab[] = { 0x80000000000000000000000000000000 };
336 #elif GMP_NUMB_BITS == 256
337 const mp_limb_t mpfr_l2b_4_0__tab[] = { 0x8000000000000000000000000000000000000000000000000000000000000000 };
338 #endif
339
340 #if 0
341 #elif GMP_NUMB_BITS == 8
342 const mp_limb_t mpfr_l2b_4_1__tab[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 };
343 #elif GMP_NUMB_BITS == 16
344 const mp_limb_t mpfr_l2b_4_1__tab[] = { 0x0000, 0x0000, 0x0000, 0x0000, 0x8000 };
345 #elif GMP_NUMB_BITS == 32
346 const mp_limb_t mpfr_l2b_4_1__tab[] = { 0x00000000, 0x00000000, 0x80000000 };
347 #elif GMP_NUMB_BITS == 64
348 const mp_limb_t mpfr_l2b_4_1__tab[] = { UINT64_C(0x0000000000000000), UINT64_C(0x8000000000000000) };
349 #elif GMP_NUMB_BITS == 96
350 const mp_limb_t mpfr_l2b_4_1__tab[] = { 0x800000000000000000000000 };
351 #elif GMP_NUMB_BITS == 128
352 const mp_limb_t mpfr_l2b_4_1__tab[] = { 0x80000000000000000000000000000000 };
353 #elif GMP_NUMB_BITS == 256
354 const mp_limb_t mpfr_l2b_4_1__tab[] = { 0x8000000000000000000000000000000000000000000000000000000000000000 };
355 #endif
356
357 #if 0
358 #elif GMP_NUMB_BITS == 8
359 const mp_limb_t mpfr_l2b_5_0__tab[] = { 0x7a, 0x9a, 0x94 };
360 #elif GMP_NUMB_BITS == 16
361 const mp_limb_t mpfr_l2b_5_0__tab[] = { 0x7a00, 0x949a };
362 #elif GMP_NUMB_BITS == 32
363 const mp_limb_t mpfr_l2b_5_0__tab[] = { 0x949a7a00 };
364 #elif GMP_NUMB_BITS == 64
365 const mp_limb_t mpfr_l2b_5_0__tab[] = { UINT64_C(0x949a7a0000000000) };
366 #elif GMP_NUMB_BITS == 96
367 const mp_limb_t mpfr_l2b_5_0__tab[] = { 0x949a7a000000000000000000 };
368 #elif GMP_NUMB_BITS == 128
369 const mp_limb_t mpfr_l2b_5_0__tab[] = { 0x949a7a00000000000000000000000000 };
370 #elif GMP_NUMB_BITS == 256
371 const mp_limb_t mpfr_l2b_5_0__tab[] = { 0x949a7a0000000000000000000000000000000000000000000000000000000000 };
372 #endif
373
374 #if 0
375 #elif GMP_NUMB_BITS == 8
376 const mp_limb_t mpfr_l2b_5_1__tab[] = { 0xb8, 0x67, 0x28, 0x97, 0x7b, 0x28, 0x48, 0xa3, 0x81, 0xdc };
377 #elif GMP_NUMB_BITS == 16
378 const mp_limb_t mpfr_l2b_5_1__tab[] = { 0x67b8, 0x9728, 0x287b, 0xa348, 0xdc81 };
379 #elif GMP_NUMB_BITS == 32
380 const mp_limb_t mpfr_l2b_5_1__tab[] = { 0x67b80000, 0x287b9728, 0xdc81a348 };
381 #elif GMP_NUMB_BITS == 64
382 const mp_limb_t mpfr_l2b_5_1__tab[] = { UINT64_C(0x67b8000000000000), UINT64_C(0xdc81a348287b9728) };
383 #elif GMP_NUMB_BITS == 96
384 const mp_limb_t mpfr_l2b_5_1__tab[] = { 0xdc81a348287b972867b80000 };
385 #elif GMP_NUMB_BITS == 128
386 const mp_limb_t mpfr_l2b_5_1__tab[] = { 0xdc81a348287b972867b8000000000000 };
387 #elif GMP_NUMB_BITS == 256
388 const mp_limb_t mpfr_l2b_5_1__tab[] = { 0xdc81a348287b972867b800000000000000000000000000000000000000000000 };
389 #endif
390
391 #if 0
392 #elif GMP_NUMB_BITS == 8
393 const mp_limb_t mpfr_l2b_6_0__tab[] = { 0x08, 0x70, 0xa5 };
394 #elif GMP_NUMB_BITS == 16
395 const mp_limb_t mpfr_l2b_6_0__tab[] = { 0x0800, 0xa570 };
396 #elif GMP_NUMB_BITS == 32
397 const mp_limb_t mpfr_l2b_6_0__tab[] = { 0xa5700800 };
398 #elif GMP_NUMB_BITS == 64
399 const mp_limb_t mpfr_l2b_6_0__tab[] = { UINT64_C(0xa570080000000000) };
400 #elif GMP_NUMB_BITS == 96
401 const mp_limb_t mpfr_l2b_6_0__tab[] = { 0xa57008000000000000000000 };
402 #elif GMP_NUMB_BITS == 128
403 const mp_limb_t mpfr_l2b_6_0__tab[] = { 0xa5700800000000000000000000000000 };
404 #elif GMP_NUMB_BITS == 256
405 const mp_limb_t mpfr_l2b_6_0__tab[] = { 0xa570080000000000000000000000000000000000000000000000000000000000 };
406 #endif
407
408 #if 0
409 #elif GMP_NUMB_BITS == 8
410 const mp_limb_t mpfr_l2b_6_1__tab[] = { 0x10, 0xff, 0xe9, 0xf9, 0x54, 0xe0, 0x36, 0x92, 0x11, 0xc6 };
411 #elif GMP_NUMB_BITS == 16
412 const mp_limb_t mpfr_l2b_6_1__tab[] = { 0xff10, 0xf9e9, 0xe054, 0x9236, 0xc611 };
413 #elif GMP_NUMB_BITS == 32
414 const mp_limb_t mpfr_l2b_6_1__tab[] = { 0xff100000, 0xe054f9e9, 0xc6119236 };
415 #elif GMP_NUMB_BITS == 64
416 const mp_limb_t mpfr_l2b_6_1__tab[] = { UINT64_C(0xff10000000000000), UINT64_C(0xc6119236e054f9e9) };
417 #elif GMP_NUMB_BITS == 96
418 const mp_limb_t mpfr_l2b_6_1__tab[] = { 0xc6119236e054f9e9ff100000 };
419 #elif GMP_NUMB_BITS == 128
420 const mp_limb_t mpfr_l2b_6_1__tab[] = { 0xc6119236e054f9e9ff10000000000000 };
421 #elif GMP_NUMB_BITS == 256
422 const mp_limb_t mpfr_l2b_6_1__tab[] = { 0xc6119236e054f9e9ff1000000000000000000000000000000000000000000000 };
423 #endif
424
425 #if 0
426 #elif GMP_NUMB_BITS == 8
427 const mp_limb_t mpfr_l2b_7_0__tab[] = { 0xb4, 0xab, 0xb3 };
428 #elif GMP_NUMB_BITS == 16
429 const mp_limb_t mpfr_l2b_7_0__tab[] = { 0xb400, 0xb3ab };
430 #elif GMP_NUMB_BITS == 32
431 const mp_limb_t mpfr_l2b_7_0__tab[] = { 0xb3abb400 };
432 #elif GMP_NUMB_BITS == 64
433 const mp_limb_t mpfr_l2b_7_0__tab[] = { UINT64_C(0xb3abb40000000000) };
434 #elif GMP_NUMB_BITS == 96
435 const mp_limb_t mpfr_l2b_7_0__tab[] = { 0xb3abb4000000000000000000 };
436 #elif GMP_NUMB_BITS == 128
437 const mp_limb_t mpfr_l2b_7_0__tab[] = { 0xb3abb400000000000000000000000000 };
438 #elif GMP_NUMB_BITS == 256
439 const mp_limb_t mpfr_l2b_7_0__tab[] = { 0xb3abb40000000000000000000000000000000000000000000000000000000000 };
440 #endif
441
442 #if 0
443 #elif GMP_NUMB_BITS == 8
444 const mp_limb_t mpfr_l2b_7_1__tab[] = { 0xb8, 0x37, 0x11, 0xa7, 0x4d, 0x75, 0xd6, 0xc9, 0x60, 0xb6 };
445 #elif GMP_NUMB_BITS == 16
446 const mp_limb_t mpfr_l2b_7_1__tab[] = { 0x37b8, 0xa711, 0x754d, 0xc9d6, 0xb660 };
447 #elif GMP_NUMB_BITS == 32
448 const mp_limb_t mpfr_l2b_7_1__tab[] = { 0x37b80000, 0x754da711, 0xb660c9d6 };
449 #elif GMP_NUMB_BITS == 64
450 const mp_limb_t mpfr_l2b_7_1__tab[] = { UINT64_C(0x37b8000000000000), UINT64_C(0xb660c9d6754da711) };
451 #elif GMP_NUMB_BITS == 96
452 const mp_limb_t mpfr_l2b_7_1__tab[] = { 0xb660c9d6754da71137b80000 };
453 #elif GMP_NUMB_BITS == 128
454 const mp_limb_t mpfr_l2b_7_1__tab[] = { 0xb660c9d6754da71137b8000000000000 };
455 #elif GMP_NUMB_BITS == 256
456 const mp_limb_t mpfr_l2b_7_1__tab[] = { 0xb660c9d6754da71137b800000000000000000000000000000000000000000000 };
457 #endif
458
459 #if 0
460 #elif GMP_NUMB_BITS == 8
461 const mp_limb_t mpfr_l2b_8_0__tab[] = { 0x00, 0x00, 0xc0 };
462 #elif GMP_NUMB_BITS == 16
463 const mp_limb_t mpfr_l2b_8_0__tab[] = { 0x0000, 0xc000 };
464 #elif GMP_NUMB_BITS == 32
465 const mp_limb_t mpfr_l2b_8_0__tab[] = { 0xc0000000 };
466 #elif GMP_NUMB_BITS == 64
467 const mp_limb_t mpfr_l2b_8_0__tab[] = { UINT64_C(0xc000000000000000) };
468 #elif GMP_NUMB_BITS == 96
469 const mp_limb_t mpfr_l2b_8_0__tab[] = { 0xc00000000000000000000000 };
470 #elif GMP_NUMB_BITS == 128
471 const mp_limb_t mpfr_l2b_8_0__tab[] = { 0xc0000000000000000000000000000000 };
472 #elif GMP_NUMB_BITS == 256
473 const mp_limb_t mpfr_l2b_8_0__tab[] = { 0xc000000000000000000000000000000000000000000000000000000000000000 };
474 #endif
475
476 #if 0
477 #elif GMP_NUMB_BITS == 8
478 const mp_limb_t mpfr_l2b_8_1__tab[] = { 0xb0, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa };
479 #elif GMP_NUMB_BITS == 16
480 const mp_limb_t mpfr_l2b_8_1__tab[] = { 0xaab0, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
481 #elif GMP_NUMB_BITS == 32
482 const mp_limb_t mpfr_l2b_8_1__tab[] = { 0xaab00000, 0xaaaaaaaa, 0xaaaaaaaa };
483 #elif GMP_NUMB_BITS == 64
484 const mp_limb_t mpfr_l2b_8_1__tab[] = { UINT64_C(0xaab0000000000000), UINT64_C(0xaaaaaaaaaaaaaaaa) };
485 #elif GMP_NUMB_BITS == 96
486 const mp_limb_t mpfr_l2b_8_1__tab[] = { 0xaaaaaaaaaaaaaaaaaab00000 };
487 #elif GMP_NUMB_BITS == 128
488 const mp_limb_t mpfr_l2b_8_1__tab[] = { 0xaaaaaaaaaaaaaaaaaab0000000000000 };
489 #elif GMP_NUMB_BITS == 256
490 const mp_limb_t mpfr_l2b_8_1__tab[] = { 0xaaaaaaaaaaaaaaaaaab000000000000000000000000000000000000000000000 };
491 #endif
492
493 #if 0
494 #elif GMP_NUMB_BITS == 8
495 const mp_limb_t mpfr_l2b_9_0__tab[] = { 0x0e, 0xe0, 0xca };
496 #elif GMP_NUMB_BITS == 16
497 const mp_limb_t mpfr_l2b_9_0__tab[] = { 0x0e00, 0xcae0 };
498 #elif GMP_NUMB_BITS == 32
499 const mp_limb_t mpfr_l2b_9_0__tab[] = { 0xcae00e00 };
500 #elif GMP_NUMB_BITS == 64
501 const mp_limb_t mpfr_l2b_9_0__tab[] = { UINT64_C(0xcae00e0000000000) };
502 #elif GMP_NUMB_BITS == 96
503 const mp_limb_t mpfr_l2b_9_0__tab[] = { 0xcae00e000000000000000000 };
504 #elif GMP_NUMB_BITS == 128
505 const mp_limb_t mpfr_l2b_9_0__tab[] = { 0xcae00e00000000000000000000000000 };
506 #elif GMP_NUMB_BITS == 256
507 const mp_limb_t mpfr_l2b_9_0__tab[] = { 0xcae00e0000000000000000000000000000000000000000000000000000000000 };
508 #endif
509
510 #if 0
511 #elif GMP_NUMB_BITS == 8
512 const mp_limb_t mpfr_l2b_9_1__tab[] = { 0x48, 0x04, 0x4e, 0xe9, 0xa9, 0xa9, 0xc1, 0x9c, 0x84, 0xa1 };
513 #elif GMP_NUMB_BITS == 16
514 const mp_limb_t mpfr_l2b_9_1__tab[] = { 0x0448, 0xe94e, 0xa9a9, 0x9cc1, 0xa184 };
515 #elif GMP_NUMB_BITS == 32
516 const mp_limb_t mpfr_l2b_9_1__tab[] = { 0x04480000, 0xa9a9e94e, 0xa1849cc1 };
517 #elif GMP_NUMB_BITS == 64
518 const mp_limb_t mpfr_l2b_9_1__tab[] = { UINT64_C(0x0448000000000000), UINT64_C(0xa1849cc1a9a9e94e) };
519 #elif GMP_NUMB_BITS == 96
520 const mp_limb_t mpfr_l2b_9_1__tab[] = { 0xa1849cc1a9a9e94e04480000 };
521 #elif GMP_NUMB_BITS == 128
522 const mp_limb_t mpfr_l2b_9_1__tab[] = { 0xa1849cc1a9a9e94e0448000000000000 };
523 #elif GMP_NUMB_BITS == 256
524 const mp_limb_t mpfr_l2b_9_1__tab[] = { 0xa1849cc1a9a9e94e044800000000000000000000000000000000000000000000 };
525 #endif
526
527 #if 0
528 #elif GMP_NUMB_BITS == 8
529 const mp_limb_t mpfr_l2b_10_0__tab[] = { 0x7a, 0x9a, 0xd4 };
530 #elif GMP_NUMB_BITS == 16
531 const mp_limb_t mpfr_l2b_10_0__tab[] = { 0x7a00, 0xd49a };
532 #elif GMP_NUMB_BITS == 32
533 const mp_limb_t mpfr_l2b_10_0__tab[] = { 0xd49a7a00 };
534 #elif GMP_NUMB_BITS == 64
535 const mp_limb_t mpfr_l2b_10_0__tab[] = { UINT64_C(0xd49a7a0000000000) };
536 #elif GMP_NUMB_BITS == 96
537 const mp_limb_t mpfr_l2b_10_0__tab[] = { 0xd49a7a000000000000000000 };
538 #elif GMP_NUMB_BITS == 128
539 const mp_limb_t mpfr_l2b_10_0__tab[] = { 0xd49a7a00000000000000000000000000 };
540 #elif GMP_NUMB_BITS == 256
541 const mp_limb_t mpfr_l2b_10_0__tab[] = { 0xd49a7a0000000000000000000000000000000000000000000000000000000000 };
542 #endif
543
544 #if 0
545 #elif GMP_NUMB_BITS == 8
546 const mp_limb_t mpfr_l2b_10_1__tab[] = { 0x90, 0x8f, 0x98, 0xf7, 0xcf, 0xfb, 0x84, 0x9a, 0x20, 0x9a };
547 #elif GMP_NUMB_BITS == 16
548 const mp_limb_t mpfr_l2b_10_1__tab[] = { 0x8f90, 0xf798, 0xfbcf, 0x9a84, 0x9a20 };
549 #elif GMP_NUMB_BITS == 32
550 const mp_limb_t mpfr_l2b_10_1__tab[] = { 0x8f900000, 0xfbcff798, 0x9a209a84 };
551 #elif GMP_NUMB_BITS == 64
552 const mp_limb_t mpfr_l2b_10_1__tab[] = { UINT64_C(0x8f90000000000000), UINT64_C(0x9a209a84fbcff798) };
553 #elif GMP_NUMB_BITS == 96
554 const mp_limb_t mpfr_l2b_10_1__tab[] = { 0x9a209a84fbcff7988f900000 };
555 #elif GMP_NUMB_BITS == 128
556 const mp_limb_t mpfr_l2b_10_1__tab[] = { 0x9a209a84fbcff7988f90000000000000 };
557 #elif GMP_NUMB_BITS == 256
558 const mp_limb_t mpfr_l2b_10_1__tab[] = { 0x9a209a84fbcff7988f9000000000000000000000000000000000000000000000 };
559 #endif
560
561 #if 0
562 #elif GMP_NUMB_BITS == 8
563 const mp_limb_t mpfr_l2b_11_0__tab[] = { 0x54, 0x67, 0xdd };
564 #elif GMP_NUMB_BITS == 16
565 const mp_limb_t mpfr_l2b_11_0__tab[] = { 0x5400, 0xdd67 };
566 #elif GMP_NUMB_BITS == 32
567 const mp_limb_t mpfr_l2b_11_0__tab[] = { 0xdd675400 };
568 #elif GMP_NUMB_BITS == 64
569 const mp_limb_t mpfr_l2b_11_0__tab[] = { UINT64_C(0xdd67540000000000) };
570 #elif GMP_NUMB_BITS == 96
571 const mp_limb_t mpfr_l2b_11_0__tab[] = { 0xdd6754000000000000000000 };
572 #elif GMP_NUMB_BITS == 128
573 const mp_limb_t mpfr_l2b_11_0__tab[] = { 0xdd675400000000000000000000000000 };
574 #elif GMP_NUMB_BITS == 256
575 const mp_limb_t mpfr_l2b_11_0__tab[] = { 0xdd67540000000000000000000000000000000000000000000000000000000000 };
576 #endif
577
578 #if 0
579 #elif GMP_NUMB_BITS == 8
580 const mp_limb_t mpfr_l2b_11_1__tab[] = { 0x70, 0xe1, 0x10, 0x9d, 0x22, 0xeb, 0x0e, 0x4e, 0x00, 0x94 };
581 #elif GMP_NUMB_BITS == 16
582 const mp_limb_t mpfr_l2b_11_1__tab[] = { 0xe170, 0x9d10, 0xeb22, 0x4e0e, 0x9400 };
583 #elif GMP_NUMB_BITS == 32
584 const mp_limb_t mpfr_l2b_11_1__tab[] = { 0xe1700000, 0xeb229d10, 0x94004e0e };
585 #elif GMP_NUMB_BITS == 64
586 const mp_limb_t mpfr_l2b_11_1__tab[] = { UINT64_C(0xe170000000000000), UINT64_C(0x94004e0eeb229d10) };
587 #elif GMP_NUMB_BITS == 96
588 const mp_limb_t mpfr_l2b_11_1__tab[] = { 0x94004e0eeb229d10e1700000 };
589 #elif GMP_NUMB_BITS == 128
590 const mp_limb_t mpfr_l2b_11_1__tab[] = { 0x94004e0eeb229d10e170000000000000 };
591 #elif GMP_NUMB_BITS == 256
592 const mp_limb_t mpfr_l2b_11_1__tab[] = { 0x94004e0eeb229d10e17000000000000000000000000000000000000000000000 };
593 #endif
594
595 #if 0
596 #elif GMP_NUMB_BITS == 8
597 const mp_limb_t mpfr_l2b_12_0__tab[] = { 0x08, 0x70, 0xe5 };
598 #elif GMP_NUMB_BITS == 16
599 const mp_limb_t mpfr_l2b_12_0__tab[] = { 0x0800, 0xe570 };
600 #elif GMP_NUMB_BITS == 32
601 const mp_limb_t mpfr_l2b_12_0__tab[] = { 0xe5700800 };
602 #elif GMP_NUMB_BITS == 64
603 const mp_limb_t mpfr_l2b_12_0__tab[] = { UINT64_C(0xe570080000000000) };
604 #elif GMP_NUMB_BITS == 96
605 const mp_limb_t mpfr_l2b_12_0__tab[] = { 0xe57008000000000000000000 };
606 #elif GMP_NUMB_BITS == 128
607 const mp_limb_t mpfr_l2b_12_0__tab[] = { 0xe5700800000000000000000000000000 };
608 #elif GMP_NUMB_BITS == 256
609 const mp_limb_t mpfr_l2b_12_0__tab[] = { 0xe570080000000000000000000000000000000000000000000000000000000000 };
610 #endif
611
612 #if 0
613 #elif GMP_NUMB_BITS == 8
614 const mp_limb_t mpfr_l2b_12_1__tab[] = { 0x28, 0xfe, 0x24, 0x1c, 0x03, 0x0b, 0x1a, 0x9c, 0xd1, 0x8e };
615 #elif GMP_NUMB_BITS == 16
616 const mp_limb_t mpfr_l2b_12_1__tab[] = { 0xfe28, 0x1c24, 0x0b03, 0x9c1a, 0x8ed1 };
617 #elif GMP_NUMB_BITS == 32
618 const mp_limb_t mpfr_l2b_12_1__tab[] = { 0xfe280000, 0x0b031c24, 0x8ed19c1a };
619 #elif GMP_NUMB_BITS == 64
620 const mp_limb_t mpfr_l2b_12_1__tab[] = { UINT64_C(0xfe28000000000000), UINT64_C(0x8ed19c1a0b031c24) };
621 #elif GMP_NUMB_BITS == 96
622 const mp_limb_t mpfr_l2b_12_1__tab[] = { 0x8ed19c1a0b031c24fe280000 };
623 #elif GMP_NUMB_BITS == 128
624 const mp_limb_t mpfr_l2b_12_1__tab[] = { 0x8ed19c1a0b031c24fe28000000000000 };
625 #elif GMP_NUMB_BITS == 256
626 const mp_limb_t mpfr_l2b_12_1__tab[] = { 0x8ed19c1a0b031c24fe2800000000000000000000000000000000000000000000 };
627 #endif
628
629 #if 0
630 #elif GMP_NUMB_BITS == 8
631 const mp_limb_t mpfr_l2b_13_0__tab[] = { 0x02, 0xd4, 0xec };
632 #elif GMP_NUMB_BITS == 16
633 const mp_limb_t mpfr_l2b_13_0__tab[] = { 0x0200, 0xecd4 };
634 #elif GMP_NUMB_BITS == 32
635 const mp_limb_t mpfr_l2b_13_0__tab[] = { 0xecd40200 };
636 #elif GMP_NUMB_BITS == 64
637 const mp_limb_t mpfr_l2b_13_0__tab[] = { UINT64_C(0xecd4020000000000) };
638 #elif GMP_NUMB_BITS == 96
639 const mp_limb_t mpfr_l2b_13_0__tab[] = { 0xecd402000000000000000000 };
640 #elif GMP_NUMB_BITS == 128
641 const mp_limb_t mpfr_l2b_13_0__tab[] = { 0xecd40200000000000000000000000000 };
642 #elif GMP_NUMB_BITS == 256
643 const mp_limb_t mpfr_l2b_13_0__tab[] = { 0xecd4020000000000000000000000000000000000000000000000000000000000 };
644 #endif
645
646 #if 0
647 #elif GMP_NUMB_BITS == 8
648 const mp_limb_t mpfr_l2b_13_1__tab[] = { 0xf8, 0x57, 0xb4, 0xf7, 0x20, 0xcb, 0xc6, 0xa7, 0x5c, 0x8a };
649 #elif GMP_NUMB_BITS == 16
650 const mp_limb_t mpfr_l2b_13_1__tab[] = { 0x57f8, 0xf7b4, 0xcb20, 0xa7c6, 0x8a5c };
651 #elif GMP_NUMB_BITS == 32
652 const mp_limb_t mpfr_l2b_13_1__tab[] = { 0x57f80000, 0xcb20f7b4, 0x8a5ca7c6 };
653 #elif GMP_NUMB_BITS == 64
654 const mp_limb_t mpfr_l2b_13_1__tab[] = { UINT64_C(0x57f8000000000000), UINT64_C(0x8a5ca7c6cb20f7b4) };
655 #elif GMP_NUMB_BITS == 96
656 const mp_limb_t mpfr_l2b_13_1__tab[] = { 0x8a5ca7c6cb20f7b457f80000 };
657 #elif GMP_NUMB_BITS == 128
658 const mp_limb_t mpfr_l2b_13_1__tab[] = { 0x8a5ca7c6cb20f7b457f8000000000000 };
659 #elif GMP_NUMB_BITS == 256
660 const mp_limb_t mpfr_l2b_13_1__tab[] = { 0x8a5ca7c6cb20f7b457f800000000000000000000000000000000000000000000 };
661 #endif
662
663 #if 0
664 #elif GMP_NUMB_BITS == 8
665 const mp_limb_t mpfr_l2b_14_0__tab[] = { 0xb4, 0xab, 0xf3 };
666 #elif GMP_NUMB_BITS == 16
667 const mp_limb_t mpfr_l2b_14_0__tab[] = { 0xb400, 0xf3ab };
668 #elif GMP_NUMB_BITS == 32
669 const mp_limb_t mpfr_l2b_14_0__tab[] = { 0xf3abb400 };
670 #elif GMP_NUMB_BITS == 64
671 const mp_limb_t mpfr_l2b_14_0__tab[] = { UINT64_C(0xf3abb40000000000) };
672 #elif GMP_NUMB_BITS == 96
673 const mp_limb_t mpfr_l2b_14_0__tab[] = { 0xf3abb4000000000000000000 };
674 #elif GMP_NUMB_BITS == 128
675 const mp_limb_t mpfr_l2b_14_0__tab[] = { 0xf3abb400000000000000000000000000 };
676 #elif GMP_NUMB_BITS == 256
677 const mp_limb_t mpfr_l2b_14_0__tab[] = { 0xf3abb40000000000000000000000000000000000000000000000000000000000 };
678 #endif
679
680 #if 0
681 #elif GMP_NUMB_BITS == 8
682 const mp_limb_t mpfr_l2b_14_1__tab[] = { 0xa8, 0x85, 0xab, 0x5c, 0xb5, 0x96, 0xf6, 0xff, 0x79, 0x86 };
683 #elif GMP_NUMB_BITS == 16
684 const mp_limb_t mpfr_l2b_14_1__tab[] = { 0x85a8, 0x5cab, 0x96b5, 0xfff6, 0x8679 };
685 #elif GMP_NUMB_BITS == 32
686 const mp_limb_t mpfr_l2b_14_1__tab[] = { 0x85a80000, 0x96b55cab, 0x8679fff6 };
687 #elif GMP_NUMB_BITS == 64
688 const mp_limb_t mpfr_l2b_14_1__tab[] = { UINT64_C(0x85a8000000000000), UINT64_C(0x8679fff696b55cab) };
689 #elif GMP_NUMB_BITS == 96
690 const mp_limb_t mpfr_l2b_14_1__tab[] = { 0x8679fff696b55cab85a80000 };
691 #elif GMP_NUMB_BITS == 128
692 const mp_limb_t mpfr_l2b_14_1__tab[] = { 0x8679fff696b55cab85a8000000000000 };
693 #elif GMP_NUMB_BITS == 256
694 const mp_limb_t mpfr_l2b_14_1__tab[] = { 0x8679fff696b55cab85a800000000000000000000000000000000000000000000 };
695 #endif
696
697 #if 0
698 #elif GMP_NUMB_BITS == 8
699 const mp_limb_t mpfr_l2b_15_0__tab[] = { 0x80, 0x0a, 0xfa };
700 #elif GMP_NUMB_BITS == 16
701 const mp_limb_t mpfr_l2b_15_0__tab[] = { 0x8000, 0xfa0a };
702 #elif GMP_NUMB_BITS == 32
703 const mp_limb_t mpfr_l2b_15_0__tab[] = { 0xfa0a8000 };
704 #elif GMP_NUMB_BITS == 64
705 const mp_limb_t mpfr_l2b_15_0__tab[] = { UINT64_C(0xfa0a800000000000) };
706 #elif GMP_NUMB_BITS == 96
707 const mp_limb_t mpfr_l2b_15_0__tab[] = { 0xfa0a80000000000000000000 };
708 #elif GMP_NUMB_BITS == 128
709 const mp_limb_t mpfr_l2b_15_0__tab[] = { 0xfa0a8000000000000000000000000000 };
710 #elif GMP_NUMB_BITS == 256
711 const mp_limb_t mpfr_l2b_15_0__tab[] = { 0xfa0a800000000000000000000000000000000000000000000000000000000000 };
712 #endif
713
714 #if 0
715 #elif GMP_NUMB_BITS == 8
716 const mp_limb_t mpfr_l2b_15_1__tab[] = { 0x80, 0x6f, 0xaa, 0xa6, 0xf0, 0x69, 0x23, 0xee, 0x0c, 0x83 };
717 #elif GMP_NUMB_BITS == 16
718 const mp_limb_t mpfr_l2b_15_1__tab[] = { 0x6f80, 0xa6aa, 0x69f0, 0xee23, 0x830c };
719 #elif GMP_NUMB_BITS == 32
720 const mp_limb_t mpfr_l2b_15_1__tab[] = { 0x6f800000, 0x69f0a6aa, 0x830cee23 };
721 #elif GMP_NUMB_BITS == 64
722 const mp_limb_t mpfr_l2b_15_1__tab[] = { UINT64_C(0x6f80000000000000), UINT64_C(0x830cee2369f0a6aa) };
723 #elif GMP_NUMB_BITS == 96
724 const mp_limb_t mpfr_l2b_15_1__tab[] = { 0x830cee2369f0a6aa6f800000 };
725 #elif GMP_NUMB_BITS == 128
726 const mp_limb_t mpfr_l2b_15_1__tab[] = { 0x830cee2369f0a6aa6f80000000000000 };
727 #elif GMP_NUMB_BITS == 256
728 const mp_limb_t mpfr_l2b_15_1__tab[] = { 0x830cee2369f0a6aa6f8000000000000000000000000000000000000000000000 };
729 #endif
730
731 #if 0
732 #elif GMP_NUMB_BITS == 8
733 const mp_limb_t mpfr_l2b_16_0__tab[] = { 0x00, 0x00, 0x80 };
734 #elif GMP_NUMB_BITS == 16
735 const mp_limb_t mpfr_l2b_16_0__tab[] = { 0x0000, 0x8000 };
736 #elif GMP_NUMB_BITS == 32
737 const mp_limb_t mpfr_l2b_16_0__tab[] = { 0x80000000 };
738 #elif GMP_NUMB_BITS == 64
739 const mp_limb_t mpfr_l2b_16_0__tab[] = { UINT64_C(0x8000000000000000) };
740 #elif GMP_NUMB_BITS == 96
741 const mp_limb_t mpfr_l2b_16_0__tab[] = { 0x800000000000000000000000 };
742 #elif GMP_NUMB_BITS == 128
743 const mp_limb_t mpfr_l2b_16_0__tab[] = { 0x80000000000000000000000000000000 };
744 #elif GMP_NUMB_BITS == 256
745 const mp_limb_t mpfr_l2b_16_0__tab[] = { 0x8000000000000000000000000000000000000000000000000000000000000000 };
746 #endif
747
748 #if 0
749 #elif GMP_NUMB_BITS == 8
750 const mp_limb_t mpfr_l2b_16_1__tab[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 };
751 #elif GMP_NUMB_BITS == 16
752 const mp_limb_t mpfr_l2b_16_1__tab[] = { 0x0000, 0x0000, 0x0000, 0x0000, 0x8000 };
753 #elif GMP_NUMB_BITS == 32
754 const mp_limb_t mpfr_l2b_16_1__tab[] = { 0x00000000, 0x00000000, 0x80000000 };
755 #elif GMP_NUMB_BITS == 64
756 const mp_limb_t mpfr_l2b_16_1__tab[] = { UINT64_C(0x0000000000000000), UINT64_C(0x8000000000000000) };
757 #elif GMP_NUMB_BITS == 96
758 const mp_limb_t mpfr_l2b_16_1__tab[] = { 0x800000000000000000000000 };
759 #elif GMP_NUMB_BITS == 128
760 const mp_limb_t mpfr_l2b_16_1__tab[] = { 0x80000000000000000000000000000000 };
761 #elif GMP_NUMB_BITS == 256
762 const mp_limb_t mpfr_l2b_16_1__tab[] = { 0x8000000000000000000000000000000000000000000000000000000000000000 };
763 #endif
764
765 #if 0
766 #elif GMP_NUMB_BITS == 8
767 const mp_limb_t mpfr_l2b_17_0__tab[] = { 0x80, 0xcc, 0x82 };
768 #elif GMP_NUMB_BITS == 16
769 const mp_limb_t mpfr_l2b_17_0__tab[] = { 0x8000, 0x82cc };
770 #elif GMP_NUMB_BITS == 32
771 const mp_limb_t mpfr_l2b_17_0__tab[] = { 0x82cc8000 };
772 #elif GMP_NUMB_BITS == 64
773 const mp_limb_t mpfr_l2b_17_0__tab[] = { UINT64_C(0x82cc800000000000) };
774 #elif GMP_NUMB_BITS == 96
775 const mp_limb_t mpfr_l2b_17_0__tab[] = { 0x82cc80000000000000000000 };
776 #elif GMP_NUMB_BITS == 128
777 const mp_limb_t mpfr_l2b_17_0__tab[] = { 0x82cc8000000000000000000000000000 };
778 #elif GMP_NUMB_BITS == 256
779 const mp_limb_t mpfr_l2b_17_0__tab[] = { 0x82cc800000000000000000000000000000000000000000000000000000000000 };
780 #endif
781
782 #if 0
783 #elif GMP_NUMB_BITS == 8
784 const mp_limb_t mpfr_l2b_17_1__tab[] = { 0x20, 0x87, 0x9b, 0x25, 0xc4, 0x62, 0xf5, 0xab, 0x85, 0xfa };
785 #elif GMP_NUMB_BITS == 16
786 const mp_limb_t mpfr_l2b_17_1__tab[] = { 0x8720, 0x259b, 0x62c4, 0xabf5, 0xfa85 };
787 #elif GMP_NUMB_BITS == 32
788 const mp_limb_t mpfr_l2b_17_1__tab[] = { 0x87200000, 0x62c4259b, 0xfa85abf5 };
789 #elif GMP_NUMB_BITS == 64
790 const mp_limb_t mpfr_l2b_17_1__tab[] = { UINT64_C(0x8720000000000000), UINT64_C(0xfa85abf562c4259b) };
791 #elif GMP_NUMB_BITS == 96
792 const mp_limb_t mpfr_l2b_17_1__tab[] = { 0xfa85abf562c4259b87200000 };
793 #elif GMP_NUMB_BITS == 128
794 const mp_limb_t mpfr_l2b_17_1__tab[] = { 0xfa85abf562c4259b8720000000000000 };
795 #elif GMP_NUMB_BITS == 256
796 const mp_limb_t mpfr_l2b_17_1__tab[] = { 0xfa85abf562c4259b872000000000000000000000000000000000000000000000 };
797 #endif
798
799 #if 0
800 #elif GMP_NUMB_BITS == 8
801 const mp_limb_t mpfr_l2b_18_0__tab[] = { 0x08, 0x70, 0x85 };
802 #elif GMP_NUMB_BITS == 16
803 const mp_limb_t mpfr_l2b_18_0__tab[] = { 0x0800, 0x8570 };
804 #elif GMP_NUMB_BITS == 32
805 const mp_limb_t mpfr_l2b_18_0__tab[] = { 0x85700800 };
806 #elif GMP_NUMB_BITS == 64
807 const mp_limb_t mpfr_l2b_18_0__tab[] = { UINT64_C(0x8570080000000000) };
808 #elif GMP_NUMB_BITS == 96
809 const mp_limb_t mpfr_l2b_18_0__tab[] = { 0x857008000000000000000000 };
810 #elif GMP_NUMB_BITS == 128
811 const mp_limb_t mpfr_l2b_18_0__tab[] = { 0x85700800000000000000000000000000 };
812 #elif GMP_NUMB_BITS == 256
813 const mp_limb_t mpfr_l2b_18_0__tab[] = { 0x8570080000000000000000000000000000000000000000000000000000000000 };
814 #endif
815
816 #if 0
817 #elif GMP_NUMB_BITS == 8
818 const mp_limb_t mpfr_l2b_18_1__tab[] = { 0x98, 0x36, 0x78, 0x13, 0x37, 0x55, 0x34, 0x66, 0x91, 0xf5 };
819 #elif GMP_NUMB_BITS == 16
820 const mp_limb_t mpfr_l2b_18_1__tab[] = { 0x3698, 0x1378, 0x5537, 0x6634, 0xf591 };
821 #elif GMP_NUMB_BITS == 32
822 const mp_limb_t mpfr_l2b_18_1__tab[] = { 0x36980000, 0x55371378, 0xf5916634 };
823 #elif GMP_NUMB_BITS == 64
824 const mp_limb_t mpfr_l2b_18_1__tab[] = { UINT64_C(0x3698000000000000), UINT64_C(0xf591663455371378) };
825 #elif GMP_NUMB_BITS == 96
826 const mp_limb_t mpfr_l2b_18_1__tab[] = { 0xf59166345537137836980000 };
827 #elif GMP_NUMB_BITS == 128
828 const mp_limb_t mpfr_l2b_18_1__tab[] = { 0xf5916634553713783698000000000000 };
829 #elif GMP_NUMB_BITS == 256
830 const mp_limb_t mpfr_l2b_18_1__tab[] = { 0xf591663455371378369800000000000000000000000000000000000000000000 };
831 #endif
832
833 #if 0
834 #elif GMP_NUMB_BITS == 8
835 const mp_limb_t mpfr_l2b_19_0__tab[] = { 0x06, 0xef, 0x87 };
836 #elif GMP_NUMB_BITS == 16
837 const mp_limb_t mpfr_l2b_19_0__tab[] = { 0x0600, 0x87ef };
838 #elif GMP_NUMB_BITS == 32
839 const mp_limb_t mpfr_l2b_19_0__tab[] = { 0x87ef0600 };
840 #elif GMP_NUMB_BITS == 64
841 const mp_limb_t mpfr_l2b_19_0__tab[] = { UINT64_C(0x87ef060000000000) };
842 #elif GMP_NUMB_BITS == 96
843 const mp_limb_t mpfr_l2b_19_0__tab[] = { 0x87ef06000000000000000000 };
844 #elif GMP_NUMB_BITS == 128
845 const mp_limb_t mpfr_l2b_19_0__tab[] = { 0x87ef0600000000000000000000000000 };
846 #elif GMP_NUMB_BITS == 256
847 const mp_limb_t mpfr_l2b_19_0__tab[] = { 0x87ef060000000000000000000000000000000000000000000000000000000000 };
848 #endif
849
850 #if 0
851 #elif GMP_NUMB_BITS == 8
852 const mp_limb_t mpfr_l2b_19_1__tab[] = { 0xb8, 0x0d, 0x8c, 0x55, 0xed, 0x62, 0xc0, 0x08, 0x0f, 0xf1 };
853 #elif GMP_NUMB_BITS == 16
854 const mp_limb_t mpfr_l2b_19_1__tab[] = { 0x0db8, 0x558c, 0x62ed, 0x08c0, 0xf10f };
855 #elif GMP_NUMB_BITS == 32
856 const mp_limb_t mpfr_l2b_19_1__tab[] = { 0x0db80000, 0x62ed558c, 0xf10f08c0 };
857 #elif GMP_NUMB_BITS == 64
858 const mp_limb_t mpfr_l2b_19_1__tab[] = { UINT64_C(0x0db8000000000000), UINT64_C(0xf10f08c062ed558c) };
859 #elif GMP_NUMB_BITS == 96
860 const mp_limb_t mpfr_l2b_19_1__tab[] = { 0xf10f08c062ed558c0db80000 };
861 #elif GMP_NUMB_BITS == 128
862 const mp_limb_t mpfr_l2b_19_1__tab[] = { 0xf10f08c062ed558c0db8000000000000 };
863 #elif GMP_NUMB_BITS == 256
864 const mp_limb_t mpfr_l2b_19_1__tab[] = { 0xf10f08c062ed558c0db800000000000000000000000000000000000000000000 };
865 #endif
866
867 #if 0
868 #elif GMP_NUMB_BITS == 8
869 const mp_limb_t mpfr_l2b_20_0__tab[] = { 0x3e, 0x4d, 0x8a };
870 #elif GMP_NUMB_BITS == 16
871 const mp_limb_t mpfr_l2b_20_0__tab[] = { 0x3e00, 0x8a4d };
872 #elif GMP_NUMB_BITS == 32
873 const mp_limb_t mpfr_l2b_20_0__tab[] = { 0x8a4d3e00 };
874 #elif GMP_NUMB_BITS == 64
875 const mp_limb_t mpfr_l2b_20_0__tab[] = { UINT64_C(0x8a4d3e0000000000) };
876 #elif GMP_NUMB_BITS == 96
877 const mp_limb_t mpfr_l2b_20_0__tab[] = { 0x8a4d3e000000000000000000 };
878 #elif GMP_NUMB_BITS == 128
879 const mp_limb_t mpfr_l2b_20_0__tab[] = { 0x8a4d3e00000000000000000000000000 };
880 #elif GMP_NUMB_BITS == 256
881 const mp_limb_t mpfr_l2b_20_0__tab[] = { 0x8a4d3e0000000000000000000000000000000000000000000000000000000000 };
882 #endif
883
884 #if 0
885 #elif GMP_NUMB_BITS == 8
886 const mp_limb_t mpfr_l2b_20_1__tab[] = { 0x40, 0x0b, 0x1c, 0xa7, 0xc1, 0x1c, 0x0a, 0x69, 0xee, 0xec };
887 #elif GMP_NUMB_BITS == 16
888 const mp_limb_t mpfr_l2b_20_1__tab[] = { 0x0b40, 0xa71c, 0x1cc1, 0x690a, 0xecee };
889 #elif GMP_NUMB_BITS == 32
890 const mp_limb_t mpfr_l2b_20_1__tab[] = { 0x0b400000, 0x1cc1a71c, 0xecee690a };
891 #elif GMP_NUMB_BITS == 64
892 const mp_limb_t mpfr_l2b_20_1__tab[] = { UINT64_C(0x0b40000000000000), UINT64_C(0xecee690a1cc1a71c) };
893 #elif GMP_NUMB_BITS == 96
894 const mp_limb_t mpfr_l2b_20_1__tab[] = { 0xecee690a1cc1a71c0b400000 };
895 #elif GMP_NUMB_BITS == 128
896 const mp_limb_t mpfr_l2b_20_1__tab[] = { 0xecee690a1cc1a71c0b40000000000000 };
897 #elif GMP_NUMB_BITS == 256
898 const mp_limb_t mpfr_l2b_20_1__tab[] = { 0xecee690a1cc1a71c0b4000000000000000000000000000000000000000000000 };
899 #endif
900
901 #if 0
902 #elif GMP_NUMB_BITS == 8
903 const mp_limb_t mpfr_l2b_21_0__tab[] = { 0xde, 0x8d, 0x8c };
904 #elif GMP_NUMB_BITS == 16
905 const mp_limb_t mpfr_l2b_21_0__tab[] = { 0xde00, 0x8c8d };
906 #elif GMP_NUMB_BITS == 32
907 const mp_limb_t mpfr_l2b_21_0__tab[] = { 0x8c8dde00 };
908 #elif GMP_NUMB_BITS == 64
909 const mp_limb_t mpfr_l2b_21_0__tab[] = { UINT64_C(0x8c8dde0000000000) };
910 #elif GMP_NUMB_BITS == 96
911 const mp_limb_t mpfr_l2b_21_0__tab[] = { 0x8c8dde000000000000000000 };
912 #elif GMP_NUMB_BITS == 128
913 const mp_limb_t mpfr_l2b_21_0__tab[] = { 0x8c8dde00000000000000000000000000 };
914 #elif GMP_NUMB_BITS == 256
915 const mp_limb_t mpfr_l2b_21_0__tab[] = { 0x8c8dde0000000000000000000000000000000000000000000000000000000000 };
916 #endif
917
918 #if 0
919 #elif GMP_NUMB_BITS == 8
920 const mp_limb_t mpfr_l2b_21_1__tab[] = { 0x08, 0x41, 0x26, 0x6b, 0xd0, 0xb3, 0xc1, 0x63, 0x22, 0xe9 };
921 #elif GMP_NUMB_BITS == 16
922 const mp_limb_t mpfr_l2b_21_1__tab[] = { 0x4108, 0x6b26, 0xb3d0, 0x63c1, 0xe922 };
923 #elif GMP_NUMB_BITS == 32
924 const mp_limb_t mpfr_l2b_21_1__tab[] = { 0x41080000, 0xb3d06b26, 0xe92263c1 };
925 #elif GMP_NUMB_BITS == 64
926 const mp_limb_t mpfr_l2b_21_1__tab[] = { UINT64_C(0x4108000000000000), UINT64_C(0xe92263c1b3d06b26) };
927 #elif GMP_NUMB_BITS == 96
928 const mp_limb_t mpfr_l2b_21_1__tab[] = { 0xe92263c1b3d06b2641080000 };
929 #elif GMP_NUMB_BITS == 128
930 const mp_limb_t mpfr_l2b_21_1__tab[] = { 0xe92263c1b3d06b264108000000000000 };
931 #elif GMP_NUMB_BITS == 256
932 const mp_limb_t mpfr_l2b_21_1__tab[] = { 0xe92263c1b3d06b26410800000000000000000000000000000000000000000000 };
933 #endif
934
935 #if 0
936 #elif GMP_NUMB_BITS == 8
937 const mp_limb_t mpfr_l2b_22_0__tab[] = { 0xaa, 0xb3, 0x8e };
938 #elif GMP_NUMB_BITS == 16
939 const mp_limb_t mpfr_l2b_22_0__tab[] = { 0xaa00, 0x8eb3 };
940 #elif GMP_NUMB_BITS == 32
941 const mp_limb_t mpfr_l2b_22_0__tab[] = { 0x8eb3aa00 };
942 #elif GMP_NUMB_BITS == 64
943 const mp_limb_t mpfr_l2b_22_0__tab[] = { UINT64_C(0x8eb3aa0000000000) };
944 #elif GMP_NUMB_BITS == 96
945 const mp_limb_t mpfr_l2b_22_0__tab[] = { 0x8eb3aa000000000000000000 };
946 #elif GMP_NUMB_BITS == 128
947 const mp_limb_t mpfr_l2b_22_0__tab[] = { 0x8eb3aa00000000000000000000000000 };
948 #elif GMP_NUMB_BITS == 256
949 const mp_limb_t mpfr_l2b_22_0__tab[] = { 0x8eb3aa0000000000000000000000000000000000000000000000000000000000 };
950 #endif
951
952 #if 0
953 #elif GMP_NUMB_BITS == 8
954 const mp_limb_t mpfr_l2b_22_1__tab[] = { 0xe8, 0xdb, 0x61, 0xf0, 0xb9, 0x60, 0x4d, 0x2c, 0xa0, 0xe5 };
955 #elif GMP_NUMB_BITS == 16
956 const mp_limb_t mpfr_l2b_22_1__tab[] = { 0xdbe8, 0xf061, 0x60b9, 0x2c4d, 0xe5a0 };
957 #elif GMP_NUMB_BITS == 32
958 const mp_limb_t mpfr_l2b_22_1__tab[] = { 0xdbe80000, 0x60b9f061, 0xe5a02c4d };
959 #elif GMP_NUMB_BITS == 64
960 const mp_limb_t mpfr_l2b_22_1__tab[] = { UINT64_C(0xdbe8000000000000), UINT64_C(0xe5a02c4d60b9f061) };
961 #elif GMP_NUMB_BITS == 96
962 const mp_limb_t mpfr_l2b_22_1__tab[] = { 0xe5a02c4d60b9f061dbe80000 };
963 #elif GMP_NUMB_BITS == 128
964 const mp_limb_t mpfr_l2b_22_1__tab[] = { 0xe5a02c4d60b9f061dbe8000000000000 };
965 #elif GMP_NUMB_BITS == 256
966 const mp_limb_t mpfr_l2b_22_1__tab[] = { 0xe5a02c4d60b9f061dbe800000000000000000000000000000000000000000000 };
967 #endif
968
969 #if 0
970 #elif GMP_NUMB_BITS == 8
971 const mp_limb_t mpfr_l2b_23_0__tab[] = { 0x06, 0xc1, 0x90 };
972 #elif GMP_NUMB_BITS == 16
973 const mp_limb_t mpfr_l2b_23_0__tab[] = { 0x0600, 0x90c1 };
974 #elif GMP_NUMB_BITS == 32
975 const mp_limb_t mpfr_l2b_23_0__tab[] = { 0x90c10600 };
976 #elif GMP_NUMB_BITS == 64
977 const mp_limb_t mpfr_l2b_23_0__tab[] = { UINT64_C(0x90c1060000000000) };
978 #elif GMP_NUMB_BITS == 96
979 const mp_limb_t mpfr_l2b_23_0__tab[] = { 0x90c106000000000000000000 };
980 #elif GMP_NUMB_BITS == 128
981 const mp_limb_t mpfr_l2b_23_0__tab[] = { 0x90c10600000000000000000000000000 };
982 #elif GMP_NUMB_BITS == 256
983 const mp_limb_t mpfr_l2b_23_0__tab[] = { 0x90c1060000000000000000000000000000000000000000000000000000000000 };
984 #endif
985
986 #if 0
987 #elif GMP_NUMB_BITS == 8
988 const mp_limb_t mpfr_l2b_23_1__tab[] = { 0xe0, 0xc3, 0x6a, 0x58, 0xb9, 0x46, 0xdd, 0xca, 0x5e, 0xe2 };
989 #elif GMP_NUMB_BITS == 16
990 const mp_limb_t mpfr_l2b_23_1__tab[] = { 0xc3e0, 0x586a, 0x46b9, 0xcadd, 0xe25e };
991 #elif GMP_NUMB_BITS == 32
992 const mp_limb_t mpfr_l2b_23_1__tab[] = { 0xc3e00000, 0x46b9586a, 0xe25ecadd };
993 #elif GMP_NUMB_BITS == 64
994 const mp_limb_t mpfr_l2b_23_1__tab[] = { UINT64_C(0xc3e0000000000000), UINT64_C(0xe25ecadd46b9586a) };
995 #elif GMP_NUMB_BITS == 96
996 const mp_limb_t mpfr_l2b_23_1__tab[] = { 0xe25ecadd46b9586ac3e00000 };
997 #elif GMP_NUMB_BITS == 128
998 const mp_limb_t mpfr_l2b_23_1__tab[] = { 0xe25ecadd46b9586ac3e0000000000000 };
999 #elif GMP_NUMB_BITS == 256
1000 const mp_limb_t mpfr_l2b_23_1__tab[] = { 0xe25ecadd46b9586ac3e000000000000000000000000000000000000000000000 };
1001 #endif
1002
1003 #if 0
1004 #elif GMP_NUMB_BITS == 8
1005 const mp_limb_t mpfr_l2b_24_0__tab[] = { 0x04, 0xb8, 0x92 };
1006 #elif GMP_NUMB_BITS == 16
1007 const mp_limb_t mpfr_l2b_24_0__tab[] = { 0x0400, 0x92b8 };
1008 #elif GMP_NUMB_BITS == 32
1009 const mp_limb_t mpfr_l2b_24_0__tab[] = { 0x92b80400 };
1010 #elif GMP_NUMB_BITS == 64
1011 const mp_limb_t mpfr_l2b_24_0__tab[] = { UINT64_C(0x92b8040000000000) };
1012 #elif GMP_NUMB_BITS == 96
1013 const mp_limb_t mpfr_l2b_24_0__tab[] = { 0x92b804000000000000000000 };
1014 #elif GMP_NUMB_BITS == 128
1015 const mp_limb_t mpfr_l2b_24_0__tab[] = { 0x92b80400000000000000000000000000 };
1016 #elif GMP_NUMB_BITS == 256
1017 const mp_limb_t mpfr_l2b_24_0__tab[] = { 0x92b8040000000000000000000000000000000000000000000000000000000000 };
1018 #endif
1019
1020 #if 0
1021 #elif GMP_NUMB_BITS == 8
1022 const mp_limb_t mpfr_l2b_24_1__tab[] = { 0x68, 0x36, 0x63, 0x72, 0xc6, 0xc7, 0x44, 0xbb, 0x56, 0xdf };
1023 #elif GMP_NUMB_BITS == 16
1024 const mp_limb_t mpfr_l2b_24_1__tab[] = { 0x3668, 0x7263, 0xc7c6, 0xbb44, 0xdf56 };
1025 #elif GMP_NUMB_BITS == 32
1026 const mp_limb_t mpfr_l2b_24_1__tab[] = { 0x36680000, 0xc7c67263, 0xdf56bb44 };
1027 #elif GMP_NUMB_BITS == 64
1028 const mp_limb_t mpfr_l2b_24_1__tab[] = { UINT64_C(0x3668000000000000), UINT64_C(0xdf56bb44c7c67263) };
1029 #elif GMP_NUMB_BITS == 96
1030 const mp_limb_t mpfr_l2b_24_1__tab[] = { 0xdf56bb44c7c6726336680000 };
1031 #elif GMP_NUMB_BITS == 128
1032 const mp_limb_t mpfr_l2b_24_1__tab[] = { 0xdf56bb44c7c672633668000000000000 };
1033 #elif GMP_NUMB_BITS == 256
1034 const mp_limb_t mpfr_l2b_24_1__tab[] = { 0xdf56bb44c7c67263366800000000000000000000000000000000000000000000 };
1035 #endif
1036
1037 #if 0
1038 #elif GMP_NUMB_BITS == 8
1039 const mp_limb_t mpfr_l2b_25_0__tab[] = { 0x7a, 0x9a, 0x94 };
1040 #elif GMP_NUMB_BITS == 16
1041 const mp_limb_t mpfr_l2b_25_0__tab[] = { 0x7a00, 0x949a };
1042 #elif GMP_NUMB_BITS == 32
1043 const mp_limb_t mpfr_l2b_25_0__tab[] = { 0x949a7a00 };
1044 #elif GMP_NUMB_BITS == 64
1045 const mp_limb_t mpfr_l2b_25_0__tab[] = { UINT64_C(0x949a7a0000000000) };
1046 #elif GMP_NUMB_BITS == 96
1047 const mp_limb_t mpfr_l2b_25_0__tab[] = { 0x949a7a000000000000000000 };
1048 #elif GMP_NUMB_BITS == 128
1049 const mp_limb_t mpfr_l2b_25_0__tab[] = { 0x949a7a00000000000000000000000000 };
1050 #elif GMP_NUMB_BITS == 256
1051 const mp_limb_t mpfr_l2b_25_0__tab[] = { 0x949a7a0000000000000000000000000000000000000000000000000000000000 };
1052 #endif
1053
1054 #if 0
1055 #elif GMP_NUMB_BITS == 8
1056 const mp_limb_t mpfr_l2b_25_1__tab[] = { 0xb8, 0x67, 0x28, 0x97, 0x7b, 0x28, 0x48, 0xa3, 0x81, 0xdc };
1057 #elif GMP_NUMB_BITS == 16
1058 const mp_limb_t mpfr_l2b_25_1__tab[] = { 0x67b8, 0x9728, 0x287b, 0xa348, 0xdc81 };
1059 #elif GMP_NUMB_BITS == 32
1060 const mp_limb_t mpfr_l2b_25_1__tab[] = { 0x67b80000, 0x287b9728, 0xdc81a348 };
1061 #elif GMP_NUMB_BITS == 64
1062 const mp_limb_t mpfr_l2b_25_1__tab[] = { UINT64_C(0x67b8000000000000), UINT64_C(0xdc81a348287b9728) };
1063 #elif GMP_NUMB_BITS == 96
1064 const mp_limb_t mpfr_l2b_25_1__tab[] = { 0xdc81a348287b972867b80000 };
1065 #elif GMP_NUMB_BITS == 128
1066 const mp_limb_t mpfr_l2b_25_1__tab[] = { 0xdc81a348287b972867b8000000000000 };
1067 #elif GMP_NUMB_BITS == 256
1068 const mp_limb_t mpfr_l2b_25_1__tab[] = { 0xdc81a348287b972867b800000000000000000000000000000000000000000000 };
1069 #endif
1070
1071 #if 0
1072 #elif GMP_NUMB_BITS == 8
1073 const mp_limb_t mpfr_l2b_26_0__tab[] = { 0x02, 0x6a, 0x96 };
1074 #elif GMP_NUMB_BITS == 16
1075 const mp_limb_t mpfr_l2b_26_0__tab[] = { 0x0200, 0x966a };
1076 #elif GMP_NUMB_BITS == 32
1077 const mp_limb_t mpfr_l2b_26_0__tab[] = { 0x966a0200 };
1078 #elif GMP_NUMB_BITS == 64
1079 const mp_limb_t mpfr_l2b_26_0__tab[] = { UINT64_C(0x966a020000000000) };
1080 #elif GMP_NUMB_BITS == 96
1081 const mp_limb_t mpfr_l2b_26_0__tab[] = { 0x966a02000000000000000000 };
1082 #elif GMP_NUMB_BITS == 128
1083 const mp_limb_t mpfr_l2b_26_0__tab[] = { 0x966a0200000000000000000000000000 };
1084 #elif GMP_NUMB_BITS == 256
1085 const mp_limb_t mpfr_l2b_26_0__tab[] = { 0x966a020000000000000000000000000000000000000000000000000000000000 };
1086 #endif
1087
1088 #if 0
1089 #elif GMP_NUMB_BITS == 8
1090 const mp_limb_t mpfr_l2b_26_1__tab[] = { 0x58, 0x64, 0xa4, 0x78, 0x83, 0x75, 0xf9, 0x19, 0xda, 0xd9 };
1091 #elif GMP_NUMB_BITS == 16
1092 const mp_limb_t mpfr_l2b_26_1__tab[] = { 0x6458, 0x78a4, 0x7583, 0x19f9, 0xd9da };
1093 #elif GMP_NUMB_BITS == 32
1094 const mp_limb_t mpfr_l2b_26_1__tab[] = { 0x64580000, 0x758378a4, 0xd9da19f9 };
1095 #elif GMP_NUMB_BITS == 64
1096 const mp_limb_t mpfr_l2b_26_1__tab[] = { UINT64_C(0x6458000000000000), UINT64_C(0xd9da19f9758378a4) };
1097 #elif GMP_NUMB_BITS == 96
1098 const mp_limb_t mpfr_l2b_26_1__tab[] = { 0xd9da19f9758378a464580000 };
1099 #elif GMP_NUMB_BITS == 128
1100 const mp_limb_t mpfr_l2b_26_1__tab[] = { 0xd9da19f9758378a46458000000000000 };
1101 #elif GMP_NUMB_BITS == 256
1102 const mp_limb_t mpfr_l2b_26_1__tab[] = { 0xd9da19f9758378a4645800000000000000000000000000000000000000000000 };
1103 #endif
1104
1105 #if 0
1106 #elif GMP_NUMB_BITS == 8
1107 const mp_limb_t mpfr_l2b_27_0__tab[] = { 0x0a, 0x28, 0x98 };
1108 #elif GMP_NUMB_BITS == 16
1109 const mp_limb_t mpfr_l2b_27_0__tab[] = { 0x0a00, 0x9828 };
1110 #elif GMP_NUMB_BITS == 32
1111 const mp_limb_t mpfr_l2b_27_0__tab[] = { 0x98280a00 };
1112 #elif GMP_NUMB_BITS == 64
1113 const mp_limb_t mpfr_l2b_27_0__tab[] = { UINT64_C(0x98280a0000000000) };
1114 #elif GMP_NUMB_BITS == 96
1115 const mp_limb_t mpfr_l2b_27_0__tab[] = { 0x98280a000000000000000000 };
1116 #elif GMP_NUMB_BITS == 128
1117 const mp_limb_t mpfr_l2b_27_0__tab[] = { 0x98280a00000000000000000000000000 };
1118 #elif GMP_NUMB_BITS == 256
1119 const mp_limb_t mpfr_l2b_27_0__tab[] = { 0x98280a0000000000000000000000000000000000000000000000000000000000 };
1120 #endif
1121
1122 #if 0
1123 #elif GMP_NUMB_BITS == 8
1124 const mp_limb_t mpfr_l2b_27_1__tab[] = { 0x08, 0x5b, 0xbd, 0xe1, 0x37, 0xe2, 0xac, 0x7b, 0x5b, 0xd7 };
1125 #elif GMP_NUMB_BITS == 16
1126 const mp_limb_t mpfr_l2b_27_1__tab[] = { 0x5b08, 0xe1bd, 0xe237, 0x7bac, 0xd75b };
1127 #elif GMP_NUMB_BITS == 32
1128 const mp_limb_t mpfr_l2b_27_1__tab[] = { 0x5b080000, 0xe237e1bd, 0xd75b7bac };
1129 #elif GMP_NUMB_BITS == 64
1130 const mp_limb_t mpfr_l2b_27_1__tab[] = { UINT64_C(0x5b08000000000000), UINT64_C(0xd75b7bace237e1bd) };
1131 #elif GMP_NUMB_BITS == 96
1132 const mp_limb_t mpfr_l2b_27_1__tab[] = { 0xd75b7bace237e1bd5b080000 };
1133 #elif GMP_NUMB_BITS == 128
1134 const mp_limb_t mpfr_l2b_27_1__tab[] = { 0xd75b7bace237e1bd5b08000000000000 };
1135 #elif GMP_NUMB_BITS == 256
1136 const mp_limb_t mpfr_l2b_27_1__tab[] = { 0xd75b7bace237e1bd5b0800000000000000000000000000000000000000000000 };
1137 #endif
1138
1139 #if 0
1140 #elif GMP_NUMB_BITS == 8
1141 const mp_limb_t mpfr_l2b_28_0__tab[] = { 0xda, 0xd5, 0x99 };
1142 #elif GMP_NUMB_BITS == 16
1143 const mp_limb_t mpfr_l2b_28_0__tab[] = { 0xda00, 0x99d5 };
1144 #elif GMP_NUMB_BITS == 32
1145 const mp_limb_t mpfr_l2b_28_0__tab[] = { 0x99d5da00 };
1146 #elif GMP_NUMB_BITS == 64
1147 const mp_limb_t mpfr_l2b_28_0__tab[] = { UINT64_C(0x99d5da0000000000) };
1148 #elif GMP_NUMB_BITS == 96
1149 const mp_limb_t mpfr_l2b_28_0__tab[] = { 0x99d5da000000000000000000 };
1150 #elif GMP_NUMB_BITS == 128
1151 const mp_limb_t mpfr_l2b_28_0__tab[] = { 0x99d5da00000000000000000000000000 };
1152 #elif GMP_NUMB_BITS == 256
1153 const mp_limb_t mpfr_l2b_28_0__tab[] = { 0x99d5da0000000000000000000000000000000000000000000000000000000000 };
1154 #endif
1155
1156 #if 0
1157 #elif GMP_NUMB_BITS == 8
1158 const mp_limb_t mpfr_l2b_28_1__tab[] = { 0xb8, 0xde, 0xb8, 0xe8, 0xdf, 0x71, 0x58, 0xc7, 0x01, 0xd5 };
1159 #elif GMP_NUMB_BITS == 16
1160 const mp_limb_t mpfr_l2b_28_1__tab[] = { 0xdeb8, 0xe8b8, 0x71df, 0xc758, 0xd501 };
1161 #elif GMP_NUMB_BITS == 32
1162 const mp_limb_t mpfr_l2b_28_1__tab[] = { 0xdeb80000, 0x71dfe8b8, 0xd501c758 };
1163 #elif GMP_NUMB_BITS == 64
1164 const mp_limb_t mpfr_l2b_28_1__tab[] = { UINT64_C(0xdeb8000000000000), UINT64_C(0xd501c75871dfe8b8) };
1165 #elif GMP_NUMB_BITS == 96
1166 const mp_limb_t mpfr_l2b_28_1__tab[] = { 0xd501c75871dfe8b8deb80000 };
1167 #elif GMP_NUMB_BITS == 128
1168 const mp_limb_t mpfr_l2b_28_1__tab[] = { 0xd501c75871dfe8b8deb8000000000000 };
1169 #elif GMP_NUMB_BITS == 256
1170 const mp_limb_t mpfr_l2b_28_1__tab[] = { 0xd501c75871dfe8b8deb800000000000000000000000000000000000000000000 };
1171 #endif
1172
1173 #if 0
1174 #elif GMP_NUMB_BITS == 8
1175 const mp_limb_t mpfr_l2b_29_0__tab[] = { 0x96, 0x74, 0x9b };
1176 #elif GMP_NUMB_BITS == 16
1177 const mp_limb_t mpfr_l2b_29_0__tab[] = { 0x9600, 0x9b74 };
1178 #elif GMP_NUMB_BITS == 32
1179 const mp_limb_t mpfr_l2b_29_0__tab[] = { 0x9b749600 };
1180 #elif GMP_NUMB_BITS == 64
1181 const mp_limb_t mpfr_l2b_29_0__tab[] = { UINT64_C(0x9b74960000000000) };
1182 #elif GMP_NUMB_BITS == 96
1183 const mp_limb_t mpfr_l2b_29_0__tab[] = { 0x9b7496000000000000000000 };
1184 #elif GMP_NUMB_BITS == 128
1185 const mp_limb_t mpfr_l2b_29_0__tab[] = { 0x9b749600000000000000000000000000 };
1186 #elif GMP_NUMB_BITS == 256
1187 const mp_limb_t mpfr_l2b_29_0__tab[] = { 0x9b74960000000000000000000000000000000000000000000000000000000000 };
1188 #endif
1189
1190 #if 0
1191 #elif GMP_NUMB_BITS == 8
1192 const mp_limb_t mpfr_l2b_29_1__tab[] = { 0xc8, 0xcc, 0xb3, 0x62, 0x6c, 0x9c, 0x15, 0x83, 0xc9, 0xd2 };
1193 #elif GMP_NUMB_BITS == 16
1194 const mp_limb_t mpfr_l2b_29_1__tab[] = { 0xccc8, 0x62b3, 0x9c6c, 0x8315, 0xd2c9 };
1195 #elif GMP_NUMB_BITS == 32
1196 const mp_limb_t mpfr_l2b_29_1__tab[] = { 0xccc80000, 0x9c6c62b3, 0xd2c98315 };
1197 #elif GMP_NUMB_BITS == 64
1198 const mp_limb_t mpfr_l2b_29_1__tab[] = { UINT64_C(0xccc8000000000000), UINT64_C(0xd2c983159c6c62b3) };
1199 #elif GMP_NUMB_BITS == 96
1200 const mp_limb_t mpfr_l2b_29_1__tab[] = { 0xd2c983159c6c62b3ccc80000 };
1201 #elif GMP_NUMB_BITS == 128
1202 const mp_limb_t mpfr_l2b_29_1__tab[] = { 0xd2c983159c6c62b3ccc8000000000000 };
1203 #elif GMP_NUMB_BITS == 256
1204 const mp_limb_t mpfr_l2b_29_1__tab[] = { 0xd2c983159c6c62b3ccc800000000000000000000000000000000000000000000 };
1205 #endif
1206
1207 #if 0
1208 #elif GMP_NUMB_BITS == 8
1209 const mp_limb_t mpfr_l2b_30_0__tab[] = { 0x40, 0x05, 0x9d };
1210 #elif GMP_NUMB_BITS == 16
1211 const mp_limb_t mpfr_l2b_30_0__tab[] = { 0x4000, 0x9d05 };
1212 #elif GMP_NUMB_BITS == 32
1213 const mp_limb_t mpfr_l2b_30_0__tab[] = { 0x9d054000 };
1214 #elif GMP_NUMB_BITS == 64
1215 const mp_limb_t mpfr_l2b_30_0__tab[] = { UINT64_C(0x9d05400000000000) };
1216 #elif GMP_NUMB_BITS == 96
1217 const mp_limb_t mpfr_l2b_30_0__tab[] = { 0x9d0540000000000000000000 };
1218 #elif GMP_NUMB_BITS == 128
1219 const mp_limb_t mpfr_l2b_30_0__tab[] = { 0x9d054000000000000000000000000000 };
1220 #elif GMP_NUMB_BITS == 256
1221 const mp_limb_t mpfr_l2b_30_0__tab[] = { 0x9d05400000000000000000000000000000000000000000000000000000000000 };
1222 #endif
1223
1224 #if 0
1225 #elif GMP_NUMB_BITS == 8
1226 const mp_limb_t mpfr_l2b_30_1__tab[] = { 0x88, 0x35, 0x32, 0x17, 0xad, 0x5c, 0x19, 0xa6, 0xaf, 0xd0 };
1227 #elif GMP_NUMB_BITS == 16
1228 const mp_limb_t mpfr_l2b_30_1__tab[] = { 0x3588, 0x1732, 0x5cad, 0xa619, 0xd0af };
1229 #elif GMP_NUMB_BITS == 32
1230 const mp_limb_t mpfr_l2b_30_1__tab[] = { 0x35880000, 0x5cad1732, 0xd0afa619 };
1231 #elif GMP_NUMB_BITS == 64
1232 const mp_limb_t mpfr_l2b_30_1__tab[] = { UINT64_C(0x3588000000000000), UINT64_C(0xd0afa6195cad1732) };
1233 #elif GMP_NUMB_BITS == 96
1234 const mp_limb_t mpfr_l2b_30_1__tab[] = { 0xd0afa6195cad173235880000 };
1235 #elif GMP_NUMB_BITS == 128
1236 const mp_limb_t mpfr_l2b_30_1__tab[] = { 0xd0afa6195cad17323588000000000000 };
1237 #elif GMP_NUMB_BITS == 256
1238 const mp_limb_t mpfr_l2b_30_1__tab[] = { 0xd0afa6195cad1732358800000000000000000000000000000000000000000000 };
1239 #endif
1240
1241 #if 0
1242 #elif GMP_NUMB_BITS == 8
1243 const mp_limb_t mpfr_l2b_31_0__tab[] = { 0xc8, 0x88, 0x9e };
1244 #elif GMP_NUMB_BITS == 16
1245 const mp_limb_t mpfr_l2b_31_0__tab[] = { 0xc800, 0x9e88 };
1246 #elif GMP_NUMB_BITS == 32
1247 const mp_limb_t mpfr_l2b_31_0__tab[] = { 0x9e88c800 };
1248 #elif GMP_NUMB_BITS == 64
1249 const mp_limb_t mpfr_l2b_31_0__tab[] = { UINT64_C(0x9e88c80000000000) };
1250 #elif GMP_NUMB_BITS == 96
1251 const mp_limb_t mpfr_l2b_31_0__tab[] = { 0x9e88c8000000000000000000 };
1252 #elif GMP_NUMB_BITS == 128
1253 const mp_limb_t mpfr_l2b_31_0__tab[] = { 0x9e88c800000000000000000000000000 };
1254 #elif GMP_NUMB_BITS == 256
1255 const mp_limb_t mpfr_l2b_31_0__tab[] = { 0x9e88c80000000000000000000000000000000000000000000000000000000000 };
1256 #endif
1257
1258 #if 0
1259 #elif GMP_NUMB_BITS == 8
1260 const mp_limb_t mpfr_l2b_31_1__tab[] = { 0x78, 0xd5, 0xca, 0xf7, 0xee, 0x63, 0xe6, 0x86, 0xb1, 0xce };
1261 #elif GMP_NUMB_BITS == 16
1262 const mp_limb_t mpfr_l2b_31_1__tab[] = { 0xd578, 0xf7ca, 0x63ee, 0x86e6, 0xceb1 };
1263 #elif GMP_NUMB_BITS == 32
1264 const mp_limb_t mpfr_l2b_31_1__tab[] = { 0xd5780000, 0x63eef7ca, 0xceb186e6 };
1265 #elif GMP_NUMB_BITS == 64
1266 const mp_limb_t mpfr_l2b_31_1__tab[] = { UINT64_C(0xd578000000000000), UINT64_C(0xceb186e663eef7ca) };
1267 #elif GMP_NUMB_BITS == 96
1268 const mp_limb_t mpfr_l2b_31_1__tab[] = { 0xceb186e663eef7cad5780000 };
1269 #elif GMP_NUMB_BITS == 128
1270 const mp_limb_t mpfr_l2b_31_1__tab[] = { 0xceb186e663eef7cad578000000000000 };
1271 #elif GMP_NUMB_BITS == 256
1272 const mp_limb_t mpfr_l2b_31_1__tab[] = { 0xceb186e663eef7cad57800000000000000000000000000000000000000000000 };
1273 #endif
1274
1275 #if 0
1276 #elif GMP_NUMB_BITS == 8
1277 const mp_limb_t mpfr_l2b_32_0__tab[] = { 0x00, 0x00, 0xa0 };
1278 #elif GMP_NUMB_BITS == 16
1279 const mp_limb_t mpfr_l2b_32_0__tab[] = { 0x0000, 0xa000 };
1280 #elif GMP_NUMB_BITS == 32
1281 const mp_limb_t mpfr_l2b_32_0__tab[] = { 0xa0000000 };
1282 #elif GMP_NUMB_BITS == 64
1283 const mp_limb_t mpfr_l2b_32_0__tab[] = { UINT64_C(0xa000000000000000) };
1284 #elif GMP_NUMB_BITS == 96
1285 const mp_limb_t mpfr_l2b_32_0__tab[] = { 0xa00000000000000000000000 };
1286 #elif GMP_NUMB_BITS == 128
1287 const mp_limb_t mpfr_l2b_32_0__tab[] = { 0xa0000000000000000000000000000000 };
1288 #elif GMP_NUMB_BITS == 256
1289 const mp_limb_t mpfr_l2b_32_0__tab[] = { 0xa000000000000000000000000000000000000000000000000000000000000000 };
1290 #endif
1291
1292 #if 0
1293 #elif GMP_NUMB_BITS == 8
1294 const mp_limb_t mpfr_l2b_32_1__tab[] = { 0xd0, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc };
1295 #elif GMP_NUMB_BITS == 16
1296 const mp_limb_t mpfr_l2b_32_1__tab[] = { 0xccd0, 0xcccc, 0xcccc, 0xcccc, 0xcccc };
1297 #elif GMP_NUMB_BITS == 32
1298 const mp_limb_t mpfr_l2b_32_1__tab[] = { 0xccd00000, 0xcccccccc, 0xcccccccc };
1299 #elif GMP_NUMB_BITS == 64
1300 const mp_limb_t mpfr_l2b_32_1__tab[] = { UINT64_C(0xccd0000000000000), UINT64_C(0xcccccccccccccccc) };
1301 #elif GMP_NUMB_BITS == 96
1302 const mp_limb_t mpfr_l2b_32_1__tab[] = { 0xccccccccccccccccccd00000 };
1303 #elif GMP_NUMB_BITS == 128
1304 const mp_limb_t mpfr_l2b_32_1__tab[] = { 0xccccccccccccccccccd0000000000000 };
1305 #elif GMP_NUMB_BITS == 256
1306 const mp_limb_t mpfr_l2b_32_1__tab[] = { 0xccccccccccccccccccd000000000000000000000000000000000000000000000 };
1307 #endif
1308
1309 #if 0
1310 #elif GMP_NUMB_BITS == 8
1311 const mp_limb_t mpfr_l2b_33_0__tab[] = { 0xae, 0x6b, 0xa1 };
1312 #elif GMP_NUMB_BITS == 16
1313 const mp_limb_t mpfr_l2b_33_0__tab[] = { 0xae00, 0xa16b };
1314 #elif GMP_NUMB_BITS == 32
1315 const mp_limb_t mpfr_l2b_33_0__tab[] = { 0xa16bae00 };
1316 #elif GMP_NUMB_BITS == 64
1317 const mp_limb_t mpfr_l2b_33_0__tab[] = { UINT64_C(0xa16bae0000000000) };
1318 #elif GMP_NUMB_BITS == 96
1319 const mp_limb_t mpfr_l2b_33_0__tab[] = { 0xa16bae000000000000000000 };
1320 #elif GMP_NUMB_BITS == 128
1321 const mp_limb_t mpfr_l2b_33_0__tab[] = { 0xa16bae00000000000000000000000000 };
1322 #elif GMP_NUMB_BITS == 256
1323 const mp_limb_t mpfr_l2b_33_0__tab[] = { 0xa16bae0000000000000000000000000000000000000000000000000000000000 };
1324 #endif
1325
1326 #if 0
1327 #elif GMP_NUMB_BITS == 8
1328 const mp_limb_t mpfr_l2b_33_1__tab[] = { 0x88, 0x08, 0x87, 0xa1, 0x04, 0x53, 0x04, 0x64, 0xff, 0xca };
1329 #elif GMP_NUMB_BITS == 16
1330 const mp_limb_t mpfr_l2b_33_1__tab[] = { 0x0888, 0xa187, 0x5304, 0x6404, 0xcaff };
1331 #elif GMP_NUMB_BITS == 32
1332 const mp_limb_t mpfr_l2b_33_1__tab[] = { 0x08880000, 0x5304a187, 0xcaff6404 };
1333 #elif GMP_NUMB_BITS == 64
1334 const mp_limb_t mpfr_l2b_33_1__tab[] = { UINT64_C(0x0888000000000000), UINT64_C(0xcaff64045304a187) };
1335 #elif GMP_NUMB_BITS == 96
1336 const mp_limb_t mpfr_l2b_33_1__tab[] = { 0xcaff64045304a18708880000 };
1337 #elif GMP_NUMB_BITS == 128
1338 const mp_limb_t mpfr_l2b_33_1__tab[] = { 0xcaff64045304a1870888000000000000 };
1339 #elif GMP_NUMB_BITS == 256
1340 const mp_limb_t mpfr_l2b_33_1__tab[] = { 0xcaff64045304a187088800000000000000000000000000000000000000000000 };
1341 #endif
1342
1343 #if 0
1344 #elif GMP_NUMB_BITS == 8
1345 const mp_limb_t mpfr_l2b_34_0__tab[] = { 0x80, 0xcc, 0xa2 };
1346 #elif GMP_NUMB_BITS == 16
1347 const mp_limb_t mpfr_l2b_34_0__tab[] = { 0x8000, 0xa2cc };
1348 #elif GMP_NUMB_BITS == 32
1349 const mp_limb_t mpfr_l2b_34_0__tab[] = { 0xa2cc8000 };
1350 #elif GMP_NUMB_BITS == 64
1351 const mp_limb_t mpfr_l2b_34_0__tab[] = { UINT64_C(0xa2cc800000000000) };
1352 #elif GMP_NUMB_BITS == 96
1353 const mp_limb_t mpfr_l2b_34_0__tab[] = { 0xa2cc80000000000000000000 };
1354 #elif GMP_NUMB_BITS == 128
1355 const mp_limb_t mpfr_l2b_34_0__tab[] = { 0xa2cc8000000000000000000000000000 };
1356 #elif GMP_NUMB_BITS == 256
1357 const mp_limb_t mpfr_l2b_34_0__tab[] = { 0xa2cc800000000000000000000000000000000000000000000000000000000000 };
1358 #endif
1359
1360 #if 0
1361 #elif GMP_NUMB_BITS == 8
1362 const mp_limb_t mpfr_l2b_34_1__tab[] = { 0x50, 0xfb, 0xca, 0x17, 0x79, 0x5a, 0xd8, 0x73, 0x47, 0xc9 };
1363 #elif GMP_NUMB_BITS == 16
1364 const mp_limb_t mpfr_l2b_34_1__tab[] = { 0xfb50, 0x17ca, 0x5a79, 0x73d8, 0xc947 };
1365 #elif GMP_NUMB_BITS == 32
1366 const mp_limb_t mpfr_l2b_34_1__tab[] = { 0xfb500000, 0x5a7917ca, 0xc94773d8 };
1367 #elif GMP_NUMB_BITS == 64
1368 const mp_limb_t mpfr_l2b_34_1__tab[] = { UINT64_C(0xfb50000000000000), UINT64_C(0xc94773d85a7917ca) };
1369 #elif GMP_NUMB_BITS == 96
1370 const mp_limb_t mpfr_l2b_34_1__tab[] = { 0xc94773d85a7917cafb500000 };
1371 #elif GMP_NUMB_BITS == 128
1372 const mp_limb_t mpfr_l2b_34_1__tab[] = { 0xc94773d85a7917cafb50000000000000 };
1373 #elif GMP_NUMB_BITS == 256
1374 const mp_limb_t mpfr_l2b_34_1__tab[] = { 0xc94773d85a7917cafb5000000000000000000000000000000000000000000000 };
1375 #endif
1376
1377 #if 0
1378 #elif GMP_NUMB_BITS == 8
1379 const mp_limb_t mpfr_l2b_35_0__tab[] = { 0x18, 0x23, 0xa4 };
1380 #elif GMP_NUMB_BITS == 16
1381 const mp_limb_t mpfr_l2b_35_0__tab[] = { 0x1800, 0xa423 };
1382 #elif GMP_NUMB_BITS == 32
1383 const mp_limb_t mpfr_l2b_35_0__tab[] = { 0xa4231800 };
1384 #elif GMP_NUMB_BITS == 64
1385 const mp_limb_t mpfr_l2b_35_0__tab[] = { UINT64_C(0xa423180000000000) };
1386 #elif GMP_NUMB_BITS == 96
1387 const mp_limb_t mpfr_l2b_35_0__tab[] = { 0xa42318000000000000000000 };
1388 #elif GMP_NUMB_BITS == 128
1389 const mp_limb_t mpfr_l2b_35_0__tab[] = { 0xa4231800000000000000000000000000 };
1390 #elif GMP_NUMB_BITS == 256
1391 const mp_limb_t mpfr_l2b_35_0__tab[] = { 0xa423180000000000000000000000000000000000000000000000000000000000 };
1392 #endif
1393
1394 #if 0
1395 #elif GMP_NUMB_BITS == 8
1396 const mp_limb_t mpfr_l2b_35_1__tab[] = { 0x60, 0x69, 0xc2, 0x18, 0x37, 0x60, 0x7c, 0x56, 0xa3, 0xc7 };
1397 #elif GMP_NUMB_BITS == 16
1398 const mp_limb_t mpfr_l2b_35_1__tab[] = { 0x6960, 0x18c2, 0x6037, 0x567c, 0xc7a3 };
1399 #elif GMP_NUMB_BITS == 32
1400 const mp_limb_t mpfr_l2b_35_1__tab[] = { 0x69600000, 0x603718c2, 0xc7a3567c };
1401 #elif GMP_NUMB_BITS == 64
1402 const mp_limb_t mpfr_l2b_35_1__tab[] = { UINT64_C(0x6960000000000000), UINT64_C(0xc7a3567c603718c2) };
1403 #elif GMP_NUMB_BITS == 96
1404 const mp_limb_t mpfr_l2b_35_1__tab[] = { 0xc7a3567c603718c269600000 };
1405 #elif GMP_NUMB_BITS == 128
1406 const mp_limb_t mpfr_l2b_35_1__tab[] = { 0xc7a3567c603718c26960000000000000 };
1407 #elif GMP_NUMB_BITS == 256
1408 const mp_limb_t mpfr_l2b_35_1__tab[] = { 0xc7a3567c603718c2696000000000000000000000000000000000000000000000 };
1409 #endif
1410
1411 #if 0
1412 #elif GMP_NUMB_BITS == 8
1413 const mp_limb_t mpfr_l2b_36_0__tab[] = { 0x08, 0x70, 0xa5 };
1414 #elif GMP_NUMB_BITS == 16
1415 const mp_limb_t mpfr_l2b_36_0__tab[] = { 0x0800, 0xa570 };
1416 #elif GMP_NUMB_BITS == 32
1417 const mp_limb_t mpfr_l2b_36_0__tab[] = { 0xa5700800 };
1418 #elif GMP_NUMB_BITS == 64
1419 const mp_limb_t mpfr_l2b_36_0__tab[] = { UINT64_C(0xa570080000000000) };
1420 #elif GMP_NUMB_BITS == 96
1421 const mp_limb_t mpfr_l2b_36_0__tab[] = { 0xa57008000000000000000000 };
1422 #elif GMP_NUMB_BITS == 128
1423 const mp_limb_t mpfr_l2b_36_0__tab[] = { 0xa5700800000000000000000000000000 };
1424 #elif GMP_NUMB_BITS == 256
1425 const mp_limb_t mpfr_l2b_36_0__tab[] = { 0xa570080000000000000000000000000000000000000000000000000000000000 };
1426 #endif
1427
1428 #if 0
1429 #elif GMP_NUMB_BITS == 8
1430 const mp_limb_t mpfr_l2b_36_1__tab[] = { 0x10, 0xff, 0xe9, 0xf9, 0x54, 0xe0, 0x36, 0x92, 0x11, 0xc6 };
1431 #elif GMP_NUMB_BITS == 16
1432 const mp_limb_t mpfr_l2b_36_1__tab[] = { 0xff10, 0xf9e9, 0xe054, 0x9236, 0xc611 };
1433 #elif GMP_NUMB_BITS == 32
1434 const mp_limb_t mpfr_l2b_36_1__tab[] = { 0xff100000, 0xe054f9e9, 0xc6119236 };
1435 #elif GMP_NUMB_BITS == 64
1436 const mp_limb_t mpfr_l2b_36_1__tab[] = { UINT64_C(0xff10000000000000), UINT64_C(0xc6119236e054f9e9) };
1437 #elif GMP_NUMB_BITS == 96
1438 const mp_limb_t mpfr_l2b_36_1__tab[] = { 0xc6119236e054f9e9ff100000 };
1439 #elif GMP_NUMB_BITS == 128
1440 const mp_limb_t mpfr_l2b_36_1__tab[] = { 0xc6119236e054f9e9ff10000000000000 };
1441 #elif GMP_NUMB_BITS == 256
1442 const mp_limb_t mpfr_l2b_36_1__tab[] = { 0xc6119236e054f9e9ff1000000000000000000000000000000000000000000000 };
1443 #endif
1444
1445 #if 0
1446 #elif GMP_NUMB_BITS == 8
1447 const mp_limb_t mpfr_l2b_37_0__tab[] = { 0xd8, 0xb3, 0xa6 };
1448 #elif GMP_NUMB_BITS == 16
1449 const mp_limb_t mpfr_l2b_37_0__tab[] = { 0xd800, 0xa6b3 };
1450 #elif GMP_NUMB_BITS == 32
1451 const mp_limb_t mpfr_l2b_37_0__tab[] = { 0xa6b3d800 };
1452 #elif GMP_NUMB_BITS == 64
1453 const mp_limb_t mpfr_l2b_37_0__tab[] = { UINT64_C(0xa6b3d80000000000) };
1454 #elif GMP_NUMB_BITS == 96
1455 const mp_limb_t mpfr_l2b_37_0__tab[] = { 0xa6b3d8000000000000000000 };
1456 #elif GMP_NUMB_BITS == 128
1457 const mp_limb_t mpfr_l2b_37_0__tab[] = { 0xa6b3d800000000000000000000000000 };
1458 #elif GMP_NUMB_BITS == 256
1459 const mp_limb_t mpfr_l2b_37_0__tab[] = { 0xa6b3d80000000000000000000000000000000000000000000000000000000000 };
1460 #endif
1461
1462 #if 0
1463 #elif GMP_NUMB_BITS == 8
1464 const mp_limb_t mpfr_l2b_37_1__tab[] = { 0x18, 0x16, 0x36, 0x6b, 0xd7, 0x70, 0xa2, 0xd3, 0x90, 0xc4 };
1465 #elif GMP_NUMB_BITS == 16
1466 const mp_limb_t mpfr_l2b_37_1__tab[] = { 0x1618, 0x6b36, 0x70d7, 0xd3a2, 0xc490 };
1467 #elif GMP_NUMB_BITS == 32
1468 const mp_limb_t mpfr_l2b_37_1__tab[] = { 0x16180000, 0x70d76b36, 0xc490d3a2 };
1469 #elif GMP_NUMB_BITS == 64
1470 const mp_limb_t mpfr_l2b_37_1__tab[] = { UINT64_C(0x1618000000000000), UINT64_C(0xc490d3a270d76b36) };
1471 #elif GMP_NUMB_BITS == 96
1472 const mp_limb_t mpfr_l2b_37_1__tab[] = { 0xc490d3a270d76b3616180000 };
1473 #elif GMP_NUMB_BITS == 128
1474 const mp_limb_t mpfr_l2b_37_1__tab[] = { 0xc490d3a270d76b361618000000000000 };
1475 #elif GMP_NUMB_BITS == 256
1476 const mp_limb_t mpfr_l2b_37_1__tab[] = { 0xc490d3a270d76b36161800000000000000000000000000000000000000000000 };
1477 #endif
1478
1479 #if 0
1480 #elif GMP_NUMB_BITS == 8
1481 const mp_limb_t mpfr_l2b_38_0__tab[] = { 0x06, 0xef, 0xa7 };
1482 #elif GMP_NUMB_BITS == 16
1483 const mp_limb_t mpfr_l2b_38_0__tab[] = { 0x0600, 0xa7ef };
1484 #elif GMP_NUMB_BITS == 32
1485 const mp_limb_t mpfr_l2b_38_0__tab[] = { 0xa7ef0600 };
1486 #elif GMP_NUMB_BITS == 64
1487 const mp_limb_t mpfr_l2b_38_0__tab[] = { UINT64_C(0xa7ef060000000000) };
1488 #elif GMP_NUMB_BITS == 96
1489 const mp_limb_t mpfr_l2b_38_0__tab[] = { 0xa7ef06000000000000000000 };
1490 #elif GMP_NUMB_BITS == 128
1491 const mp_limb_t mpfr_l2b_38_0__tab[] = { 0xa7ef0600000000000000000000000000 };
1492 #elif GMP_NUMB_BITS == 256
1493 const mp_limb_t mpfr_l2b_38_0__tab[] = { 0xa7ef060000000000000000000000000000000000000000000000000000000000 };
1494 #endif
1495
1496 #if 0
1497 #elif GMP_NUMB_BITS == 8
1498 const mp_limb_t mpfr_l2b_38_1__tab[] = { 0xe0, 0xa3, 0x05, 0x95, 0x82, 0x51, 0xd2, 0xe8, 0x1f, 0xc3 };
1499 #elif GMP_NUMB_BITS == 16
1500 const mp_limb_t mpfr_l2b_38_1__tab[] = { 0xa3e0, 0x9505, 0x5182, 0xe8d2, 0xc31f };
1501 #elif GMP_NUMB_BITS == 32
1502 const mp_limb_t mpfr_l2b_38_1__tab[] = { 0xa3e00000, 0x51829505, 0xc31fe8d2 };
1503 #elif GMP_NUMB_BITS == 64
1504 const mp_limb_t mpfr_l2b_38_1__tab[] = { UINT64_C(0xa3e0000000000000), UINT64_C(0xc31fe8d251829505) };
1505 #elif GMP_NUMB_BITS == 96
1506 const mp_limb_t mpfr_l2b_38_1__tab[] = { 0xc31fe8d251829505a3e00000 };
1507 #elif GMP_NUMB_BITS == 128
1508 const mp_limb_t mpfr_l2b_38_1__tab[] = { 0xc31fe8d251829505a3e0000000000000 };
1509 #elif GMP_NUMB_BITS == 256
1510 const mp_limb_t mpfr_l2b_38_1__tab[] = { 0xc31fe8d251829505a3e000000000000000000000000000000000000000000000 };
1511 #endif
1512
1513 #if 0
1514 #elif GMP_NUMB_BITS == 8
1515 const mp_limb_t mpfr_l2b_39_0__tab[] = { 0x04, 0x22, 0xa9 };
1516 #elif GMP_NUMB_BITS == 16
1517 const mp_limb_t mpfr_l2b_39_0__tab[] = { 0x0400, 0xa922 };
1518 #elif GMP_NUMB_BITS == 32
1519 const mp_limb_t mpfr_l2b_39_0__tab[] = { 0xa9220400 };
1520 #elif GMP_NUMB_BITS == 64
1521 const mp_limb_t mpfr_l2b_39_0__tab[] = { UINT64_C(0xa922040000000000) };
1522 #elif GMP_NUMB_BITS == 96
1523 const mp_limb_t mpfr_l2b_39_0__tab[] = { 0xa92204000000000000000000 };
1524 #elif GMP_NUMB_BITS == 128
1525 const mp_limb_t mpfr_l2b_39_0__tab[] = { 0xa9220400000000000000000000000000 };
1526 #elif GMP_NUMB_BITS == 256
1527 const mp_limb_t mpfr_l2b_39_0__tab[] = { 0xa922040000000000000000000000000000000000000000000000000000000000 };
1528 #endif
1529
1530 #if 0
1531 #elif GMP_NUMB_BITS == 8
1532 const mp_limb_t mpfr_l2b_39_1__tab[] = { 0xf8, 0xfc, 0xb5, 0xf1, 0xca, 0x10, 0x32, 0xbd, 0xbd, 0xc1 };
1533 #elif GMP_NUMB_BITS == 16
1534 const mp_limb_t mpfr_l2b_39_1__tab[] = { 0xfcf8, 0xf1b5, 0x10ca, 0xbd32, 0xc1bd };
1535 #elif GMP_NUMB_BITS == 32
1536 const mp_limb_t mpfr_l2b_39_1__tab[] = { 0xfcf80000, 0x10caf1b5, 0xc1bdbd32 };
1537 #elif GMP_NUMB_BITS == 64
1538 const mp_limb_t mpfr_l2b_39_1__tab[] = { UINT64_C(0xfcf8000000000000), UINT64_C(0xc1bdbd3210caf1b5) };
1539 #elif GMP_NUMB_BITS == 96
1540 const mp_limb_t mpfr_l2b_39_1__tab[] = { 0xc1bdbd3210caf1b5fcf80000 };
1541 #elif GMP_NUMB_BITS == 128
1542 const mp_limb_t mpfr_l2b_39_1__tab[] = { 0xc1bdbd3210caf1b5fcf8000000000000 };
1543 #elif GMP_NUMB_BITS == 256
1544 const mp_limb_t mpfr_l2b_39_1__tab[] = { 0xc1bdbd3210caf1b5fcf800000000000000000000000000000000000000000000 };
1545 #endif
1546
1547 #if 0
1548 #elif GMP_NUMB_BITS == 8
1549 const mp_limb_t mpfr_l2b_40_0__tab[] = { 0x3e, 0x4d, 0xaa };
1550 #elif GMP_NUMB_BITS == 16
1551 const mp_limb_t mpfr_l2b_40_0__tab[] = { 0x3e00, 0xaa4d };
1552 #elif GMP_NUMB_BITS == 32
1553 const mp_limb_t mpfr_l2b_40_0__tab[] = { 0xaa4d3e00 };
1554 #elif GMP_NUMB_BITS == 64
1555 const mp_limb_t mpfr_l2b_40_0__tab[] = { UINT64_C(0xaa4d3e0000000000) };
1556 #elif GMP_NUMB_BITS == 96
1557 const mp_limb_t mpfr_l2b_40_0__tab[] = { 0xaa4d3e000000000000000000 };
1558 #elif GMP_NUMB_BITS == 128
1559 const mp_limb_t mpfr_l2b_40_0__tab[] = { 0xaa4d3e00000000000000000000000000 };
1560 #elif GMP_NUMB_BITS == 256
1561 const mp_limb_t mpfr_l2b_40_0__tab[] = { 0xaa4d3e0000000000000000000000000000000000000000000000000000000000 };
1562 #endif
1563
1564 #if 0
1565 #elif GMP_NUMB_BITS == 8
1566 const mp_limb_t mpfr_l2b_40_1__tab[] = { 0xe8, 0xdc, 0x48, 0x49, 0xf7, 0xef, 0xff, 0x55, 0x69, 0xc0 };
1567 #elif GMP_NUMB_BITS == 16
1568 const mp_limb_t mpfr_l2b_40_1__tab[] = { 0xdce8, 0x4948, 0xeff7, 0x55ff, 0xc069 };
1569 #elif GMP_NUMB_BITS == 32
1570 const mp_limb_t mpfr_l2b_40_1__tab[] = { 0xdce80000, 0xeff74948, 0xc06955ff };
1571 #elif GMP_NUMB_BITS == 64
1572 const mp_limb_t mpfr_l2b_40_1__tab[] = { UINT64_C(0xdce8000000000000), UINT64_C(0xc06955ffeff74948) };
1573 #elif GMP_NUMB_BITS == 96
1574 const mp_limb_t mpfr_l2b_40_1__tab[] = { 0xc06955ffeff74948dce80000 };
1575 #elif GMP_NUMB_BITS == 128
1576 const mp_limb_t mpfr_l2b_40_1__tab[] = { 0xc06955ffeff74948dce8000000000000 };
1577 #elif GMP_NUMB_BITS == 256
1578 const mp_limb_t mpfr_l2b_40_1__tab[] = { 0xc06955ffeff74948dce800000000000000000000000000000000000000000000 };
1579 #endif
1580
1581 #if 0
1582 #elif GMP_NUMB_BITS == 8
1583 const mp_limb_t mpfr_l2b_41_0__tab[] = { 0x12, 0x71, 0xab };
1584 #elif GMP_NUMB_BITS == 16
1585 const mp_limb_t mpfr_l2b_41_0__tab[] = { 0x1200, 0xab71 };
1586 #elif GMP_NUMB_BITS == 32
1587 const mp_limb_t mpfr_l2b_41_0__tab[] = { 0xab711200 };
1588 #elif GMP_NUMB_BITS == 64
1589 const mp_limb_t mpfr_l2b_41_0__tab[] = { UINT64_C(0xab71120000000000) };
1590 #elif GMP_NUMB_BITS == 96
1591 const mp_limb_t mpfr_l2b_41_0__tab[] = { 0xab7112000000000000000000 };
1592 #elif GMP_NUMB_BITS == 128
1593 const mp_limb_t mpfr_l2b_41_0__tab[] = { 0xab711200000000000000000000000000 };
1594 #elif GMP_NUMB_BITS == 256
1595 const mp_limb_t mpfr_l2b_41_0__tab[] = { 0xab71120000000000000000000000000000000000000000000000000000000000 };
1596 #endif
1597
1598 #if 0
1599 #elif GMP_NUMB_BITS == 8
1600 const mp_limb_t mpfr_l2b_41_1__tab[] = { 0x28, 0xdc, 0xef, 0x7c, 0x95, 0xf6, 0x47, 0xcf, 0x21, 0xbf };
1601 #elif GMP_NUMB_BITS == 16
1602 const mp_limb_t mpfr_l2b_41_1__tab[] = { 0xdc28, 0x7cef, 0xf695, 0xcf47, 0xbf21 };
1603 #elif GMP_NUMB_BITS == 32
1604 const mp_limb_t mpfr_l2b_41_1__tab[] = { 0xdc280000, 0xf6957cef, 0xbf21cf47 };
1605 #elif GMP_NUMB_BITS == 64
1606 const mp_limb_t mpfr_l2b_41_1__tab[] = { UINT64_C(0xdc28000000000000), UINT64_C(0xbf21cf47f6957cef) };
1607 #elif GMP_NUMB_BITS == 96
1608 const mp_limb_t mpfr_l2b_41_1__tab[] = { 0xbf21cf47f6957cefdc280000 };
1609 #elif GMP_NUMB_BITS == 128
1610 const mp_limb_t mpfr_l2b_41_1__tab[] = { 0xbf21cf47f6957cefdc28000000000000 };
1611 #elif GMP_NUMB_BITS == 256
1612 const mp_limb_t mpfr_l2b_41_1__tab[] = { 0xbf21cf47f6957cefdc2800000000000000000000000000000000000000000000 };
1613 #endif
1614
1615 #if 0
1616 #elif GMP_NUMB_BITS == 8
1617 const mp_limb_t mpfr_l2b_42_0__tab[] = { 0xde, 0x8d, 0xac };
1618 #elif GMP_NUMB_BITS == 16
1619 const mp_limb_t mpfr_l2b_42_0__tab[] = { 0xde00, 0xac8d };
1620 #elif GMP_NUMB_BITS == 32
1621 const mp_limb_t mpfr_l2b_42_0__tab[] = { 0xac8dde00 };
1622 #elif GMP_NUMB_BITS == 64
1623 const mp_limb_t mpfr_l2b_42_0__tab[] = { UINT64_C(0xac8dde0000000000) };
1624 #elif GMP_NUMB_BITS == 96
1625 const mp_limb_t mpfr_l2b_42_0__tab[] = { 0xac8dde000000000000000000 };
1626 #elif GMP_NUMB_BITS == 128
1627 const mp_limb_t mpfr_l2b_42_0__tab[] = { 0xac8dde00000000000000000000000000 };
1628 #elif GMP_NUMB_BITS == 256
1629 const mp_limb_t mpfr_l2b_42_0__tab[] = { 0xac8dde0000000000000000000000000000000000000000000000000000000000 };
1630 #endif
1631
1632 #if 0
1633 #elif GMP_NUMB_BITS == 8
1634 const mp_limb_t mpfr_l2b_42_1__tab[] = { 0x10, 0xba, 0x25, 0x71, 0x9b, 0x93, 0x4a, 0x59, 0xe6, 0xbd };
1635 #elif GMP_NUMB_BITS == 16
1636 const mp_limb_t mpfr_l2b_42_1__tab[] = { 0xba10, 0x7125, 0x939b, 0x594a, 0xbde6 };
1637 #elif GMP_NUMB_BITS == 32
1638 const mp_limb_t mpfr_l2b_42_1__tab[] = { 0xba100000, 0x939b7125, 0xbde6594a };
1639 #elif GMP_NUMB_BITS == 64
1640 const mp_limb_t mpfr_l2b_42_1__tab[] = { UINT64_C(0xba10000000000000), UINT64_C(0xbde6594a939b7125) };
1641 #elif GMP_NUMB_BITS == 96
1642 const mp_limb_t mpfr_l2b_42_1__tab[] = { 0xbde6594a939b7125ba100000 };
1643 #elif GMP_NUMB_BITS == 128
1644 const mp_limb_t mpfr_l2b_42_1__tab[] = { 0xbde6594a939b7125ba10000000000000 };
1645 #elif GMP_NUMB_BITS == 256
1646 const mp_limb_t mpfr_l2b_42_1__tab[] = { 0xbde6594a939b7125ba1000000000000000000000000000000000000000000000 };
1647 #endif
1648
1649 #if 0
1650 #elif GMP_NUMB_BITS == 8
1651 const mp_limb_t mpfr_l2b_43_0__tab[] = { 0xf6, 0xa3, 0xad };
1652 #elif GMP_NUMB_BITS == 16
1653 const mp_limb_t mpfr_l2b_43_0__tab[] = { 0xf600, 0xada3 };
1654 #elif GMP_NUMB_BITS == 32
1655 const mp_limb_t mpfr_l2b_43_0__tab[] = { 0xada3f600 };
1656 #elif GMP_NUMB_BITS == 64
1657 const mp_limb_t mpfr_l2b_43_0__tab[] = { UINT64_C(0xada3f60000000000) };
1658 #elif GMP_NUMB_BITS == 96
1659 const mp_limb_t mpfr_l2b_43_0__tab[] = { 0xada3f6000000000000000000 };
1660 #elif GMP_NUMB_BITS == 128
1661 const mp_limb_t mpfr_l2b_43_0__tab[] = { 0xada3f600000000000000000000000000 };
1662 #elif GMP_NUMB_BITS == 256
1663 const mp_limb_t mpfr_l2b_43_0__tab[] = { 0xada3f60000000000000000000000000000000000000000000000000000000000 };
1664 #endif
1665
1666 #if 0
1667 #elif GMP_NUMB_BITS == 8
1668 const mp_limb_t mpfr_l2b_43_1__tab[] = { 0x60, 0x95, 0xb5, 0x2a, 0x18, 0x91, 0x3d, 0x36, 0xb6, 0xbc };
1669 #elif GMP_NUMB_BITS == 16
1670 const mp_limb_t mpfr_l2b_43_1__tab[] = { 0x9560, 0x2ab5, 0x9118, 0x363d, 0xbcb6 };
1671 #elif GMP_NUMB_BITS == 32
1672 const mp_limb_t mpfr_l2b_43_1__tab[] = { 0x95600000, 0x91182ab5, 0xbcb6363d };
1673 #elif GMP_NUMB_BITS == 64
1674 const mp_limb_t mpfr_l2b_43_1__tab[] = { UINT64_C(0x9560000000000000), UINT64_C(0xbcb6363d91182ab5) };
1675 #elif GMP_NUMB_BITS == 96
1676 const mp_limb_t mpfr_l2b_43_1__tab[] = { 0xbcb6363d91182ab595600000 };
1677 #elif GMP_NUMB_BITS == 128
1678 const mp_limb_t mpfr_l2b_43_1__tab[] = { 0xbcb6363d91182ab59560000000000000 };
1679 #elif GMP_NUMB_BITS == 256
1680 const mp_limb_t mpfr_l2b_43_1__tab[] = { 0xbcb6363d91182ab5956000000000000000000000000000000000000000000000 };
1681 #endif
1682
1683 #if 0
1684 #elif GMP_NUMB_BITS == 8
1685 const mp_limb_t mpfr_l2b_44_0__tab[] = { 0xaa, 0xb3, 0xae };
1686 #elif GMP_NUMB_BITS == 16
1687 const mp_limb_t mpfr_l2b_44_0__tab[] = { 0xaa00, 0xaeb3 };
1688 #elif GMP_NUMB_BITS == 32
1689 const mp_limb_t mpfr_l2b_44_0__tab[] = { 0xaeb3aa00 };
1690 #elif GMP_NUMB_BITS == 64
1691 const mp_limb_t mpfr_l2b_44_0__tab[] = { UINT64_C(0xaeb3aa0000000000) };
1692 #elif GMP_NUMB_BITS == 96
1693 const mp_limb_t mpfr_l2b_44_0__tab[] = { 0xaeb3aa000000000000000000 };
1694 #elif GMP_NUMB_BITS == 128
1695 const mp_limb_t mpfr_l2b_44_0__tab[] = { 0xaeb3aa00000000000000000000000000 };
1696 #elif GMP_NUMB_BITS == 256
1697 const mp_limb_t mpfr_l2b_44_0__tab[] = { 0xaeb3aa0000000000000000000000000000000000000000000000000000000000 };
1698 #endif
1699
1700 #if 0
1701 #elif GMP_NUMB_BITS == 8
1702 const mp_limb_t mpfr_l2b_44_1__tab[] = { 0x90, 0x15, 0x90, 0x4e, 0x3d, 0x3a, 0x59, 0xb8, 0x90, 0xbb };
1703 #elif GMP_NUMB_BITS == 16
1704 const mp_limb_t mpfr_l2b_44_1__tab[] = { 0x1590, 0x4e90, 0x3a3d, 0xb859, 0xbb90 };
1705 #elif GMP_NUMB_BITS == 32
1706 const mp_limb_t mpfr_l2b_44_1__tab[] = { 0x15900000, 0x3a3d4e90, 0xbb90b859 };
1707 #elif GMP_NUMB_BITS == 64
1708 const mp_limb_t mpfr_l2b_44_1__tab[] = { UINT64_C(0x1590000000000000), UINT64_C(0xbb90b8593a3d4e90) };
1709 #elif GMP_NUMB_BITS == 96
1710 const mp_limb_t mpfr_l2b_44_1__tab[] = { 0xbb90b8593a3d4e9015900000 };
1711 #elif GMP_NUMB_BITS == 128
1712 const mp_limb_t mpfr_l2b_44_1__tab[] = { 0xbb90b8593a3d4e901590000000000000 };
1713 #elif GMP_NUMB_BITS == 256
1714 const mp_limb_t mpfr_l2b_44_1__tab[] = { 0xbb90b8593a3d4e90159000000000000000000000000000000000000000000000 };
1715 #endif
1716
1717 #if 0
1718 #elif GMP_NUMB_BITS == 8
1719 const mp_limb_t mpfr_l2b_45_0__tab[] = { 0x44, 0xbd, 0xaf };
1720 #elif GMP_NUMB_BITS == 16
1721 const mp_limb_t mpfr_l2b_45_0__tab[] = { 0x4400, 0xafbd };
1722 #elif GMP_NUMB_BITS == 32
1723 const mp_limb_t mpfr_l2b_45_0__tab[] = { 0xafbd4400 };
1724 #elif GMP_NUMB_BITS == 64
1725 const mp_limb_t mpfr_l2b_45_0__tab[] = { UINT64_C(0xafbd440000000000) };
1726 #elif GMP_NUMB_BITS == 96
1727 const mp_limb_t mpfr_l2b_45_0__tab[] = { 0xafbd44000000000000000000 };
1728 #elif GMP_NUMB_BITS == 128
1729 const mp_limb_t mpfr_l2b_45_0__tab[] = { 0xafbd4400000000000000000000000000 };
1730 #elif GMP_NUMB_BITS == 256
1731 const mp_limb_t mpfr_l2b_45_0__tab[] = { 0xafbd440000000000000000000000000000000000000000000000000000000000 };
1732 #endif
1733
1734 #if 0
1735 #elif GMP_NUMB_BITS == 8
1736 const mp_limb_t mpfr_l2b_45_1__tab[] = { 0x78, 0x1e, 0xf5, 0x76, 0x10, 0x10, 0x26, 0x40, 0x75, 0xba };
1737 #elif GMP_NUMB_BITS == 16
1738 const mp_limb_t mpfr_l2b_45_1__tab[] = { 0x1e78, 0x76f5, 0x1010, 0x4026, 0xba75 };
1739 #elif GMP_NUMB_BITS == 32
1740 const mp_limb_t mpfr_l2b_45_1__tab[] = { 0x1e780000, 0x101076f5, 0xba754026 };
1741 #elif GMP_NUMB_BITS == 64
1742 const mp_limb_t mpfr_l2b_45_1__tab[] = { UINT64_C(0x1e78000000000000), UINT64_C(0xba754026101076f5) };
1743 #elif GMP_NUMB_BITS == 96
1744 const mp_limb_t mpfr_l2b_45_1__tab[] = { 0xba754026101076f51e780000 };
1745 #elif GMP_NUMB_BITS == 128
1746 const mp_limb_t mpfr_l2b_45_1__tab[] = { 0xba754026101076f51e78000000000000 };
1747 #elif GMP_NUMB_BITS == 256
1748 const mp_limb_t mpfr_l2b_45_1__tab[] = { 0xba754026101076f51e7800000000000000000000000000000000000000000000 };
1749 #endif
1750
1751 #if 0
1752 #elif GMP_NUMB_BITS == 8
1753 const mp_limb_t mpfr_l2b_46_0__tab[] = { 0x06, 0xc1, 0xb0 };
1754 #elif GMP_NUMB_BITS == 16
1755 const mp_limb_t mpfr_l2b_46_0__tab[] = { 0x0600, 0xb0c1 };
1756 #elif GMP_NUMB_BITS == 32
1757 const mp_limb_t mpfr_l2b_46_0__tab[] = { 0xb0c10600 };
1758 #elif GMP_NUMB_BITS == 64
1759 const mp_limb_t mpfr_l2b_46_0__tab[] = { UINT64_C(0xb0c1060000000000) };
1760 #elif GMP_NUMB_BITS == 96
1761 const mp_limb_t mpfr_l2b_46_0__tab[] = { 0xb0c106000000000000000000 };
1762 #elif GMP_NUMB_BITS == 128
1763 const mp_limb_t mpfr_l2b_46_0__tab[] = { 0xb0c10600000000000000000000000000 };
1764 #elif GMP_NUMB_BITS == 256
1765 const mp_limb_t mpfr_l2b_46_0__tab[] = { 0xb0c1060000000000000000000000000000000000000000000000000000000000 };
1766 #endif
1767
1768 #if 0
1769 #elif GMP_NUMB_BITS == 8
1770 const mp_limb_t mpfr_l2b_46_1__tab[] = { 0x70, 0xb6, 0x12, 0x05, 0xaa, 0x69, 0x01, 0x3b, 0x63, 0xb9 };
1771 #elif GMP_NUMB_BITS == 16
1772 const mp_limb_t mpfr_l2b_46_1__tab[] = { 0xb670, 0x0512, 0x69aa, 0x3b01, 0xb963 };
1773 #elif GMP_NUMB_BITS == 32
1774 const mp_limb_t mpfr_l2b_46_1__tab[] = { 0xb6700000, 0x69aa0512, 0xb9633b01 };
1775 #elif GMP_NUMB_BITS == 64
1776 const mp_limb_t mpfr_l2b_46_1__tab[] = { UINT64_C(0xb670000000000000), UINT64_C(0xb9633b0169aa0512) };
1777 #elif GMP_NUMB_BITS == 96
1778 const mp_limb_t mpfr_l2b_46_1__tab[] = { 0xb9633b0169aa0512b6700000 };
1779 #elif GMP_NUMB_BITS == 128
1780 const mp_limb_t mpfr_l2b_46_1__tab[] = { 0xb9633b0169aa0512b670000000000000 };
1781 #elif GMP_NUMB_BITS == 256
1782 const mp_limb_t mpfr_l2b_46_1__tab[] = { 0xb9633b0169aa0512b67000000000000000000000000000000000000000000000 };
1783 #endif
1784
1785 #if 0
1786 #elif GMP_NUMB_BITS == 8
1787 const mp_limb_t mpfr_l2b_47_0__tab[] = { 0x32, 0xbf, 0xb1 };
1788 #elif GMP_NUMB_BITS == 16
1789 const mp_limb_t mpfr_l2b_47_0__tab[] = { 0x3200, 0xb1bf };
1790 #elif GMP_NUMB_BITS == 32
1791 const mp_limb_t mpfr_l2b_47_0__tab[] = { 0xb1bf3200 };
1792 #elif GMP_NUMB_BITS == 64
1793 const mp_limb_t mpfr_l2b_47_0__tab[] = { UINT64_C(0xb1bf320000000000) };
1794 #elif GMP_NUMB_BITS == 96
1795 const mp_limb_t mpfr_l2b_47_0__tab[] = { 0xb1bf32000000000000000000 };
1796 #elif GMP_NUMB_BITS == 128
1797 const mp_limb_t mpfr_l2b_47_0__tab[] = { 0xb1bf3200000000000000000000000000 };
1798 #elif GMP_NUMB_BITS == 256
1799 const mp_limb_t mpfr_l2b_47_0__tab[] = { 0xb1bf320000000000000000000000000000000000000000000000000000000000 };
1800 #endif
1801
1802 #if 0
1803 #elif GMP_NUMB_BITS == 8
1804 const mp_limb_t mpfr_l2b_47_1__tab[] = { 0x18, 0x51, 0x33, 0x41, 0xe4, 0xfb, 0xd0, 0x21, 0x5a, 0xb8 };
1805 #elif GMP_NUMB_BITS == 16
1806 const mp_limb_t mpfr_l2b_47_1__tab[] = { 0x5118, 0x4133, 0xfbe4, 0x21d0, 0xb85a };
1807 #elif GMP_NUMB_BITS == 32
1808 const mp_limb_t mpfr_l2b_47_1__tab[] = { 0x51180000, 0xfbe44133, 0xb85a21d0 };
1809 #elif GMP_NUMB_BITS == 64
1810 const mp_limb_t mpfr_l2b_47_1__tab[] = { UINT64_C(0x5118000000000000), UINT64_C(0xb85a21d0fbe44133) };
1811 #elif GMP_NUMB_BITS == 96
1812 const mp_limb_t mpfr_l2b_47_1__tab[] = { 0xb85a21d0fbe4413351180000 };
1813 #elif GMP_NUMB_BITS == 128
1814 const mp_limb_t mpfr_l2b_47_1__tab[] = { 0xb85a21d0fbe441335118000000000000 };
1815 #elif GMP_NUMB_BITS == 256
1816 const mp_limb_t mpfr_l2b_47_1__tab[] = { 0xb85a21d0fbe44133511800000000000000000000000000000000000000000000 };
1817 #endif
1818
1819 #if 0
1820 #elif GMP_NUMB_BITS == 8
1821 const mp_limb_t mpfr_l2b_48_0__tab[] = { 0x04, 0xb8, 0xb2 };
1822 #elif GMP_NUMB_BITS == 16
1823 const mp_limb_t mpfr_l2b_48_0__tab[] = { 0x0400, 0xb2b8 };
1824 #elif GMP_NUMB_BITS == 32
1825 const mp_limb_t mpfr_l2b_48_0__tab[] = { 0xb2b80400 };
1826 #elif GMP_NUMB_BITS == 64
1827 const mp_limb_t mpfr_l2b_48_0__tab[] = { UINT64_C(0xb2b8040000000000) };
1828 #elif GMP_NUMB_BITS == 96
1829 const mp_limb_t mpfr_l2b_48_0__tab[] = { 0xb2b804000000000000000000 };
1830 #elif GMP_NUMB_BITS == 128
1831 const mp_limb_t mpfr_l2b_48_0__tab[] = { 0xb2b80400000000000000000000000000 };
1832 #elif GMP_NUMB_BITS == 256
1833 const mp_limb_t mpfr_l2b_48_0__tab[] = { 0xb2b8040000000000000000000000000000000000000000000000000000000000 };
1834 #endif
1835
1836 #if 0
1837 #elif GMP_NUMB_BITS == 8
1838 const mp_limb_t mpfr_l2b_48_1__tab[] = { 0x90, 0x04, 0x3d, 0x66, 0x0d, 0x96, 0xde, 0x77, 0x59, 0xb7 };
1839 #elif GMP_NUMB_BITS == 16
1840 const mp_limb_t mpfr_l2b_48_1__tab[] = { 0x0490, 0x663d, 0x960d, 0x77de, 0xb759 };
1841 #elif GMP_NUMB_BITS == 32
1842 const mp_limb_t mpfr_l2b_48_1__tab[] = { 0x04900000, 0x960d663d, 0xb75977de };
1843 #elif GMP_NUMB_BITS == 64
1844 const mp_limb_t mpfr_l2b_48_1__tab[] = { UINT64_C(0x0490000000000000), UINT64_C(0xb75977de960d663d) };
1845 #elif GMP_NUMB_BITS == 96
1846 const mp_limb_t mpfr_l2b_48_1__tab[] = { 0xb75977de960d663d04900000 };
1847 #elif GMP_NUMB_BITS == 128
1848 const mp_limb_t mpfr_l2b_48_1__tab[] = { 0xb75977de960d663d0490000000000000 };
1849 #elif GMP_NUMB_BITS == 256
1850 const mp_limb_t mpfr_l2b_48_1__tab[] = { 0xb75977de960d663d049000000000000000000000000000000000000000000000 };
1851 #endif
1852
1853 #if 0
1854 #elif GMP_NUMB_BITS == 8
1855 const mp_limb_t mpfr_l2b_49_0__tab[] = { 0xb4, 0xab, 0xb3 };
1856 #elif GMP_NUMB_BITS == 16
1857 const mp_limb_t mpfr_l2b_49_0__tab[] = { 0xb400, 0xb3ab };
1858 #elif GMP_NUMB_BITS == 32
1859 const mp_limb_t mpfr_l2b_49_0__tab[] = { 0xb3abb400 };
1860 #elif GMP_NUMB_BITS == 64
1861 const mp_limb_t mpfr_l2b_49_0__tab[] = { UINT64_C(0xb3abb40000000000) };
1862 #elif GMP_NUMB_BITS == 96
1863 const mp_limb_t mpfr_l2b_49_0__tab[] = { 0xb3abb4000000000000000000 };
1864 #elif GMP_NUMB_BITS == 128
1865 const mp_limb_t mpfr_l2b_49_0__tab[] = { 0xb3abb400000000000000000000000000 };
1866 #elif GMP_NUMB_BITS == 256
1867 const mp_limb_t mpfr_l2b_49_0__tab[] = { 0xb3abb40000000000000000000000000000000000000000000000000000000000 };
1868 #endif
1869
1870 #if 0
1871 #elif GMP_NUMB_BITS == 8
1872 const mp_limb_t mpfr_l2b_49_1__tab[] = { 0xb8, 0x37, 0x11, 0xa7, 0x4d, 0x75, 0xd6, 0xc9, 0x60, 0xb6 };
1873 #elif GMP_NUMB_BITS == 16
1874 const mp_limb_t mpfr_l2b_49_1__tab[] = { 0x37b8, 0xa711, 0x754d, 0xc9d6, 0xb660 };
1875 #elif GMP_NUMB_BITS == 32
1876 const mp_limb_t mpfr_l2b_49_1__tab[] = { 0x37b80000, 0x754da711, 0xb660c9d6 };
1877 #elif GMP_NUMB_BITS == 64
1878 const mp_limb_t mpfr_l2b_49_1__tab[] = { UINT64_C(0x37b8000000000000), UINT64_C(0xb660c9d6754da711) };
1879 #elif GMP_NUMB_BITS == 96
1880 const mp_limb_t mpfr_l2b_49_1__tab[] = { 0xb660c9d6754da71137b80000 };
1881 #elif GMP_NUMB_BITS == 128
1882 const mp_limb_t mpfr_l2b_49_1__tab[] = { 0xb660c9d6754da71137b8000000000000 };
1883 #elif GMP_NUMB_BITS == 256
1884 const mp_limb_t mpfr_l2b_49_1__tab[] = { 0xb660c9d6754da71137b800000000000000000000000000000000000000000000 };
1885 #endif
1886
1887 #if 0
1888 #elif GMP_NUMB_BITS == 8
1889 const mp_limb_t mpfr_l2b_50_0__tab[] = { 0x7a, 0x9a, 0xb4 };
1890 #elif GMP_NUMB_BITS == 16
1891 const mp_limb_t mpfr_l2b_50_0__tab[] = { 0x7a00, 0xb49a };
1892 #elif GMP_NUMB_BITS == 32
1893 const mp_limb_t mpfr_l2b_50_0__tab[] = { 0xb49a7a00 };
1894 #elif GMP_NUMB_BITS == 64
1895 const mp_limb_t mpfr_l2b_50_0__tab[] = { UINT64_C(0xb49a7a0000000000) };
1896 #elif GMP_NUMB_BITS == 96
1897 const mp_limb_t mpfr_l2b_50_0__tab[] = { 0xb49a7a000000000000000000 };
1898 #elif GMP_NUMB_BITS == 128
1899 const mp_limb_t mpfr_l2b_50_0__tab[] = { 0xb49a7a00000000000000000000000000 };
1900 #elif GMP_NUMB_BITS == 256
1901 const mp_limb_t mpfr_l2b_50_0__tab[] = { 0xb49a7a0000000000000000000000000000000000000000000000000000000000 };
1902 #endif
1903
1904 #if 0
1905 #elif GMP_NUMB_BITS == 8
1906 const mp_limb_t mpfr_l2b_50_1__tab[] = { 0xf0, 0x27, 0x32, 0xe5, 0x44, 0x73, 0xe3, 0xac, 0x6f, 0xb5 };
1907 #elif GMP_NUMB_BITS == 16
1908 const mp_limb_t mpfr_l2b_50_1__tab[] = { 0x27f0, 0xe532, 0x7344, 0xace3, 0xb56f };
1909 #elif GMP_NUMB_BITS == 32
1910 const mp_limb_t mpfr_l2b_50_1__tab[] = { 0x27f00000, 0x7344e532, 0xb56face3 };
1911 #elif GMP_NUMB_BITS == 64
1912 const mp_limb_t mpfr_l2b_50_1__tab[] = { UINT64_C(0x27f0000000000000), UINT64_C(0xb56face37344e532) };
1913 #elif GMP_NUMB_BITS == 96
1914 const mp_limb_t mpfr_l2b_50_1__tab[] = { 0xb56face37344e53227f00000 };
1915 #elif GMP_NUMB_BITS == 128
1916 const mp_limb_t mpfr_l2b_50_1__tab[] = { 0xb56face37344e53227f0000000000000 };
1917 #elif GMP_NUMB_BITS == 256
1918 const mp_limb_t mpfr_l2b_50_1__tab[] = { 0xb56face37344e53227f000000000000000000000000000000000000000000000 };
1919 #endif
1920
1921 #if 0
1922 #elif GMP_NUMB_BITS == 8
1923 const mp_limb_t mpfr_l2b_51_0__tab[] = { 0x84, 0x84, 0xb5 };
1924 #elif GMP_NUMB_BITS == 16
1925 const mp_limb_t mpfr_l2b_51_0__tab[] = { 0x8400, 0xb584 };
1926 #elif GMP_NUMB_BITS == 32
1927 const mp_limb_t mpfr_l2b_51_0__tab[] = { 0xb5848400 };
1928 #elif GMP_NUMB_BITS == 64
1929 const mp_limb_t mpfr_l2b_51_0__tab[] = { UINT64_C(0xb584840000000000) };
1930 #elif GMP_NUMB_BITS == 96
1931 const mp_limb_t mpfr_l2b_51_0__tab[] = { 0xb58484000000000000000000 };
1932 #elif GMP_NUMB_BITS == 128
1933 const mp_limb_t mpfr_l2b_51_0__tab[] = { 0xb5848400000000000000000000000000 };
1934 #elif GMP_NUMB_BITS == 256
1935 const mp_limb_t mpfr_l2b_51_0__tab[] = { 0xb584840000000000000000000000000000000000000000000000000000000000 };
1936 #endif
1937
1938 #if 0
1939 #elif GMP_NUMB_BITS == 8
1940 const mp_limb_t mpfr_l2b_51_1__tab[] = { 0x00, 0x40, 0xa9, 0xe9, 0x8a, 0x0f, 0xe5, 0xbd, 0x85, 0xb4 };
1941 #elif GMP_NUMB_BITS == 16
1942 const mp_limb_t mpfr_l2b_51_1__tab[] = { 0x4000, 0xe9a9, 0x0f8a, 0xbde5, 0xb485 };
1943 #elif GMP_NUMB_BITS == 32
1944 const mp_limb_t mpfr_l2b_51_1__tab[] = { 0x40000000, 0x0f8ae9a9, 0xb485bde5 };
1945 #elif GMP_NUMB_BITS == 64
1946 const mp_limb_t mpfr_l2b_51_1__tab[] = { UINT64_C(0x4000000000000000), UINT64_C(0xb485bde50f8ae9a9) };
1947 #elif GMP_NUMB_BITS == 96
1948 const mp_limb_t mpfr_l2b_51_1__tab[] = { 0xb485bde50f8ae9a940000000 };
1949 #elif GMP_NUMB_BITS == 128
1950 const mp_limb_t mpfr_l2b_51_1__tab[] = { 0xb485bde50f8ae9a94000000000000000 };
1951 #elif GMP_NUMB_BITS == 256
1952 const mp_limb_t mpfr_l2b_51_1__tab[] = { 0xb485bde50f8ae9a9400000000000000000000000000000000000000000000000 };
1953 #endif
1954
1955 #if 0
1956 #elif GMP_NUMB_BITS == 8
1957 const mp_limb_t mpfr_l2b_52_0__tab[] = { 0x02, 0x6a, 0xb6 };
1958 #elif GMP_NUMB_BITS == 16
1959 const mp_limb_t mpfr_l2b_52_0__tab[] = { 0x0200, 0xb66a };
1960 #elif GMP_NUMB_BITS == 32
1961 const mp_limb_t mpfr_l2b_52_0__tab[] = { 0xb66a0200 };
1962 #elif GMP_NUMB_BITS == 64
1963 const mp_limb_t mpfr_l2b_52_0__tab[] = { UINT64_C(0xb66a020000000000) };
1964 #elif GMP_NUMB_BITS == 96
1965 const mp_limb_t mpfr_l2b_52_0__tab[] = { 0xb66a02000000000000000000 };
1966 #elif GMP_NUMB_BITS == 128
1967 const mp_limb_t mpfr_l2b_52_0__tab[] = { 0xb66a0200000000000000000000000000 };
1968 #elif GMP_NUMB_BITS == 256
1969 const mp_limb_t mpfr_l2b_52_0__tab[] = { 0xb66a020000000000000000000000000000000000000000000000000000000000 };
1970 #endif
1971
1972 #if 0
1973 #elif GMP_NUMB_BITS == 8
1974 const mp_limb_t mpfr_l2b_52_1__tab[] = { 0x08, 0x46, 0xb3, 0xfc, 0xcf, 0xee, 0xbb, 0xa0, 0xa2, 0xb3 };
1975 #elif GMP_NUMB_BITS == 16
1976 const mp_limb_t mpfr_l2b_52_1__tab[] = { 0x4608, 0xfcb3, 0xeecf, 0xa0bb, 0xb3a2 };
1977 #elif GMP_NUMB_BITS == 32
1978 const mp_limb_t mpfr_l2b_52_1__tab[] = { 0x46080000, 0xeecffcb3, 0xb3a2a0bb };
1979 #elif GMP_NUMB_BITS == 64
1980 const mp_limb_t mpfr_l2b_52_1__tab[] = { UINT64_C(0x4608000000000000), UINT64_C(0xb3a2a0bbeecffcb3) };
1981 #elif GMP_NUMB_BITS == 96
1982 const mp_limb_t mpfr_l2b_52_1__tab[] = { 0xb3a2a0bbeecffcb346080000 };
1983 #elif GMP_NUMB_BITS == 128
1984 const mp_limb_t mpfr_l2b_52_1__tab[] = { 0xb3a2a0bbeecffcb34608000000000000 };
1985 #elif GMP_NUMB_BITS == 256
1986 const mp_limb_t mpfr_l2b_52_1__tab[] = { 0xb3a2a0bbeecffcb3460800000000000000000000000000000000000000000000 };
1987 #endif
1988
1989 #if 0
1990 #elif GMP_NUMB_BITS == 8
1991 const mp_limb_t mpfr_l2b_53_0__tab[] = { 0x20, 0x4b, 0xb7 };
1992 #elif GMP_NUMB_BITS == 16
1993 const mp_limb_t mpfr_l2b_53_0__tab[] = { 0x2000, 0xb74b };
1994 #elif GMP_NUMB_BITS == 32
1995 const mp_limb_t mpfr_l2b_53_0__tab[] = { 0xb74b2000 };
1996 #elif GMP_NUMB_BITS == 64
1997 const mp_limb_t mpfr_l2b_53_0__tab[] = { UINT64_C(0xb74b200000000000) };
1998 #elif GMP_NUMB_BITS == 96
1999 const mp_limb_t mpfr_l2b_53_0__tab[] = { 0xb74b20000000000000000000 };
2000 #elif GMP_NUMB_BITS == 128
2001 const mp_limb_t mpfr_l2b_53_0__tab[] = { 0xb74b2000000000000000000000000000 };
2002 #elif GMP_NUMB_BITS == 256
2003 const mp_limb_t mpfr_l2b_53_0__tab[] = { 0xb74b200000000000000000000000000000000000000000000000000000000000 };
2004 #endif
2005
2006 #if 0
2007 #elif GMP_NUMB_BITS == 8
2008 const mp_limb_t mpfr_l2b_53_1__tab[] = { 0x60, 0xa3, 0xcb, 0x8c, 0x5f, 0xeb, 0xa9, 0xff, 0xc5, 0xb2 };
2009 #elif GMP_NUMB_BITS == 16
2010 const mp_limb_t mpfr_l2b_53_1__tab[] = { 0xa360, 0x8ccb, 0xeb5f, 0xffa9, 0xb2c5 };
2011 #elif GMP_NUMB_BITS == 32
2012 const mp_limb_t mpfr_l2b_53_1__tab[] = { 0xa3600000, 0xeb5f8ccb, 0xb2c5ffa9 };
2013 #elif GMP_NUMB_BITS == 64
2014 const mp_limb_t mpfr_l2b_53_1__tab[] = { UINT64_C(0xa360000000000000), UINT64_C(0xb2c5ffa9eb5f8ccb) };
2015 #elif GMP_NUMB_BITS == 96
2016 const mp_limb_t mpfr_l2b_53_1__tab[] = { 0xb2c5ffa9eb5f8ccba3600000 };
2017 #elif GMP_NUMB_BITS == 128
2018 const mp_limb_t mpfr_l2b_53_1__tab[] = { 0xb2c5ffa9eb5f8ccba360000000000000 };
2019 #elif GMP_NUMB_BITS == 256
2020 const mp_limb_t mpfr_l2b_53_1__tab[] = { 0xb2c5ffa9eb5f8ccba36000000000000000000000000000000000000000000000 };
2021 #endif
2022
2023 #if 0
2024 #elif GMP_NUMB_BITS == 8
2025 const mp_limb_t mpfr_l2b_54_0__tab[] = { 0x0a, 0x28, 0xb8 };
2026 #elif GMP_NUMB_BITS == 16
2027 const mp_limb_t mpfr_l2b_54_0__tab[] = { 0x0a00, 0xb828 };
2028 #elif GMP_NUMB_BITS == 32
2029 const mp_limb_t mpfr_l2b_54_0__tab[] = { 0xb8280a00 };
2030 #elif GMP_NUMB_BITS == 64
2031 const mp_limb_t mpfr_l2b_54_0__tab[] = { UINT64_C(0xb8280a0000000000) };
2032 #elif GMP_NUMB_BITS == 96
2033 const mp_limb_t mpfr_l2b_54_0__tab[] = { 0xb8280a000000000000000000 };
2034 #elif GMP_NUMB_BITS == 128
2035 const mp_limb_t mpfr_l2b_54_0__tab[] = { 0xb8280a00000000000000000000000000 };
2036 #elif GMP_NUMB_BITS == 256
2037 const mp_limb_t mpfr_l2b_54_0__tab[] = { 0xb8280a0000000000000000000000000000000000000000000000000000000000 };
2038 #endif
2039
2040 #if 0
2041 #elif GMP_NUMB_BITS == 8
2042 const mp_limb_t mpfr_l2b_54_1__tab[] = { 0x68, 0xf3, 0x40, 0xe9, 0x86, 0x3e, 0xc3, 0x8a, 0xef, 0xb1 };
2043 #elif GMP_NUMB_BITS == 16
2044 const mp_limb_t mpfr_l2b_54_1__tab[] = { 0xf368, 0xe940, 0x3e86, 0x8ac3, 0xb1ef };
2045 #elif GMP_NUMB_BITS == 32
2046 const mp_limb_t mpfr_l2b_54_1__tab[] = { 0xf3680000, 0x3e86e940, 0xb1ef8ac3 };
2047 #elif GMP_NUMB_BITS == 64
2048 const mp_limb_t mpfr_l2b_54_1__tab[] = { UINT64_C(0xf368000000000000), UINT64_C(0xb1ef8ac33e86e940) };
2049 #elif GMP_NUMB_BITS == 96
2050 const mp_limb_t mpfr_l2b_54_1__tab[] = { 0xb1ef8ac33e86e940f3680000 };
2051 #elif GMP_NUMB_BITS == 128
2052 const mp_limb_t mpfr_l2b_54_1__tab[] = { 0xb1ef8ac33e86e940f368000000000000 };
2053 #elif GMP_NUMB_BITS == 256
2054 const mp_limb_t mpfr_l2b_54_1__tab[] = { 0xb1ef8ac33e86e940f36800000000000000000000000000000000000000000000 };
2055 #endif
2056
2057 #if 0
2058 #elif GMP_NUMB_BITS == 8
2059 const mp_limb_t mpfr_l2b_55_0__tab[] = { 0xe8, 0x00, 0xb9 };
2060 #elif GMP_NUMB_BITS == 16
2061 const mp_limb_t mpfr_l2b_55_0__tab[] = { 0xe800, 0xb900 };
2062 #elif GMP_NUMB_BITS == 32
2063 const mp_limb_t mpfr_l2b_55_0__tab[] = { 0xb900e800 };
2064 #elif GMP_NUMB_BITS == 64
2065 const mp_limb_t mpfr_l2b_55_0__tab[] = { UINT64_C(0xb900e80000000000) };
2066 #elif GMP_NUMB_BITS == 96
2067 const mp_limb_t mpfr_l2b_55_0__tab[] = { 0xb900e8000000000000000000 };
2068 #elif GMP_NUMB_BITS == 128
2069 const mp_limb_t mpfr_l2b_55_0__tab[] = { 0xb900e800000000000000000000000000 };
2070 #elif GMP_NUMB_BITS == 256
2071 const mp_limb_t mpfr_l2b_55_0__tab[] = { 0xb900e80000000000000000000000000000000000000000000000000000000000 };
2072 #endif
2073
2074 #if 0
2075 #elif GMP_NUMB_BITS == 8
2076 const mp_limb_t mpfr_l2b_55_1__tab[] = { 0x40, 0x7a, 0x8e, 0xd1, 0xb5, 0xa4, 0x6e, 0xf7, 0x1e, 0xb1 };
2077 #elif GMP_NUMB_BITS == 16
2078 const mp_limb_t mpfr_l2b_55_1__tab[] = { 0x7a40, 0xd18e, 0xa4b5, 0xf76e, 0xb11e };
2079 #elif GMP_NUMB_BITS == 32
2080 const mp_limb_t mpfr_l2b_55_1__tab[] = { 0x7a400000, 0xa4b5d18e, 0xb11ef76e };
2081 #elif GMP_NUMB_BITS == 64
2082 const mp_limb_t mpfr_l2b_55_1__tab[] = { UINT64_C(0x7a40000000000000), UINT64_C(0xb11ef76ea4b5d18e) };
2083 #elif GMP_NUMB_BITS == 96
2084 const mp_limb_t mpfr_l2b_55_1__tab[] = { 0xb11ef76ea4b5d18e7a400000 };
2085 #elif GMP_NUMB_BITS == 128
2086 const mp_limb_t mpfr_l2b_55_1__tab[] = { 0xb11ef76ea4b5d18e7a40000000000000 };
2087 #elif GMP_NUMB_BITS == 256
2088 const mp_limb_t mpfr_l2b_55_1__tab[] = { 0xb11ef76ea4b5d18e7a4000000000000000000000000000000000000000000000 };
2089 #endif
2090
2091 #if 0
2092 #elif GMP_NUMB_BITS == 8
2093 const mp_limb_t mpfr_l2b_56_0__tab[] = { 0xda, 0xd5, 0xb9 };
2094 #elif GMP_NUMB_BITS == 16
2095 const mp_limb_t mpfr_l2b_56_0__tab[] = { 0xda00, 0xb9d5 };
2096 #elif GMP_NUMB_BITS == 32
2097 const mp_limb_t mpfr_l2b_56_0__tab[] = { 0xb9d5da00 };
2098 #elif GMP_NUMB_BITS == 64
2099 const mp_limb_t mpfr_l2b_56_0__tab[] = { UINT64_C(0xb9d5da0000000000) };
2100 #elif GMP_NUMB_BITS == 96
2101 const mp_limb_t mpfr_l2b_56_0__tab[] = { 0xb9d5da000000000000000000 };
2102 #elif GMP_NUMB_BITS == 128
2103 const mp_limb_t mpfr_l2b_56_0__tab[] = { 0xb9d5da00000000000000000000000000 };
2104 #elif GMP_NUMB_BITS == 256
2105 const mp_limb_t mpfr_l2b_56_0__tab[] = { 0xb9d5da0000000000000000000000000000000000000000000000000000000000 };
2106 #endif
2107
2108 #if 0
2109 #elif GMP_NUMB_BITS == 8
2110 const mp_limb_t mpfr_l2b_56_1__tab[] = { 0x18, 0xe8, 0x7b, 0x4c, 0x2c, 0xaa, 0xf2, 0xff, 0x53, 0xb0 };
2111 #elif GMP_NUMB_BITS == 16
2112 const mp_limb_t mpfr_l2b_56_1__tab[] = { 0xe818, 0x4c7b, 0xaa2c, 0xfff2, 0xb053 };
2113 #elif GMP_NUMB_BITS == 32
2114 const mp_limb_t mpfr_l2b_56_1__tab[] = { 0xe8180000, 0xaa2c4c7b, 0xb053fff2 };
2115 #elif GMP_NUMB_BITS == 64
2116 const mp_limb_t mpfr_l2b_56_1__tab[] = { UINT64_C(0xe818000000000000), UINT64_C(0xb053fff2aa2c4c7b) };
2117 #elif GMP_NUMB_BITS == 96
2118 const mp_limb_t mpfr_l2b_56_1__tab[] = { 0xb053fff2aa2c4c7be8180000 };
2119 #elif GMP_NUMB_BITS == 128
2120 const mp_limb_t mpfr_l2b_56_1__tab[] = { 0xb053fff2aa2c4c7be818000000000000 };
2121 #elif GMP_NUMB_BITS == 256
2122 const mp_limb_t mpfr_l2b_56_1__tab[] = { 0xb053fff2aa2c4c7be81800000000000000000000000000000000000000000000 };
2123 #endif
2124
2125 #if 0
2126 #elif GMP_NUMB_BITS == 8
2127 const mp_limb_t mpfr_l2b_57_0__tab[] = { 0x0a, 0xa7, 0xba };
2128 #elif GMP_NUMB_BITS == 16
2129 const mp_limb_t mpfr_l2b_57_0__tab[] = { 0x0a00, 0xbaa7 };
2130 #elif GMP_NUMB_BITS == 32
2131 const mp_limb_t mpfr_l2b_57_0__tab[] = { 0xbaa70a00 };
2132 #elif GMP_NUMB_BITS == 64
2133 const mp_limb_t mpfr_l2b_57_0__tab[] = { UINT64_C(0xbaa70a0000000000) };
2134 #elif GMP_NUMB_BITS == 96
2135 const mp_limb_t mpfr_l2b_57_0__tab[] = { 0xbaa70a000000000000000000 };
2136 #elif GMP_NUMB_BITS == 128
2137 const mp_limb_t mpfr_l2b_57_0__tab[] = { 0xbaa70a00000000000000000000000000 };
2138 #elif GMP_NUMB_BITS == 256
2139 const mp_limb_t mpfr_l2b_57_0__tab[] = { 0xbaa70a0000000000000000000000000000000000000000000000000000000000 };
2140 #endif
2141
2142 #if 0
2143 #elif GMP_NUMB_BITS == 8
2144 const mp_limb_t mpfr_l2b_57_1__tab[] = { 0xb0, 0xef, 0x4f, 0x81, 0x2f, 0x8e, 0x0e, 0x63, 0x8e, 0xaf };
2145 #elif GMP_NUMB_BITS == 16
2146 const mp_limb_t mpfr_l2b_57_1__tab[] = { 0xefb0, 0x814f, 0x8e2f, 0x630e, 0xaf8e };
2147 #elif GMP_NUMB_BITS == 32
2148 const mp_limb_t mpfr_l2b_57_1__tab[] = { 0xefb00000, 0x8e2f814f, 0xaf8e630e };
2149 #elif GMP_NUMB_BITS == 64
2150 const mp_limb_t mpfr_l2b_57_1__tab[] = { UINT64_C(0xefb0000000000000), UINT64_C(0xaf8e630e8e2f814f) };
2151 #elif GMP_NUMB_BITS == 96
2152 const mp_limb_t mpfr_l2b_57_1__tab[] = { 0xaf8e630e8e2f814fefb00000 };
2153 #elif GMP_NUMB_BITS == 128
2154 const mp_limb_t mpfr_l2b_57_1__tab[] = { 0xaf8e630e8e2f814fefb0000000000000 };
2155 #elif GMP_NUMB_BITS == 256
2156 const mp_limb_t mpfr_l2b_57_1__tab[] = { 0xaf8e630e8e2f814fefb000000000000000000000000000000000000000000000 };
2157 #endif
2158
2159 #if 0
2160 #elif GMP_NUMB_BITS == 8
2161 const mp_limb_t mpfr_l2b_58_0__tab[] = { 0x96, 0x74, 0xbb };
2162 #elif GMP_NUMB_BITS == 16
2163 const mp_limb_t mpfr_l2b_58_0__tab[] = { 0x9600, 0xbb74 };
2164 #elif GMP_NUMB_BITS == 32
2165 const mp_limb_t mpfr_l2b_58_0__tab[] = { 0xbb749600 };
2166 #elif GMP_NUMB_BITS == 64
2167 const mp_limb_t mpfr_l2b_58_0__tab[] = { UINT64_C(0xbb74960000000000) };
2168 #elif GMP_NUMB_BITS == 96
2169 const mp_limb_t mpfr_l2b_58_0__tab[] = { 0xbb7496000000000000000000 };
2170 #elif GMP_NUMB_BITS == 128
2171 const mp_limb_t mpfr_l2b_58_0__tab[] = { 0xbb749600000000000000000000000000 };
2172 #elif GMP_NUMB_BITS == 256
2173 const mp_limb_t mpfr_l2b_58_0__tab[] = { 0xbb74960000000000000000000000000000000000000000000000000000000000 };
2174 #endif
2175
2176 #if 0
2177 #elif GMP_NUMB_BITS == 8
2178 const mp_limb_t mpfr_l2b_58_1__tab[] = { 0x18, 0x5d, 0xa1, 0x41, 0x14, 0x61, 0x9d, 0xe3, 0xcd, 0xae };
2179 #elif GMP_NUMB_BITS == 16
2180 const mp_limb_t mpfr_l2b_58_1__tab[] = { 0x5d18, 0x41a1, 0x6114, 0xe39d, 0xaecd };
2181 #elif GMP_NUMB_BITS == 32
2182 const mp_limb_t mpfr_l2b_58_1__tab[] = { 0x5d180000, 0x611441a1, 0xaecde39d };
2183 #elif GMP_NUMB_BITS == 64
2184 const mp_limb_t mpfr_l2b_58_1__tab[] = { UINT64_C(0x5d18000000000000), UINT64_C(0xaecde39d611441a1) };
2185 #elif GMP_NUMB_BITS == 96
2186 const mp_limb_t mpfr_l2b_58_1__tab[] = { 0xaecde39d611441a15d180000 };
2187 #elif GMP_NUMB_BITS == 128
2188 const mp_limb_t mpfr_l2b_58_1__tab[] = { 0xaecde39d611441a15d18000000000000 };
2189 #elif GMP_NUMB_BITS == 256
2190 const mp_limb_t mpfr_l2b_58_1__tab[] = { 0xaecde39d611441a15d1800000000000000000000000000000000000000000000 };
2191 #endif
2192
2193 #if 0
2194 #elif GMP_NUMB_BITS == 8
2195 const mp_limb_t mpfr_l2b_59_0__tab[] = { 0x9e, 0x3e, 0xbc };
2196 #elif GMP_NUMB_BITS == 16
2197 const mp_limb_t mpfr_l2b_59_0__tab[] = { 0x9e00, 0xbc3e };
2198 #elif GMP_NUMB_BITS == 32
2199 const mp_limb_t mpfr_l2b_59_0__tab[] = { 0xbc3e9e00 };
2200 #elif GMP_NUMB_BITS == 64
2201 const mp_limb_t mpfr_l2b_59_0__tab[] = { UINT64_C(0xbc3e9e0000000000) };
2202 #elif GMP_NUMB_BITS == 96
2203 const mp_limb_t mpfr_l2b_59_0__tab[] = { 0xbc3e9e000000000000000000 };
2204 #elif GMP_NUMB_BITS == 128
2205 const mp_limb_t mpfr_l2b_59_0__tab[] = { 0xbc3e9e00000000000000000000000000 };
2206 #elif GMP_NUMB_BITS == 256
2207 const mp_limb_t mpfr_l2b_59_0__tab[] = { 0xbc3e9e0000000000000000000000000000000000000000000000000000000000 };
2208 #endif
2209
2210 #if 0
2211 #elif GMP_NUMB_BITS == 8
2212 const mp_limb_t mpfr_l2b_59_1__tab[] = { 0x00, 0xd0, 0xdf, 0x97, 0x97, 0x2f, 0x42, 0x48, 0x12, 0xae };
2213 #elif GMP_NUMB_BITS == 16
2214 const mp_limb_t mpfr_l2b_59_1__tab[] = { 0xd000, 0x97df, 0x2f97, 0x4842, 0xae12 };
2215 #elif GMP_NUMB_BITS == 32
2216 const mp_limb_t mpfr_l2b_59_1__tab[] = { 0xd0000000, 0x2f9797df, 0xae124842 };
2217 #elif GMP_NUMB_BITS == 64
2218 const mp_limb_t mpfr_l2b_59_1__tab[] = { UINT64_C(0xd000000000000000), UINT64_C(0xae1248422f9797df) };
2219 #elif GMP_NUMB_BITS == 96
2220 const mp_limb_t mpfr_l2b_59_1__tab[] = { 0xae1248422f9797dfd0000000 };
2221 #elif GMP_NUMB_BITS == 128
2222 const mp_limb_t mpfr_l2b_59_1__tab[] = { 0xae1248422f9797dfd000000000000000 };
2223 #elif GMP_NUMB_BITS == 256
2224 const mp_limb_t mpfr_l2b_59_1__tab[] = { 0xae1248422f9797dfd00000000000000000000000000000000000000000000000 };
2225 #endif
2226
2227 #if 0
2228 #elif GMP_NUMB_BITS == 8
2229 const mp_limb_t mpfr_l2b_60_0__tab[] = { 0x40, 0x05, 0xbd };
2230 #elif GMP_NUMB_BITS == 16
2231 const mp_limb_t mpfr_l2b_60_0__tab[] = { 0x4000, 0xbd05 };
2232 #elif GMP_NUMB_BITS == 32
2233 const mp_limb_t mpfr_l2b_60_0__tab[] = { 0xbd054000 };
2234 #elif GMP_NUMB_BITS == 64
2235 const mp_limb_t mpfr_l2b_60_0__tab[] = { UINT64_C(0xbd05400000000000) };
2236 #elif GMP_NUMB_BITS == 96
2237 const mp_limb_t mpfr_l2b_60_0__tab[] = { 0xbd0540000000000000000000 };
2238 #elif GMP_NUMB_BITS == 128
2239 const mp_limb_t mpfr_l2b_60_0__tab[] = { 0xbd054000000000000000000000000000 };
2240 #elif GMP_NUMB_BITS == 256
2241 const mp_limb_t mpfr_l2b_60_0__tab[] = { 0xbd05400000000000000000000000000000000000000000000000000000000000 };
2242 #endif
2243
2244 #if 0
2245 #elif GMP_NUMB_BITS == 8
2246 const mp_limb_t mpfr_l2b_60_1__tab[] = { 0x58, 0xfe, 0x6d, 0x20, 0x55, 0x35, 0x1c, 0x5b, 0x5b, 0xad };
2247 #elif GMP_NUMB_BITS == 16
2248 const mp_limb_t mpfr_l2b_60_1__tab[] = { 0xfe58, 0x206d, 0x3555, 0x5b1c, 0xad5b };
2249 #elif GMP_NUMB_BITS == 32
2250 const mp_limb_t mpfr_l2b_60_1__tab[] = { 0xfe580000, 0x3555206d, 0xad5b5b1c };
2251 #elif GMP_NUMB_BITS == 64
2252 const mp_limb_t mpfr_l2b_60_1__tab[] = { UINT64_C(0xfe58000000000000), UINT64_C(0xad5b5b1c3555206d) };
2253 #elif GMP_NUMB_BITS == 96
2254 const mp_limb_t mpfr_l2b_60_1__tab[] = { 0xad5b5b1c3555206dfe580000 };
2255 #elif GMP_NUMB_BITS == 128
2256 const mp_limb_t mpfr_l2b_60_1__tab[] = { 0xad5b5b1c3555206dfe58000000000000 };
2257 #elif GMP_NUMB_BITS == 256
2258 const mp_limb_t mpfr_l2b_60_1__tab[] = { 0xad5b5b1c3555206dfe5800000000000000000000000000000000000000000000 };
2259 #endif
2260
2261 #if 0
2262 #elif GMP_NUMB_BITS == 8
2263 const mp_limb_t mpfr_l2b_61_0__tab[] = { 0x9a, 0xc8, 0xbd };
2264 #elif GMP_NUMB_BITS == 16
2265 const mp_limb_t mpfr_l2b_61_0__tab[] = { 0x9a00, 0xbdc8 };
2266 #elif GMP_NUMB_BITS == 32
2267 const mp_limb_t mpfr_l2b_61_0__tab[] = { 0xbdc89a00 };
2268 #elif GMP_NUMB_BITS == 64
2269 const mp_limb_t mpfr_l2b_61_0__tab[] = { UINT64_C(0xbdc89a0000000000) };
2270 #elif GMP_NUMB_BITS == 96
2271 const mp_limb_t mpfr_l2b_61_0__tab[] = { 0xbdc89a000000000000000000 };
2272 #elif GMP_NUMB_BITS == 128
2273 const mp_limb_t mpfr_l2b_61_0__tab[] = { 0xbdc89a00000000000000000000000000 };
2274 #elif GMP_NUMB_BITS == 256
2275 const mp_limb_t mpfr_l2b_61_0__tab[] = { 0xbdc89a0000000000000000000000000000000000000000000000000000000000 };
2276 #endif
2277
2278 #if 0
2279 #elif GMP_NUMB_BITS == 8
2280 const mp_limb_t mpfr_l2b_61_1__tab[] = { 0xf8, 0x4d, 0x57, 0x77, 0xcb, 0x31, 0x82, 0xe9, 0xa8, 0xac };
2281 #elif GMP_NUMB_BITS == 16
2282 const mp_limb_t mpfr_l2b_61_1__tab[] = { 0x4df8, 0x7757, 0x31cb, 0xe982, 0xaca8 };
2283 #elif GMP_NUMB_BITS == 32
2284 const mp_limb_t mpfr_l2b_61_1__tab[] = { 0x4df80000, 0x31cb7757, 0xaca8e982 };
2285 #elif GMP_NUMB_BITS == 64
2286 const mp_limb_t mpfr_l2b_61_1__tab[] = { UINT64_C(0x4df8000000000000), UINT64_C(0xaca8e98231cb7757) };
2287 #elif GMP_NUMB_BITS == 96
2288 const mp_limb_t mpfr_l2b_61_1__tab[] = { 0xaca8e98231cb77574df80000 };
2289 #elif GMP_NUMB_BITS == 128
2290 const mp_limb_t mpfr_l2b_61_1__tab[] = { 0xaca8e98231cb77574df8000000000000 };
2291 #elif GMP_NUMB_BITS == 256
2292 const mp_limb_t mpfr_l2b_61_1__tab[] = { 0xaca8e98231cb77574df800000000000000000000000000000000000000000000 };
2293 #endif
2294
2295 #if 0
2296 #elif GMP_NUMB_BITS == 8
2297 const mp_limb_t mpfr_l2b_62_0__tab[] = { 0xc8, 0x88, 0xbe };
2298 #elif GMP_NUMB_BITS == 16
2299 const mp_limb_t mpfr_l2b_62_0__tab[] = { 0xc800, 0xbe88 };
2300 #elif GMP_NUMB_BITS == 32
2301 const mp_limb_t mpfr_l2b_62_0__tab[] = { 0xbe88c800 };
2302 #elif GMP_NUMB_BITS == 64
2303 const mp_limb_t mpfr_l2b_62_0__tab[] = { UINT64_C(0xbe88c80000000000) };
2304 #elif GMP_NUMB_BITS == 96
2305 const mp_limb_t mpfr_l2b_62_0__tab[] = { 0xbe88c8000000000000000000 };
2306 #elif GMP_NUMB_BITS == 128
2307 const mp_limb_t mpfr_l2b_62_0__tab[] = { 0xbe88c800000000000000000000000000 };
2308 #elif GMP_NUMB_BITS == 256
2309 const mp_limb_t mpfr_l2b_62_0__tab[] = { 0xbe88c80000000000000000000000000000000000000000000000000000000000 };
2310 #endif
2311
2312 #if 0
2313 #elif GMP_NUMB_BITS == 8
2314 const mp_limb_t mpfr_l2b_62_1__tab[] = { 0xf8, 0x74, 0x05, 0xf9, 0x31, 0x18, 0xc4, 0xc3, 0xfa, 0xab };
2315 #elif GMP_NUMB_BITS == 16
2316 const mp_limb_t mpfr_l2b_62_1__tab[] = { 0x74f8, 0xf905, 0x1831, 0xc3c4, 0xabfa };
2317 #elif GMP_NUMB_BITS == 32
2318 const mp_limb_t mpfr_l2b_62_1__tab[] = { 0x74f80000, 0x1831f905, 0xabfac3c4 };
2319 #elif GMP_NUMB_BITS == 64
2320 const mp_limb_t mpfr_l2b_62_1__tab[] = { UINT64_C(0x74f8000000000000), UINT64_C(0xabfac3c41831f905) };
2321 #elif GMP_NUMB_BITS == 96
2322 const mp_limb_t mpfr_l2b_62_1__tab[] = { 0xabfac3c41831f90574f80000 };
2323 #elif GMP_NUMB_BITS == 128
2324 const mp_limb_t mpfr_l2b_62_1__tab[] = { 0xabfac3c41831f90574f8000000000000 };
2325 #elif GMP_NUMB_BITS == 256
2326 const mp_limb_t mpfr_l2b_62_1__tab[] = { 0xabfac3c41831f90574f800000000000000000000000000000000000000000000 };
2327 #endif
2328
2329 const __mpfr_struct __gmpfr_l2b[BASE_MAX-1][2] = {
2330 { { 23, 1, 1, (mp_limb_t *) mpfr_l2b_2_0__tab },
2331 { 77, 1, 1, (mp_limb_t *) mpfr_l2b_2_1__tab } },
2332 { { 23, 1, 1, (mp_limb_t *) mpfr_l2b_3_0__tab },
2333 { 77, 1, 0, (mp_limb_t *) mpfr_l2b_3_1__tab } },
2334 { { 23, 1, 2, (mp_limb_t *) mpfr_l2b_4_0__tab },
2335 { 77, 1, 0, (mp_limb_t *) mpfr_l2b_4_1__tab } },
2336 { { 23, 1, 2, (mp_limb_t *) mpfr_l2b_5_0__tab },
2337 { 77, 1, -1, (mp_limb_t *) mpfr_l2b_5_1__tab } },
2338 { { 23, 1, 2, (mp_limb_t *) mpfr_l2b_6_0__tab },
2339 { 77, 1, -1, (mp_limb_t *) mpfr_l2b_6_1__tab } },
2340 { { 23, 1, 2, (mp_limb_t *) mpfr_l2b_7_0__tab },
2341 { 77, 1, -1, (mp_limb_t *) mpfr_l2b_7_1__tab } },
2342 { { 23, 1, 2, (mp_limb_t *) mpfr_l2b_8_0__tab },
2343 { 77, 1, -1, (mp_limb_t *) mpfr_l2b_8_1__tab } },
2344 { { 23, 1, 2, (mp_limb_t *) mpfr_l2b_9_0__tab },
2345 { 77, 1, -1, (mp_limb_t *) mpfr_l2b_9_1__tab } },
2346 { { 23, 1, 2, (mp_limb_t *) mpfr_l2b_10_0__tab },
2347 { 77, 1, -1, (mp_limb_t *) mpfr_l2b_10_1__tab } },
2348 { { 23, 1, 2, (mp_limb_t *) mpfr_l2b_11_0__tab },
2349 { 77, 1, -1, (mp_limb_t *) mpfr_l2b_11_1__tab } },
2350 { { 23, 1, 2, (mp_limb_t *) mpfr_l2b_12_0__tab },
2351 { 77, 1, -1, (mp_limb_t *) mpfr_l2b_12_1__tab } },
2352 { { 23, 1, 2, (mp_limb_t *) mpfr_l2b_13_0__tab },
2353 { 77, 1, -1, (mp_limb_t *) mpfr_l2b_13_1__tab } },
2354 { { 23, 1, 2, (mp_limb_t *) mpfr_l2b_14_0__tab },
2355 { 77, 1, -1, (mp_limb_t *) mpfr_l2b_14_1__tab } },
2356 { { 23, 1, 2, (mp_limb_t *) mpfr_l2b_15_0__tab },
2357 { 77, 1, -1, (mp_limb_t *) mpfr_l2b_15_1__tab } },
2358 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_16_0__tab },
2359 { 77, 1, -1, (mp_limb_t *) mpfr_l2b_16_1__tab } },
2360 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_17_0__tab },
2361 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_17_1__tab } },
2362 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_18_0__tab },
2363 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_18_1__tab } },
2364 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_19_0__tab },
2365 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_19_1__tab } },
2366 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_20_0__tab },
2367 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_20_1__tab } },
2368 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_21_0__tab },
2369 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_21_1__tab } },
2370 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_22_0__tab },
2371 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_22_1__tab } },
2372 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_23_0__tab },
2373 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_23_1__tab } },
2374 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_24_0__tab },
2375 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_24_1__tab } },
2376 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_25_0__tab },
2377 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_25_1__tab } },
2378 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_26_0__tab },
2379 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_26_1__tab } },
2380 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_27_0__tab },
2381 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_27_1__tab } },
2382 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_28_0__tab },
2383 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_28_1__tab } },
2384 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_29_0__tab },
2385 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_29_1__tab } },
2386 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_30_0__tab },
2387 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_30_1__tab } },
2388 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_31_0__tab },
2389 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_31_1__tab } },
2390 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_32_0__tab },
2391 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_32_1__tab } },
2392 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_33_0__tab },
2393 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_33_1__tab } },
2394 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_34_0__tab },
2395 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_34_1__tab } },
2396 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_35_0__tab },
2397 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_35_1__tab } },
2398 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_36_0__tab },
2399 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_36_1__tab } },
2400 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_37_0__tab },
2401 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_37_1__tab } },
2402 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_38_0__tab },
2403 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_38_1__tab } },
2404 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_39_0__tab },
2405 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_39_1__tab } },
2406 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_40_0__tab },
2407 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_40_1__tab } },
2408 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_41_0__tab },
2409 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_41_1__tab } },
2410 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_42_0__tab },
2411 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_42_1__tab } },
2412 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_43_0__tab },
2413 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_43_1__tab } },
2414 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_44_0__tab },
2415 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_44_1__tab } },
2416 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_45_0__tab },
2417 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_45_1__tab } },
2418 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_46_0__tab },
2419 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_46_1__tab } },
2420 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_47_0__tab },
2421 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_47_1__tab } },
2422 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_48_0__tab },
2423 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_48_1__tab } },
2424 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_49_0__tab },
2425 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_49_1__tab } },
2426 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_50_0__tab },
2427 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_50_1__tab } },
2428 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_51_0__tab },
2429 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_51_1__tab } },
2430 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_52_0__tab },
2431 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_52_1__tab } },
2432 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_53_0__tab },
2433 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_53_1__tab } },
2434 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_54_0__tab },
2435 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_54_1__tab } },
2436 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_55_0__tab },
2437 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_55_1__tab } },
2438 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_56_0__tab },
2439 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_56_1__tab } },
2440 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_57_0__tab },
2441 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_57_1__tab } },
2442 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_58_0__tab },
2443 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_58_1__tab } },
2444 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_59_0__tab },
2445 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_59_1__tab } },
2446 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_60_0__tab },
2447 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_60_1__tab } },
2448 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_61_0__tab },
2449 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_61_1__tab } },
2450 { { 23, 1, 3, (mp_limb_t *) mpfr_l2b_62_0__tab },
2451 { 77, 1, -2, (mp_limb_t *) mpfr_l2b_62_1__tab } } };
2452
2453 /***************************************************************************/
2454
2455 /* returns ceil(e * log2(b)^((-1)^i)), or ... + 1.
2456 For i=0, uses a 23-bit upper approximation to log(beta)/log(2).
2457 For i=1, uses a 77-bit upper approximation to log(2)/log(beta).
2458 Note: this function should be called only in the extended exponent range.
2459 */
2460 mpfr_exp_t
2461 mpfr_ceil_mul (mpfr_exp_t e, int beta, int i)
2462 {
2463 mpfr_srcptr p;
2464 mpfr_t t;
2465 mpfr_exp_t r;
2466 mp_limb_t tmpmant[MPFR_EXP_LIMB_SIZE];
2467
2468 p = &__gmpfr_l2b[beta-2][i];
2469 MPFR_TMP_INIT1(tmpmant, t, sizeof (mpfr_exp_t) * CHAR_BIT - 1);
2470 mpfr_set_exp_t (t, e, MPFR_RNDU);
2471 mpfr_mul (t, t, p, MPFR_RNDU);
2472 r = mpfr_get_exp_t (t, MPFR_RNDU);
2473 return r;
2474 }
2475
2476 /* take at least 1 + ceil(p*log(2)/log(b)) digits, where p is the
2477 number of bits of the mantissa, to ensure back conversion from
2478 the output gives the same floating-point.
2479
2480 Warning: if b = 2^k, this may be too large. The worst case is when
2481 the first base-b digit contains only one bit, so we take
2482 1 + ceil((p-1)/k) instead.
2483 */
2484 size_t
2485 mpfr_get_str_ndigits (int b, mpfr_prec_t p)
2486 {
2487 size_t ret;
2488 MPFR_SAVE_EXPO_DECL (expo);
2489
2490 MPFR_ASSERTN (2 <= b && b <= 62);
2491
2492 /* deal first with power of two bases, since even for those, mpfr_ceil_mul
2493 might return a value too large by 1 */
2494 if (IS_POW2(b)) /* 1 + ceil((p-1)/k) = 2 + floor((p-2)/k) */
2495 {
2496 int k;
2497
2498 count_leading_zeros (k, (mp_limb_t) b);
2499 k = GMP_NUMB_BITS - k - 1; /* now b = 2^k */
2500 return 1 + (p + k - 2) / k;
2501 }
2502
2503 MPFR_SAVE_EXPO_MARK (expo);
2504
2505 /* the value returned by mpfr_ceil_mul is guaranteed to be
2506 1 + ceil(p*log(2)/log(b)) for p < 186564318007 (it returns one more
2507 for p=186564318007 and b=7 or 49) */
2508 MPFR_STAT_STATIC_ASSERT (MPFR_PREC_BITS >= 64 || MPFR_PREC_BITS <= 32);
2509 if (
2510 #if MPFR_PREC_BITS >= 64
2511 /* 64-bit numbers are supported by the C implementation, so that we can
2512 use the large constant below. */
2513 MPFR_LIKELY (p < 186564318007)
2514 #else
2515 /* Since MPFR_PREC_BITS <= 32, the above condition is always satisfied,
2516 so that we do not need any test on p. */
2517 1
2518 #endif
2519 )
2520 ret = mpfr_ceil_mul (IS_POW2(b) ? p - 1 : p, b, 1);
2521 else
2522 {
2523 /* p is large and b is not a power of two. The code below works
2524 for any value of p and b, as long as b is not a power of two.
2525 Indeed, in such a case, p*log(2)/log(b) cannot be exactly an
2526 integer, and thus Ziv's loop will terminate. */
2527 mpfr_prec_t w = 77; /* mpfr_ceil_mul used a 77-bit upper approximation
2528 to log(2)/log(b) */
2529
2530 ret = 0;
2531 while (ret == 0)
2532 {
2533 mpfr_t d, u;
2534
2535 w = 2 * w;
2536 mpfr_init2 (d, w); /* lower approximation */
2537 mpfr_init2 (u, w); /* upper approximation */
2538 mpfr_set_ui (d, b, MPFR_RNDU);
2539 mpfr_set_ui (u, b, MPFR_RNDD);
2540 mpfr_log2 (d, d, MPFR_RNDU);
2541 mpfr_log2 (u, u, MPFR_RNDD);
2542 /* The code below requires that the precision p fit in
2543 an unsigned long, which we currently guarantee (see
2544 _MPFR_PREC_FORMAT). */
2545 MPFR_STAT_STATIC_ASSERT (MPFR_PREC_MAX <= ULONG_MAX);
2546 /* u <= log(b)/log(2) <= d (***) */
2547 mpfr_ui_div (d, p, d, MPFR_RNDD);
2548 mpfr_ui_div (u, p, u, MPFR_RNDU);
2549 /* d <= p*log(2)/log(b) <= u */
2550 mpfr_ceil (d, d);
2551 mpfr_ceil (u, u);
2552 if (mpfr_equal_p (d, u))
2553 {
2554 ret = mpfr_get_ui (d, MPFR_RNDU);
2555 MPFR_ASSERTD (ret != 0);
2556 }
2557 mpfr_clear (d);
2558 mpfr_clear (u);
2559 }
2560 }
2561
2562 MPFR_SAVE_EXPO_FREE (expo);
2563 return 1 + ret;
2564 }
2565
2566 /* prints the mantissa of x in the string s, and writes the corresponding
2567 exponent in e.
2568 x is rounded with direction rnd, m is the number of digits of the mantissa,
2569 |b| is the given base (2 <= b <= 62 or -36 <= b <= -2).
2570 This follows GMP's mpf_get_str specification.
2571
2572 Return value:
2573 if s=NULL, allocates a string to store the mantissa, with
2574 m characters, plus a final '\0', plus a possible minus sign
2575 (thus m+1 or m+2 characters).
2576
2577 Important: when you call this function with s=NULL, don't forget to free
2578 the memory space allocated, with mpfr_free_str.
2579 */
2580 char *
2581 mpfr_get_str (char *s, mpfr_exp_t *e, int b, size_t m, mpfr_srcptr x,
2582 mpfr_rnd_t rnd)
2583 {
2584 const char *num_to_text;
2585 int exact; /* exact result */
2586 mpfr_exp_t exp, g;
2587 mpfr_exp_t prec; /* precision of the computation */
2588 long err;
2589 mp_limb_t *a;
2590 mpfr_exp_t exp_a;
2591 mp_limb_t *result;
2592 mp_limb_t *xp;
2593 mp_limb_t *reste;
2594 size_t nx, nx1;
2595 size_t n, i;
2596 char *s0;
2597 int neg;
2598 int ret; /* return value of mpfr_get_str_aux */
2599 int b0 = b; /* initial base argument, might be negative */
2600 MPFR_ZIV_DECL (loop);
2601 MPFR_SAVE_EXPO_DECL (expo);
2602 MPFR_TMP_DECL (marker);
2603
2604 /* if exact = 1 then err is undefined */
2605 /* otherwise err is such that |x*b^(m-g)-a*2^exp_a| < 2^(err+exp_a) */
2606
2607 MPFR_LOG_FUNC
2608 (("b=%d m=%zu x[%Pd]=%.*Rg rnd=%d",
2609 b, m, mpfr_get_prec (x), mpfr_log_prec, x, rnd),
2610 ("flags=%lx", (unsigned long) __gmpfr_flags));
2611
2612 /* Is the base argument valid? Valid values are -36 to -2 and 2 to 62. */
2613 if (b < -36 || (-2 < b && b < 2) || 62 < b)
2614 return NULL;
2615
2616 num_to_text = (2 <= b && b <= 36) ? num_to_text36 : num_to_text62;
2617
2618 b = (b > 0) ? b : -b;
2619
2620 /* now b is positive */
2621
2622 /* map RNDF to RNDN, to avoid problems with specification of mpfr_can_round
2623 or mpfr_can_round_raw */
2624 if (rnd == MPFR_RNDF)
2625 rnd = MPFR_RNDN;
2626
2627 if (MPFR_UNLIKELY (MPFR_IS_NAN (x)))
2628 {
2629 if (s == NULL)
2630 s = (char *) mpfr_allocate_func (6);
2631 strcpy (s, "@NaN@");
2632 MPFR_LOG_MSG (("%s\n", s));
2633 __gmpfr_flags |= MPFR_FLAGS_NAN;
2634 return s;
2635 }
2636
2637 neg = MPFR_IS_NEG (x); /* 0 if positive, 1 if negative */
2638
2639 if (MPFR_UNLIKELY (MPFR_IS_INF (x)))
2640 {
2641 if (s == NULL)
2642 s = (char *) mpfr_allocate_func (neg + 6);
2643 strcpy (s, (neg) ? "-@Inf@" : "@Inf@");
2644 MPFR_LOG_MSG (("%s\n", s));
2645 return s;
2646 }
2647
2648 MPFR_SAVE_EXPO_MARK (expo); /* needed for mpfr_ceil_mul (at least) */
2649
2650 if (m == 0)
2651 m = mpfr_get_str_ndigits (b, MPFR_PREC(x));
2652
2653 MPFR_LOG_MSG (("m=%zu\n", m));
2654
2655 /* The code below works for m=1, both for power-of-two and non-power-of-two
2656 bases; this is important for the internal use of mpfr_get_str. */
2657
2658 /* x is a floating-point number */
2659
2660 if (s == NULL)
2661 s = (char *) mpfr_allocate_func (neg + m + 1);
2662 s0 = s;
2663 if (neg)
2664 *s++ = '-';
2665
2666 if (MPFR_IS_ZERO (x))
2667 {
2668 memset (s, '0', m);
2669 s[m] = '\0';
2670 *e = 0; /* a bit like frexp() in ISO C99 */
2671 MPFR_SAVE_EXPO_FREE (expo);
2672 return s0; /* strlen(s0) = neg + m */
2673 }
2674
2675 xp = MPFR_MANT (x);
2676
2677 if (IS_POW2 (b))
2678 {
2679 int pow2;
2680 mpfr_exp_t f, r;
2681 mp_limb_t *x1;
2682 mp_size_t nb;
2683 int inexp;
2684
2685 count_leading_zeros (pow2, (mp_limb_t) b);
2686 pow2 = GMP_NUMB_BITS - pow2 - 1; /* b = 2^pow2 */
2687
2688 /* set MPFR_EXP(x) = f*pow2 + r, 1 <= r <= pow2 */
2689 f = (MPFR_GET_EXP (x) - 1) / pow2;
2690 r = MPFR_GET_EXP (x) - f * pow2;
2691 if (r <= 0)
2692 {
2693 f --;
2694 r += pow2;
2695 }
2696
2697 /* the first digit will contain only r bits */
2698 prec = (m - 1) * pow2 + r; /* total number of bits */
2699 /* if m=1 then 1 <= prec <= pow2, and since prec=1 is now valid in MPFR,
2700 the power-of-two code also works for m=1 */
2701 n = MPFR_PREC2LIMBS (prec);
2702
2703 MPFR_TMP_MARK (marker);
2704 x1 = MPFR_TMP_LIMBS_ALLOC (n + 1);
2705 nb = n * GMP_NUMB_BITS - prec;
2706 /* round xp to the precision prec, and put it into x1
2707 put the carry into x1[n] */
2708 if ((x1[n] = mpfr_round_raw (x1, xp, MPFR_PREC(x),
2709 MPFR_IS_STRICTNEG(x),
2710 prec, rnd, &inexp)))
2711 {
2712 /* overflow when rounding x: x1 = 2^prec */
2713 if (r == pow2) /* prec = m * pow2,
2714 2^prec will need (m+1) digits in base 2^pow2 */
2715 {
2716 /* divide x1 by 2^pow2, and increase the exponent */
2717 mpn_rshift (x1, x1, n + 1, pow2);
2718 f ++;
2719 }
2720 else /* 2^prec needs still m digits, but x1 may need n+1 limbs */
2721 n ++;
2722 }
2723
2724 /* it remains to shift x1 by nb limbs to the right, since mpn_get_str
2725 expects a right-normalized number */
2726 if (nb != 0)
2727 {
2728 mpn_rshift (x1, x1, n, nb);
2729 /* the most significant word may be zero */
2730 if (x1[n - 1] == 0)
2731 n --;
2732 }
2733
2734 mpn_get_str ((unsigned char *) s, b, x1, n);
2735 for (i = 0; i < m; i++)
2736 s[i] = num_to_text[(int) s[i]];
2737 s[m] = 0;
2738
2739 /* the exponent of s is f + 1 */
2740 *e = f + 1;
2741
2742 MPFR_LOG_MSG (("e=%" MPFR_EXP_FSPEC "d\n", (mpfr_eexp_t) *e));
2743
2744 MPFR_TMP_FREE (marker);
2745 MPFR_SAVE_EXPO_FREE (expo);
2746 return s0;
2747 }
2748
2749 /* if x < 0, reduce to x > 0 */
2750 if (neg)
2751 rnd = MPFR_INVERT_RND (rnd);
2752
2753 g = mpfr_ceil_mul (MPFR_GET_EXP (x) - 1, b, 1);
2754 exact = 1;
2755 /* prec is the radix-2 precision necessary to get m digits in radix b */
2756 prec = mpfr_ceil_mul (m, b, 0) + 1;
2757 exp = ((mpfr_exp_t) m < g) ? g - (mpfr_exp_t) m : (mpfr_exp_t) m - g;
2758 prec += MPFR_INT_CEIL_LOG2 (prec); /* number of guard bits */
2759 if (exp != 0) /* add maximal exponentiation error */
2760 prec += 3 * (mpfr_exp_t) MPFR_INT_CEIL_LOG2 (exp);
2761
2762 MPFR_ZIV_INIT (loop, prec);
2763 for (;;)
2764 {
2765 MPFR_TMP_MARK (marker);
2766
2767 exact = 1;
2768
2769 /* number of limbs */
2770 n = MPFR_PREC2LIMBS (prec);
2771
2772 /* a will contain the approximation of the mantissa */
2773 a = MPFR_TMP_LIMBS_ALLOC (n);
2774
2775 nx = MPFR_LIMB_SIZE (x);
2776
2777 if ((mpfr_exp_t) m == g) /* final exponent is 0, no multiplication or
2778 division to perform */
2779 {
2780 if (nx > n)
2781 exact = mpn_scan1 (xp, 0) >= (nx - n) * GMP_NUMB_BITS;
2782 err = !exact;
2783 MPN_COPY2 (a, n, xp, nx);
2784 exp_a = MPFR_GET_EXP (x) - n * GMP_NUMB_BITS;
2785 }
2786 else if ((mpfr_exp_t) m > g) /* we have to multiply x by b^exp */
2787 {
2788 mp_limb_t *x1;
2789
2790 /* a2*2^exp_a = b^e */
2791 err = mpfr_mpn_exp (a, &exp_a, b, exp, n);
2792 /* here, the error on a is at most 2^err ulps */
2793 exact = (err == -1);
2794
2795 /* x = x1*2^(n*GMP_NUMB_BITS) */
2796 x1 = (nx >= n) ? xp + nx - n : xp;
2797 nx1 = (nx >= n) ? n : nx; /* nx1 = min(n, nx) */
2798
2799 /* test if exact */
2800 if (nx > n)
2801 exact = (exact &&
2802 ((mpn_scan1 (xp, 0) >= (nx - n) * GMP_NUMB_BITS)));
2803
2804 /* we loose one more bit in the multiplication,
2805 except when err=0 where we loose two bits */
2806 err = (err <= 0) ? 2 : err + 1;
2807
2808 /* result = a * x */
2809 result = MPFR_TMP_LIMBS_ALLOC (n + nx1);
2810 mpn_mul (result, a, n, x1, nx1);
2811 exp_a += MPFR_GET_EXP (x);
2812 if (mpn_scan1 (result, 0) < (nx1 * GMP_NUMB_BITS))
2813 exact = 0;
2814
2815 /* normalize a and truncate */
2816 if ((result[n + nx1 - 1] & MPFR_LIMB_HIGHBIT) == 0)
2817 {
2818 mpn_lshift (a, result + nx1, n, 1);
2819 a[0] |= result[nx1 - 1] >> (GMP_NUMB_BITS - 1);
2820 exp_a --;
2821 }
2822 else
2823 MPN_COPY (a, result + nx1, n);
2824 }
2825 else /* m < g: divide by b^exp */
2826 {
2827 mp_limb_t *x1;
2828
2829 /* a2*2^exp_a = b^e */
2830 err = mpfr_mpn_exp (a, &exp_a, b, exp, n);
2831 exact = (err == -1);
2832
2833 /* allocate memory for x1, result and reste */
2834 result = MPFR_TMP_LIMBS_ALLOC (n + 1);
2835 reste = MPFR_TMP_LIMBS_ALLOC (n);
2836
2837 if (2 * n <= nx)
2838 {
2839 x1 = xp + nx - 2 * n;
2840 /* we ignored the low nx - 2 * n limbs from x */
2841 if (exact && mpn_scan1 (xp, 0) < (nx - 2 * n) * GMP_NUMB_BITS)
2842 exact = 0;
2843 }
2844 else
2845 {
2846 /* copy the nx most significant limbs of x into those of x1 */
2847 x1 = MPFR_TMP_LIMBS_ALLOC (2 * n);
2848 MPN_ZERO (x1, 2 * n - nx);
2849 MPN_COPY (x1 + 2 * n - nx, xp, nx);
2850 }
2851
2852 /* result = x / a */
2853 mpn_tdiv_qr (result, reste, 0, x1, 2 * n, a, n);
2854 exp_a = MPFR_GET_EXP (x) - exp_a - 2 * n * GMP_NUMB_BITS;
2855
2856 /* test if division was exact */
2857 if (exact)
2858 exact = mpn_popcount (reste, n) == 0;
2859
2860 /* normalize the result and copy into a */
2861 if (result[n] == 1)
2862 {
2863 mpn_rshift (a, result, n, 1);
2864 a[n - 1] |= MPFR_LIMB_HIGHBIT;;
2865 exp_a ++;
2866 }
2867 else
2868 MPN_COPY (a, result, n);
2869
2870 err = (err == -1) ? 2 : err + 2;
2871 }
2872
2873 /* check if rounding is possible */
2874 if (exact)
2875 err = -1;
2876
2877 ret = mpfr_get_str_aux (s, e, a, n, exp_a, err, b0, m, rnd);
2878
2879 MPFR_TMP_FREE (marker);
2880
2881 if (ret == MPFR_ROUND_FAILED)
2882 {
2883 /* too large error: increment the working precision */
2884 MPFR_ZIV_NEXT (loop, prec);
2885 }
2886 else if (ret == - MPFR_ROUND_FAILED)
2887 {
2888 /* too many digits in mantissa: exp = |m-g| */
2889 if ((mpfr_exp_t) m > g) /* exp = m - g, multiply by b^exp */
2890 {
2891 g ++;
2892 exp --;
2893 }
2894 else /* exp = g - m, divide by b^exp */
2895 {
2896 g ++;
2897 exp ++;
2898 }
2899 }
2900 else
2901 {
2902 if (ret != 0)
2903 MPFR_SAVE_EXPO_UPDATE_FLAGS (expo, MPFR_FLAGS_INEXACT);
2904 break;
2905 }
2906 }
2907 MPFR_ZIV_FREE (loop);
2908
2909 *e += g;
2910
2911 MPFR_LOG_MSG (("e=%" MPFR_EXP_FSPEC "d\n", (mpfr_eexp_t) *e));
2912
2913 MPFR_SAVE_EXPO_FREE (expo);
2914 return s0;
2915 }
2916
2917 void mpfr_free_str (char *str)
2918 {
2919 mpfr_free_func (str, strlen (str) + 1);
2920 }