source/libs/mpfr/mpfr-3.1.2/src/get_str.c

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