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