w32tex
About: TeX Live provides a comprehensive TeX system including all the major TeX-related programs, macro packages, and fonts that are free software. Windows sources.
  Fossies Dox: w32tex-src.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

get_str.c
Go to the documentation of this file.
1 /* mpfr_get_str -- output a floating-point number to a string
2 
3 Copyright 1999-2020 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,
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);
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 */
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 */
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 
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
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);
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
2486 {
2487  MPFR_ASSERTN (2 <= b && b <= 62);
2488 
2489  /* deal first with power of two bases, since even for those, mpfr_ceil_mul
2490  might return a value too large by 1 */
2491  if (IS_POW2(b)) /* 1 + ceil((p-1)/k) = 2 + floor((p-2)/k) */
2492  {
2493  int k;
2494 
2496  k = GMP_NUMB_BITS - k - 1; /* now b = 2^k */
2497  return 1 + (p + k - 2) / k;
2498  }
2499 
2500  /* the value returned by mpfr_ceil_mul is guaranteed to be
2501  1 + ceil(p*log(2)/log(b)) for p < 186564318007 (it returns one more
2502  for p=186564318007 and b=7 or 49) */
2504 #if MPFR_PREC_BITS >= 64
2505  /* 64-bit numbers are supported by the C implementation, so that we can
2506  use the large constant below. If MPFR_PREC_BITS <= 32, the condition
2507  is always satisfied, so that we do not need any test. */
2508  if (MPFR_LIKELY (p < 186564318007))
2509 #endif
2510  return 1 + mpfr_ceil_mul (IS_POW2(b) ? p - 1 : p, b, 1);
2511 
2512  /* Now p is large and b is not a power of two. The code below works for any
2513  value of p and b, as long as b is not a power of two. Indeed, in such a
2514  case, p*log(2)/log(b) cannot be exactly an integer, and thus Ziv's loop
2515  will terminate. */
2516  {
2517  mpfr_prec_t w = 77; /* mpfr_ceil_mul used a 77-bit upper approximation of
2518  log(2)/log(b) */
2519  mpfr_t d, u;
2520  size_t ret = 0;
2521  while (ret == 0)
2522  {
2523  w = 2 * w;
2524  mpfr_init2 (d, w); /* lower approximation */
2525  mpfr_init2 (u, w); /* upper approximation */
2526  mpfr_set_ui (d, b, MPFR_RNDU);
2527  mpfr_set_ui (u, b, MPFR_RNDD);
2528  mpfr_log2 (d, d, MPFR_RNDU);
2529  mpfr_log2 (u, u, MPFR_RNDD);
2530  /* The code below requires that the precision fit in an unsigned long,
2531  which we currently guarantee (see _MPFR_PREC_FORMAT). */
2533  /* u <= log(b)/log(2) <= d (***) */
2534  mpfr_ui_div (d, p, d, MPFR_RNDD);
2535  mpfr_ui_div (u, p, u, MPFR_RNDU);
2536  /* d <= p*log(2)/log(b) <= u */
2537  mpfr_ceil (d, d);
2538  mpfr_ceil (u, u);
2539  if (mpfr_cmp (d, u) == 0)
2540  ret = mpfr_get_ui (d, MPFR_RNDU);
2541  mpfr_clear (d);
2542  mpfr_clear (u);
2543  }
2544  return 1 + ret;
2545  }
2546 }
2547 
2548 /* prints the mantissa of x in the string s, and writes the corresponding
2549  exponent in e.
2550  x is rounded with direction rnd, m is the number of digits of the mantissa,
2551  |b| is the given base (2 <= b <= 62 or -36 <= b <= -2).
2552  This follows GMP's mpf_get_str specification.
2553 
2554  Return value:
2555  if s=NULL, allocates a string to store the mantissa, with
2556  m characters, plus a final '\0', plus a possible minus sign
2557  (thus m+1 or m+2 characters).
2558 
2559  Important: when you call this function with s=NULL, don't forget to free
2560  the memory space allocated, with mpfr_free_str.
2561 */
2562 char *
2563 mpfr_get_str (char *s, mpfr_exp_t *e, int b, size_t m, mpfr_srcptr x,
2564  mpfr_rnd_t rnd)
2565 {
2566  const char *num_to_text;
2567  int exact; /* exact result */
2568  mpfr_exp_t exp, g;
2569  mpfr_exp_t prec; /* precision of the computation */
2570  long err;
2571  mp_limb_t *a;
2572  mpfr_exp_t exp_a;
2573  mp_limb_t *result;
2574  mp_limb_t *xp;
2575  mp_limb_t *reste;
2576  size_t nx, nx1;
2577  size_t n, i;
2578  char *s0;
2579  int neg;
2580  int ret; /* return value of mpfr_get_str_aux */
2581  int b0 = b; /* initial base argument, might be negative */
2582  MPFR_ZIV_DECL (loop);
2583  MPFR_SAVE_EXPO_DECL (expo);
2584  MPFR_TMP_DECL (marker);
2585 
2586  /* if exact = 1 then err is undefined */
2587  /* otherwise err is such that |x*b^(m-g)-a*2^exp_a| < 2^(err+exp_a) */
2588 
2590  (("b=%d m=%zu x[%Pu]=%.*Rg rnd=%d",
2591  b, m, mpfr_get_prec (x), mpfr_log_prec, x, rnd),
2592  ("flags=%lx", (unsigned long) __gmpfr_flags));
2593 
2594  /* Is the base argument valid? Valid values are -36 to -2 and 2 to 62. */
2595  if (b < -36 || (-2 < b && b < 2) || 62 < b)
2596  return NULL;
2597 
2598  num_to_text = (2 <= b && b <= 36) ? num_to_text36 : num_to_text62;
2599 
2600  b = (b > 0) ? b : -b;
2601 
2602  /* now b is positive */
2603 
2604  /* map RNDF to RNDN, to avoid problems with specification of mpfr_can_round
2605  or mpfr_can_round_raw */
2606  if (rnd == MPFR_RNDF)
2607  rnd = MPFR_RNDN;
2608 
2609  if (MPFR_UNLIKELY (MPFR_IS_NAN (x)))
2610  {
2611  if (s == NULL)
2612  s = (char *) mpfr_allocate_func (6);
2613  strcpy (s, "@NaN@");
2614  MPFR_LOG_MSG (("%s\n", s));
2616  return s;
2617  }
2618 
2619  neg = MPFR_IS_NEG (x); /* 0 if positive, 1 if negative */
2620 
2621  if (MPFR_UNLIKELY (MPFR_IS_INF (x)))
2622  {
2623  if (s == NULL)
2624  s = (char *) mpfr_allocate_func (neg + 6);
2625  strcpy (s, (neg) ? "-@Inf@" : "@Inf@");
2626  MPFR_LOG_MSG (("%s\n", s));
2627  return s;
2628  }
2629 
2630  MPFR_SAVE_EXPO_MARK (expo); /* needed for mpfr_ceil_mul (at least) */
2631 
2632  if (m == 0)
2634 
2635  MPFR_LOG_MSG (("m=%zu\n", m));
2636 
2637  /* The code below works for m=1, both for power-of-two and non-power-of-two
2638  bases; this is important for the internal use of mpfr_get_str. */
2639 
2640  /* x is a floating-point number */
2641 
2642  if (s == NULL)
2643  s = (char *) mpfr_allocate_func (neg + m + 1);
2644  s0 = s;
2645  if (neg)
2646  *s++ = '-';
2647 
2648  if (MPFR_IS_ZERO (x))
2649  {
2650  memset (s, '0', m);
2651  s[m] = '\0';
2652  *e = 0; /* a bit like frexp() in ISO C99 */
2653  MPFR_SAVE_EXPO_FREE (expo);
2654  return s0; /* strlen(s0) = neg + m */
2655  }
2656 
2657  xp = MPFR_MANT (x);
2658 
2659  if (IS_POW2 (b))
2660  {
2661  int pow2;
2662  mpfr_exp_t f, r;
2663  mp_limb_t *x1;
2664  mp_size_t nb;
2665  int inexp;
2666 
2667  count_leading_zeros (pow2, (mp_limb_t) b);
2668  pow2 = GMP_NUMB_BITS - pow2 - 1; /* b = 2^pow2 */
2669 
2670  /* set MPFR_EXP(x) = f*pow2 + r, 1 <= r <= pow2 */
2671  f = (MPFR_GET_EXP (x) - 1) / pow2;
2672  r = MPFR_GET_EXP (x) - f * pow2;
2673  if (r <= 0)
2674  {
2675  f --;
2676  r += pow2;
2677  }
2678 
2679  /* the first digit will contain only r bits */
2680  prec = (m - 1) * pow2 + r; /* total number of bits */
2681  /* if m=1 then 1 <= prec <= pow2, and since prec=1 is now valid in MPFR,
2682  the power-of-two code also works for m=1 */
2683  n = MPFR_PREC2LIMBS (prec);
2684 
2685  MPFR_TMP_MARK (marker);
2686  x1 = MPFR_TMP_LIMBS_ALLOC (n + 1);
2687  nb = n * GMP_NUMB_BITS - prec;
2688  /* round xp to the precision prec, and put it into x1
2689  put the carry into x1[n] */
2690  if ((x1[n] = mpfr_round_raw (x1, xp, MPFR_PREC(x),
2692  prec, rnd, &inexp)))
2693  {
2694  /* overflow when rounding x: x1 = 2^prec */
2695  if (r == pow2) /* prec = m * pow2,
2696  2^prec will need (m+1) digits in base 2^pow2 */
2697  {
2698  /* divide x1 by 2^pow2, and increase the exponent */
2699  mpn_rshift (x1, x1, n + 1, pow2);
2700  f ++;
2701  }
2702  else /* 2^prec needs still m digits, but x1 may need n+1 limbs */
2703  n ++;
2704  }
2705 
2706  /* it remains to shift x1 by nb limbs to the right, since mpn_get_str
2707  expects a right-normalized number */
2708  if (nb != 0)
2709  {
2710  mpn_rshift (x1, x1, n, nb);
2711  /* the most significant word may be zero */
2712  if (x1[n - 1] == 0)
2713  n --;
2714  }
2715 
2716  mpn_get_str ((unsigned char *) s, b, x1, n);
2717  for (i = 0; i < m; i++)
2718  s[i] = num_to_text[(int) s[i]];
2719  s[m] = 0;
2720 
2721  /* the exponent of s is f + 1 */
2722  *e = f + 1;
2723 
2724  MPFR_LOG_MSG (("e=%" MPFR_EXP_FSPEC "d\n", (mpfr_eexp_t) *e));
2725 
2726  MPFR_TMP_FREE (marker);
2727  MPFR_SAVE_EXPO_FREE (expo);
2728  return s0;
2729  }
2730 
2731  /* if x < 0, reduce to x > 0 */
2732  if (neg)
2733  rnd = MPFR_INVERT_RND (rnd);
2734 
2735  g = mpfr_ceil_mul (MPFR_GET_EXP (x) - 1, b, 1);
2736  exact = 1;
2737  /* prec is the radix-2 precision necessary to get m digits in radix b */
2738  prec = mpfr_ceil_mul (m, b, 0) + 1;
2739  exp = ((mpfr_exp_t) m < g) ? g - (mpfr_exp_t) m : (mpfr_exp_t) m - g;
2740  prec += MPFR_INT_CEIL_LOG2 (prec); /* number of guard bits */
2741  if (exp != 0) /* add maximal exponentiation error */
2742  prec += 3 * (mpfr_exp_t) MPFR_INT_CEIL_LOG2 (exp);
2743 
2744  MPFR_ZIV_INIT (loop, prec);
2745  for (;;)
2746  {
2747  MPFR_TMP_MARK (marker);
2748 
2749  exact = 1;
2750 
2751  /* number of limbs */
2752  n = MPFR_PREC2LIMBS (prec);
2753 
2754  /* a will contain the approximation of the mantissa */
2755  a = MPFR_TMP_LIMBS_ALLOC (n);
2756 
2757  nx = MPFR_LIMB_SIZE (x);
2758 
2759  if ((mpfr_exp_t) m == g) /* final exponent is 0, no multiplication or
2760  division to perform */
2761  {
2762  if (nx > n)
2763  exact = mpn_scan1 (xp, 0) >= (nx - n) * GMP_NUMB_BITS;
2764  err = !exact;
2765  MPN_COPY2 (a, n, xp, nx);
2766  exp_a = MPFR_GET_EXP (x) - n * GMP_NUMB_BITS;
2767  }
2768  else if ((mpfr_exp_t) m > g) /* we have to multiply x by b^exp */
2769  {
2770  mp_limb_t *x1;
2771 
2772  /* a2*2^exp_a = b^e */
2773  err = mpfr_mpn_exp (a, &exp_a, b, exp, n);
2774  /* here, the error on a is at most 2^err ulps */
2775  exact = (err == -1);
2776 
2777  /* x = x1*2^(n*GMP_NUMB_BITS) */
2778  x1 = (nx >= n) ? xp + nx - n : xp;
2779  nx1 = (nx >= n) ? n : nx; /* nx1 = min(n, nx) */
2780 
2781  /* test if exact */
2782  if (nx > n)
2783  exact = (exact &&
2784  ((mpn_scan1 (xp, 0) >= (nx - n) * GMP_NUMB_BITS)));
2785 
2786  /* we loose one more bit in the multiplication,
2787  except when err=0 where we loose two bits */
2788  err = (err <= 0) ? 2 : err + 1;
2789 
2790  /* result = a * x */
2791  result = MPFR_TMP_LIMBS_ALLOC (n + nx1);
2792  mpn_mul (result, a, n, x1, nx1);
2793  exp_a += MPFR_GET_EXP (x);
2794  if (mpn_scan1 (result, 0) < (nx1 * GMP_NUMB_BITS))
2795  exact = 0;
2796 
2797  /* normalize a and truncate */
2798  if ((result[n + nx1 - 1] & MPFR_LIMB_HIGHBIT) == 0)
2799  {
2800  mpn_lshift (a, result + nx1, n , 1);
2801  a[0] |= result[nx1 - 1] >> (GMP_NUMB_BITS - 1);
2802  exp_a --;
2803  }
2804  else
2805  MPN_COPY (a, result + nx1, n);
2806  }
2807  else /* m < g: divide by b^exp */
2808  {
2809  mp_limb_t *x1;
2810 
2811  /* a2*2^exp_a = b^e */
2812  err = mpfr_mpn_exp (a, &exp_a, b, exp, n);
2813  exact = (err == -1);
2814 
2815  /* allocate memory for x1, result and reste */
2816  result = MPFR_TMP_LIMBS_ALLOC (n + 1);
2817  reste = MPFR_TMP_LIMBS_ALLOC (n);
2818 
2819  if (2 * n <= nx)
2820  {
2821  x1 = xp + nx - 2 * n;
2822  /* we ignored the low nx - 2 * n limbs from x */
2823  if (exact && mpn_scan1 (xp, 0) < (nx - 2 * n) * GMP_NUMB_BITS)
2824  exact = 0;
2825  }
2826  else
2827  {
2828  /* copy the nx most significant limbs of x into those of x1 */
2829  x1 = MPFR_TMP_LIMBS_ALLOC (2 * n);
2830  MPN_ZERO (x1, 2 * n - nx);
2831  MPN_COPY (x1 + 2 * n - nx, xp, nx);
2832  }
2833 
2834  /* result = x / a */
2835  mpn_tdiv_qr (result, reste, 0, x1, 2 * n, a, n);
2836  exp_a = MPFR_GET_EXP (x) - exp_a - 2 * n * GMP_NUMB_BITS;
2837 
2838  /* test if division was exact */
2839  if (exact)
2840  exact = mpn_popcount (reste, n) == 0;
2841 
2842  /* normalize the result and copy into a */
2843  if (result[n] == 1)
2844  {
2845  mpn_rshift (a, result, n, 1);
2846  a[n - 1] |= MPFR_LIMB_HIGHBIT;;
2847  exp_a ++;
2848  }
2849  else
2850  MPN_COPY (a, result, n);
2851 
2852  err = (err == -1) ? 2 : err + 2;
2853  }
2854 
2855  /* check if rounding is possible */
2856  if (exact)
2857  err = -1;
2858 
2859  ret = mpfr_get_str_aux (s, e, a, n, exp_a, err, b0, m, rnd);
2860 
2861  MPFR_TMP_FREE (marker);
2862 
2863  if (ret == MPFR_ROUND_FAILED)
2864  {
2865  /* too large error: increment the working precision */
2866  MPFR_ZIV_NEXT (loop, prec);
2867  }
2868  else if (ret == - MPFR_ROUND_FAILED)
2869  {
2870  /* too many digits in mantissa: exp = |m-g| */
2871  if ((mpfr_exp_t) m > g) /* exp = m - g, multiply by b^exp */
2872  {
2873  g ++;
2874  exp --;
2875  }
2876  else /* exp = g - m, divide by b^exp */
2877  {
2878  g ++;
2879  exp ++;
2880  }
2881  }
2882  else
2883  {
2884  if (ret != 0)
2886  break;
2887  }
2888  }
2889  MPFR_ZIV_FREE (loop);
2890 
2891  *e += g;
2892 
2893  MPFR_LOG_MSG (("e=%" MPFR_EXP_FSPEC "d\n", (mpfr_eexp_t) *e));
2894 
2895  MPFR_SAVE_EXPO_FREE (expo);
2896  return s0;
2897 }
2898 
2899 void mpfr_free_str (char *str)
2900 {
2901  mpfr_free_func (str, strlen (str) + 1);
2902 }
double __cdecl exp(double _X)
#define CHAR_BIT
Definition: ChkTeX.h:91
Definition: asl.h:63
#define n
Definition: t4ht.c:1290
#define b
Definition: jpegint.h:372
int w
Definition: dviconv.c:26
char * strcpy()
mpfr_flags_t __gmpfr_flags
Definition: exceptions.c:25
mpz_t * f
Definition: gen-fib.c:34
#define xp
#define s
Definition: afcover.h:80
#define t
Definition: afcover.h:96
#define MPN_COPY(d, s, n)
Definition: gmp-impl.h:1849
#define MPN_ZERO(dst, n)
Definition: gmp-impl.h:1919
#define mpn_popcount
Definition: gmp.h:1569
#define mpn_scan1
Definition: gmp.h:1591
#define mpn_mul
Definition: gmp.h:1543
#define mpn_rshift
Definition: gmp.h:1585
#define GMP_NUMB_BITS
Definition: gmp.h:46
long int mp_size_t
Definition: gmp.h:175
#define mpn_lshift
Definition: gmp.h:1537
#define mpn_get_str
Definition: gmp.h:1531
#define a(n)
Definition: gpos-common.c:148
#define d(n)
Definition: gpos-common.c:151
#define NULL
Definition: ftobjs.h:61
small capitals from c petite p scientific f u
Definition: afcover.h:88
small capitals from c petite p
Definition: afcover.h:72
small capitals from c petite p scientific i
Definition: afcover.h:80
#define beta
Definition: gd_nnquant.c:55
#define ULONG_MAX
Definition: c-minmax.h:66
static int ret
Definition: convert.c:72
#define b0
Definition: texmfmem.h:168
#define loop
Definition: tie.c:8
int mpfr_log2(mpfr_ptr r, mpfr_srcptr a, mpfr_rnd_t rnd_mode)
Definition: log2.c:30
#define count_leading_zeros(count, x)
Definition: longlong.h:2202
void mpfr_free_func(void *ptr, size_t size)
Definition: mpfr-gmp.c:330
void * mpfr_allocate_func(size_t alloc_size)
Definition: mpfr-gmp.c:308
#define MPFR_IS_INF(x)
Definition: mpfr-impl.h:1082
#define MPFR_LIMB_HIGHBIT
Definition: mpfr-impl.h:1276
#define MPFR_UNLIKELY(x)
Definition: mpfr-impl.h:1490
#define MPFR_LIKELY(x)
Definition: mpfr-impl.h:1489
#define MPFR_IS_NAN(x)
Definition: mpfr-impl.h:1080
#define MPFR_INVERT_RND(rnd)
Definition: mpfr-impl.h:1224
#define MPFR_INT_CEIL_LOG2(x)
Definition: mpfr-impl.h:1558
int mpfr_round_p(mp_limb_t *, mp_size_t, mpfr_exp_t, mpfr_prec_t)
Definition: round_p.c:69
#define MPFR_ZIV_INIT(_x, _p)
Definition: mpfr-impl.h:2053
#define MPFR_IS_NEG(x)
Definition: mpfr-impl.h:1140
#define MPFR_EVEN_INEX
Definition: mpfr-impl.h:1166
#define MPFR_SAVE_EXPO_UPDATE_FLAGS(x, flags)
Definition: mpfr-impl.h:1740
#define IS_POW2(X)
Definition: mpfr-impl.h:1619
#define MPFR_SAVE_EXPO_MARK(x)
Definition: mpfr-impl.h:1730
#define MPFR_PREC(x)
Definition: mpfr-impl.h:958
#define MPFR_GET_EXP(x)
Definition: mpfr-impl.h:1058
#define MPFR_TMP_ALLOC
Definition: mpfr-impl.h:1335
int mpfr_round_raw(mp_limb_t *, const mp_limb_t *, mpfr_prec_t, int, mpfr_prec_t, mpfr_rnd_t, int *)
#define MPFR_EXP_FSPEC
Definition: mpfr-impl.h:1005
#define MPFR_SAVE_EXPO_FREE(x)
Definition: mpfr-impl.h:1736
#define MPFR_TMP_FREE
Definition: mpfr-impl.h:1336
#define MPFR_IS_ZERO(x)
Definition: mpfr-impl.h:1084
#define MPFR_LIMB_SIZE(x)
Definition: mpfr-impl.h:963
#define mpfr_get_exp_t(x, r)
Definition: mpfr-impl.h:1003
long mpfr_eexp_t
Definition: mpfr-impl.h:1001
#define MPFR_ZIV_NEXT(_x, _p)
Definition: mpfr-impl.h:2054
#define MPFR_TMP_DECL
Definition: mpfr-impl.h:1333
#define MPFR_TMP_INIT1(xp, x, p)
Definition: mpfr-impl.h:1349
#define MPFR_SAVE_EXPO_DECL(x)
Definition: mpfr-impl.h:1729
#define MPFR_ASSERTN(expr)
Definition: mpfr-impl.h:495
int mpfr_mpn_exp(mp_limb_t *, mpfr_exp_t *, int, mpfr_exp_t, size_t)
Definition: mpn_exp.c:76
#define MPFR_EXP_LIMB_SIZE
Definition: mpfr-impl.h:1015
#define MPFR_PREC_BITS
Definition: mpfr-impl.h:2563
#define MPFR_ZIV_DECL(_x)
Definition: mpfr-impl.h:2052
#define MPFR_PREC2LIMBS(p)
Definition: mpfr-impl.h:955
#define MPFR_ZIV_FREE(x)
Definition: mpfr-impl.h:2055
#define MPFR_LOG_FUNC(x, y)
Definition: mpfr-impl.h:2227
#define MPFR_TMP_MARK
Definition: mpfr-impl.h:1334
#define MPFR_ASSERTD(expr)
Definition: mpfr-impl.h:516
#define MPFR_TMP_LIMBS_ALLOC(N)
Definition: mpfr-impl.h:1344
#define MPFR_LOG_MSG(x)
Definition: mpfr-impl.h:2226
#define mpfr_set_exp_t(x, e, r)
Definition: mpfr-impl.h:1004
#define MPFR_MANT(x)
Definition: mpfr-impl.h:960
#define MPFR_IS_STRICTNEG(x)
Definition: mpfr-impl.h:1138
void mpn_tdiv_qr(mp_limb_t *, mp_limb_t *, mp_size_t, const mp_limb_t *, mp_size_t, const mp_limb_t *, mp_size_t)
#define MPFR_STAT_STATIC_ASSERT(c)
Definition: mpfr-sassert.h:69
void mpfr_clear(mpfr_ptr m)
Definition: clear.c:26
const mp_limb_t mpfr_l2b_25_0__tab[]
Definition: get_str.c:1045
const mp_limb_t mpfr_l2b_24_0__tab[]
Definition: get_str.c:1011
const mp_limb_t mpfr_l2b_61_1__tab[]
Definition: get_str.c:2286
const mp_limb_t mpfr_l2b_42_1__tab[]
Definition: get_str.c:1640
const mp_limb_t mpfr_l2b_31_0__tab[]
Definition: get_str.c:1249
const mp_limb_t mpfr_l2b_58_0__tab[]
Definition: get_str.c:2167
const mp_limb_t mpfr_l2b_8_1__tab[]
Definition: get_str.c:484
const mp_limb_t mpfr_l2b_27_0__tab[]
Definition: get_str.c:1113
const mp_limb_t mpfr_l2b_26_1__tab[]
Definition: get_str.c:1096
const mp_limb_t mpfr_l2b_31_1__tab[]
Definition: get_str.c:1266
const mp_limb_t mpfr_l2b_53_1__tab[]
Definition: get_str.c:2014
const mp_limb_t mpfr_l2b_29_0__tab[]
Definition: get_str.c:1181
const mp_limb_t mpfr_l2b_21_0__tab[]
Definition: get_str.c:909
const mp_limb_t mpfr_l2b_57_1__tab[]
Definition: get_str.c:2150
static int mpfr_get_str_aux(char *const, mpfr_exp_t *const, mp_limb_t *const, mp_size_t, mpfr_exp_t, long, int, size_t, mpfr_rnd_t)
Definition: get_str.c:80
const mp_limb_t mpfr_l2b_48_1__tab[]
Definition: get_str.c:1844
const mp_limb_t mpfr_l2b_54_1__tab[]
Definition: get_str.c:2048
const mp_limb_t mpfr_l2b_23_0__tab[]
Definition: get_str.c:977
const mp_limb_t mpfr_l2b_4_0__tab[]
Definition: get_str.c:331
#define UINT64_C(c)
Definition: get_str.c:252
const mp_limb_t mpfr_l2b_5_1__tab[]
Definition: get_str.c:382
const mp_limb_t mpfr_l2b_24_1__tab[]
Definition: get_str.c:1028
const mp_limb_t mpfr_l2b_28_0__tab[]
Definition: get_str.c:1147
const mp_limb_t mpfr_l2b_42_0__tab[]
Definition: get_str.c:1623
const mp_limb_t mpfr_l2b_17_1__tab[]
Definition: get_str.c:790
const mp_limb_t mpfr_l2b_56_0__tab[]
Definition: get_str.c:2099
const mp_limb_t mpfr_l2b_59_1__tab[]
Definition: get_str.c:2218
const mp_limb_t mpfr_l2b_41_0__tab[]
Definition: get_str.c:1589
const mp_limb_t mpfr_l2b_3_0__tab[]
Definition: get_str.c:297
const mp_limb_t mpfr_l2b_60_0__tab[]
Definition: get_str.c:2235
const mp_limb_t mpfr_l2b_19_0__tab[]
Definition: get_str.c:841
const mp_limb_t mpfr_l2b_23_1__tab[]
Definition: get_str.c:994
const mp_limb_t mpfr_l2b_13_0__tab[]
Definition: get_str.c:637
const mp_limb_t mpfr_l2b_30_0__tab[]
Definition: get_str.c:1215
const mp_limb_t mpfr_l2b_40_0__tab[]
Definition: get_str.c:1555
const mp_limb_t mpfr_l2b_38_1__tab[]
Definition: get_str.c:1504
const mp_limb_t mpfr_l2b_43_0__tab[]
Definition: get_str.c:1657
const mp_limb_t mpfr_l2b_58_1__tab[]
Definition: get_str.c:2184
const mp_limb_t mpfr_l2b_36_1__tab[]
Definition: get_str.c:1436
const mp_limb_t mpfr_l2b_61_0__tab[]
Definition: get_str.c:2269
const mp_limb_t mpfr_l2b_11_0__tab[]
Definition: get_str.c:569
const mp_limb_t mpfr_l2b_15_1__tab[]
Definition: get_str.c:722
const mp_limb_t mpfr_l2b_7_0__tab[]
Definition: get_str.c:433
const mp_limb_t mpfr_l2b_2_1__tab[]
Definition: get_str.c:280
const mp_limb_t mpfr_l2b_5_0__tab[]
Definition: get_str.c:365
const mp_limb_t mpfr_l2b_8_0__tab[]
Definition: get_str.c:467
const mp_limb_t mpfr_l2b_33_1__tab[]
Definition: get_str.c:1334
const mp_limb_t mpfr_l2b_55_1__tab[]
Definition: get_str.c:2082
static const char num_to_text62[]
Definition: get_str.c:33
const mp_limb_t mpfr_l2b_54_0__tab[]
Definition: get_str.c:2031
const mp_limb_t mpfr_l2b_22_0__tab[]
Definition: get_str.c:943
const mp_limb_t mpfr_l2b_29_1__tab[]
Definition: get_str.c:1198
void mpfr_free_str(char *str)
Definition: get_str.c:2899
const mp_limb_t mpfr_l2b_7_1__tab[]
Definition: get_str.c:450
const mp_limb_t mpfr_l2b_12_1__tab[]
Definition: get_str.c:620
const __mpfr_struct __gmpfr_l2b[62 -1][2]
Definition: get_str.c:2329
const mp_limb_t mpfr_l2b_32_1__tab[]
Definition: get_str.c:1300
const mp_limb_t mpfr_l2b_6_1__tab[]
Definition: get_str.c:416
const mp_limb_t mpfr_l2b_19_1__tab[]
Definition: get_str.c:858
const mp_limb_t mpfr_l2b_17_0__tab[]
Definition: get_str.c:773
const mp_limb_t mpfr_l2b_50_0__tab[]
Definition: get_str.c:1895
const mp_limb_t mpfr_l2b_32_0__tab[]
Definition: get_str.c:1283
const mp_limb_t mpfr_l2b_14_0__tab[]
Definition: get_str.c:671
const mp_limb_t mpfr_l2b_28_1__tab[]
Definition: get_str.c:1164
const mp_limb_t mpfr_l2b_47_1__tab[]
Definition: get_str.c:1810
const mp_limb_t mpfr_l2b_45_0__tab[]
Definition: get_str.c:1725
const mp_limb_t mpfr_l2b_12_0__tab[]
Definition: get_str.c:603
const mp_limb_t mpfr_l2b_6_0__tab[]
Definition: get_str.c:399
const mp_limb_t mpfr_l2b_20_1__tab[]
Definition: get_str.c:892
const mp_limb_t mpfr_l2b_35_1__tab[]
Definition: get_str.c:1402
const mp_limb_t mpfr_l2b_13_1__tab[]
Definition: get_str.c:654
const mp_limb_t mpfr_l2b_34_1__tab[]
Definition: get_str.c:1368
const mp_limb_t mpfr_l2b_60_1__tab[]
Definition: get_str.c:2252
const mp_limb_t mpfr_l2b_62_0__tab[]
Definition: get_str.c:2303
const mp_limb_t mpfr_l2b_9_1__tab[]
Definition: get_str.c:518
const mp_limb_t mpfr_l2b_52_0__tab[]
Definition: get_str.c:1963
const mp_limb_t mpfr_l2b_25_1__tab[]
Definition: get_str.c:1062
const mp_limb_t mpfr_l2b_40_1__tab[]
Definition: get_str.c:1572
const mp_limb_t mpfr_l2b_55_0__tab[]
Definition: get_str.c:2065
char * mpfr_get_str(char *s, mpfr_exp_t *e, int b, size_t m, mpfr_srcptr x, mpfr_rnd_t rnd)
Definition: get_str.c:2563
const mp_limb_t mpfr_l2b_44_0__tab[]
Definition: get_str.c:1691
const mp_limb_t mpfr_l2b_46_0__tab[]
Definition: get_str.c:1759
const mp_limb_t mpfr_l2b_45_1__tab[]
Definition: get_str.c:1742
const mp_limb_t mpfr_l2b_57_0__tab[]
Definition: get_str.c:2133
#define MPN_COPY2(rp, n1, op, n2)
Definition: get_str.c:38
const mp_limb_t mpfr_l2b_27_1__tab[]
Definition: get_str.c:1130
const mp_limb_t mpfr_l2b_18_0__tab[]
Definition: get_str.c:807
const mp_limb_t mpfr_l2b_62_1__tab[]
Definition: get_str.c:2320
const mp_limb_t mpfr_l2b_52_1__tab[]
Definition: get_str.c:1980
const mp_limb_t mpfr_l2b_30_1__tab[]
Definition: get_str.c:1232
const mp_limb_t mpfr_l2b_41_1__tab[]
Definition: get_str.c:1606
const mp_limb_t mpfr_l2b_49_1__tab[]
Definition: get_str.c:1878
const mp_limb_t mpfr_l2b_11_1__tab[]
Definition: get_str.c:586
mpfr_exp_t mpfr_ceil_mul(mpfr_exp_t e, int beta, int i)
Definition: get_str.c:2461
const mp_limb_t mpfr_l2b_48_0__tab[]
Definition: get_str.c:1827
const mp_limb_t mpfr_l2b_35_0__tab[]
Definition: get_str.c:1385
const mp_limb_t mpfr_l2b_50_1__tab[]
Definition: get_str.c:1912
const mp_limb_t mpfr_l2b_4_1__tab[]
Definition: get_str.c:348
const mp_limb_t mpfr_l2b_15_0__tab[]
Definition: get_str.c:705
const mp_limb_t mpfr_l2b_14_1__tab[]
Definition: get_str.c:688
const mp_limb_t mpfr_l2b_53_0__tab[]
Definition: get_str.c:1997
const mp_limb_t mpfr_l2b_10_1__tab[]
Definition: get_str.c:552
static const char num_to_text36[]
Definition: get_str.c:32
const mp_limb_t mpfr_l2b_43_1__tab[]
Definition: get_str.c:1674
const mp_limb_t mpfr_l2b_22_1__tab[]
Definition: get_str.c:960
const mp_limb_t mpfr_l2b_51_0__tab[]
Definition: get_str.c:1929
const mp_limb_t mpfr_l2b_18_1__tab[]
Definition: get_str.c:824
const mp_limb_t mpfr_l2b_16_1__tab[]
Definition: get_str.c:756
const mp_limb_t mpfr_l2b_51_1__tab[]
Definition: get_str.c:1946
const mp_limb_t mpfr_l2b_16_0__tab[]
Definition: get_str.c:739
const mp_limb_t mpfr_l2b_9_0__tab[]
Definition: get_str.c:501
const mp_limb_t mpfr_l2b_39_1__tab[]
Definition: get_str.c:1538
const mp_limb_t mpfr_l2b_33_0__tab[]
Definition: get_str.c:1317
const mp_limb_t mpfr_l2b_20_0__tab[]
Definition: get_str.c:875
const mp_limb_t mpfr_l2b_59_0__tab[]
Definition: get_str.c:2201
const mp_limb_t mpfr_l2b_34_0__tab[]
Definition: get_str.c:1351
const mp_limb_t mpfr_l2b_26_0__tab[]
Definition: get_str.c:1079
const mp_limb_t mpfr_l2b_56_1__tab[]
Definition: get_str.c:2116
const mp_limb_t mpfr_l2b_21_1__tab[]
Definition: get_str.c:926
#define MPFR_ROUND_FAILED
Definition: get_str.c:49
const mp_limb_t mpfr_l2b_38_0__tab[]
Definition: get_str.c:1487
const mp_limb_t mpfr_l2b_39_0__tab[]
Definition: get_str.c:1521
size_t mpfr_get_str_ndigits(int b, mpfr_prec_t p)
Definition: get_str.c:2485
const mp_limb_t mpfr_l2b_10_0__tab[]
Definition: get_str.c:535
const mp_limb_t mpfr_l2b_37_1__tab[]
Definition: get_str.c:1470
const mp_limb_t mpfr_l2b_2_0__tab[]
Definition: get_str.c:263
const mp_limb_t mpfr_l2b_36_0__tab[]
Definition: get_str.c:1419
const mp_limb_t mpfr_l2b_46_1__tab[]
Definition: get_str.c:1776
const mp_limb_t mpfr_l2b_47_0__tab[]
Definition: get_str.c:1793
const mp_limb_t mpfr_l2b_44_1__tab[]
Definition: get_str.c:1708
const mp_limb_t mpfr_l2b_3_1__tab[]
Definition: get_str.c:314
const mp_limb_t mpfr_l2b_37_0__tab[]
Definition: get_str.c:1453
const mp_limb_t mpfr_l2b_49_0__tab[]
Definition: get_str.c:1861
unsigned long mpfr_get_ui(mpfr_srcptr f, mpfr_rnd_t rnd)
Definition: get_ui.c:26
void mpfr_init2(mpfr_ptr x, mpfr_prec_t p)
Definition: init2.c:26
#define MPFR_FLAGS_NAN
Definition: mpfr.h:79
int mpfr_ui_div(mpfr_ptr, unsigned long, mpfr_srcptr, mpfr_rnd_t)
long mpfr_prec_t
Definition: mpfr.h:168
__mpfr_struct mpfr_t[1]
Definition: mpfr.h:250
#define mpfr_ceil(a, b)
Definition: mpfr.h:859
#define mpfr_get_prec(_x)
Definition: mpfr.h:848
#define MPFR_PREC_MAX
Definition: mpfr.h:181
int mpfr_set_ui(mpfr_ptr, unsigned long, mpfr_rnd_t)
Definition: set_ui.c:27
mpfr_rnd_t
Definition: mpfr.h:102
@ MPFR_RNDA
Definition: mpfr.h:107
@ MPFR_RNDF
Definition: mpfr.h:108
@ MPFR_RNDN
Definition: mpfr.h:103
@ MPFR_RNDU
Definition: mpfr.h:105
@ MPFR_RNDD
Definition: mpfr.h:106
long mpfr_exp_t
Definition: mpfr.h:195
#define mpfr_cmp(b, c)
Definition: mpfr.h:869
#define MPFR_FLAGS_INEXACT
Definition: mpfr.h:80
int mpfr_mul(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t)
Definition: mul.c:732
@ err
Definition: mtxline.h:24
float x
Definition: cordic.py:15
int k
Definition: otp-parser.c:70
#define BASE_MAX
Definition: pl-lexer.c:1067
integer nb
Definition: pmxab.c:180
int g
Definition: ppmqvga.c:68
int r
Definition: ppmqvga.c:68
bstring c int memset(void *s, int c, int length)
#define x1
#define dir
#define str(s)
Definition: sh6.c:399
ShellFileEnvironment e
Definition: sh6.c:388
Definition: dvips.h:235
*job_name strlen((char *) job_name) - 4)
str1
Definition: tex4ht.c:2099
m
Definition: tex4ht.c:3990
#define s0
Definition: tokst.h:45
#define rnd(x)
Definition: xim.h:106