{

private static final Logger log = Configuration.DEBUG ?

Logger.getLogger(BigInteger.class.getName()) : null;

/** All integers are stored in 2's-complement form.

private transient int ival;

private transient int[] words;

// Serialization fields.

// the first three, although not used in the code, are present for

// compatibility with older RI versions of this class. DO NOT REMOVE.

private int bitCount = -1;

private int bitLength = -1;

private int lowestSetBit = -2;

private byte[] magnitude;

private int signum;

private static final long serialVersionUID = -8287574255936472291L;

/** We pre-allocate integers in the range minFixNum..maxFixNum.

private static final int minFixNum = -100;

private static final int maxFixNum = 1024;

private static final int numFixNum = maxFixNum-minFixNum+1;

private static final BigInteger[] smallFixNums;

/** The alter-ego GMP instance for this. */

private transient GMP mpz;

private static final boolean USING_NATIVE = Configuration.WANT_NATIVE_BIG_INTEGER

&& initializeLibrary();

static

{

if (USING_NATIVE)

{

smallFixNums = null;

ZERO = valueOf(0L);

ONE = valueOf(1L);

TEN = valueOf(10L);

}

else

{

smallFixNums = new BigInteger[numFixNum];

for (int i = numFixNum; --i >= 0; )

smallFixNums[i] = new BigInteger(i + minFixNum);

ZERO = smallFixNums[-minFixNum];

ONE = smallFixNums[1 - minFixNum];

TEN = smallFixNums[10 - minFixNum];

}

}

/**

public static final BigInteger ZERO;

/**

public static final BigInteger ONE;

/**

public static final BigInteger TEN;

/* Rounding modes: */

private static final int FLOOR = 1;

private static final int CEILING = 2;

private static final int TRUNCATE = 3;

private static final int ROUND = 4;

/** When checking the probability of primes, it is most efficient to

private static final int[] primes =

{ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43,

47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107,

109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181,

191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251 };

/** HAC (Handbook of Applied Cryptography), Alfred Menezes & al. Table 4.4. */

private static final int[] k =

{100,150,200,250,300,350,400,500,600,800,1250, Integer.MAX_VALUE};

private static final int[] t =

{ 27, 18, 15, 12, 9, 8, 7, 6, 5, 4, 3, 2};

private BigInteger()

{

super();

if (USING_NATIVE)

mpz = new GMP();

}

/* Create a new (non-shared) BigInteger, and initialize to an int. */

private BigInteger(int value)

{

super();

ival = value;

}

public BigInteger(String s, int radix)

{

this();

int len = s.length();

int i, digit;

boolean negative;

byte[] bytes;

char ch = s.charAt(0);

if (ch == '-')

{

negative = true;

i = 1;

bytes = new byte[len - 1];

}

else

{

negative = false;

i = 0;

bytes = new byte[len];

}

int byte_len = 0;

for ( ; i < len; i++)

{

ch = s.charAt(i);

digit = Character.digit(ch, radix);

if (digit < 0)

throw new NumberFormatException("Invalid character at position #" + i);

bytes[byte_len++] = (byte) digit;

}

if (USING_NATIVE)

{

bytes = null;

if (mpz.fromString(s, radix) != 0)

throw new NumberFormatException("String \"" + s

+ "\" is NOT a valid number in base "

+ radix);

}

else

{

BigInteger result;

// Testing (len < MPN.chars_per_word(radix)) would be more accurate,

// but slightly more expensive, for little practical gain.

if (len <= 15 && radix <= 16)

result = valueOf(Long.parseLong(s, radix));

else

result = valueOf(bytes, byte_len, negative, radix);

this.ival = result.ival;

this.words = result.words;

}

}

public BigInteger(String val)

{

this(val, 10);

}

/* Create a new (non-shared) BigInteger, and initialize from a byte array. */

public BigInteger(byte[] val)

{

this();

if (val == null || val.length < 1)

throw new NumberFormatException();

if (USING_NATIVE)

mpz.fromByteArray(val);

else

{

words = byteArrayToIntArray(val, val[0] < 0 ? -1 : 0);

BigInteger result = make(words, words.length);

this.ival = result.ival;

this.words = result.words;

}

}

public BigInteger(int signum, byte[] magnitude)

{

this();

if (magnitude == null || signum > 1 || signum < -1)

throw new NumberFormatException();

if (signum == 0)

{

int i;

for (i = magnitude.length - 1; i >= 0 && magnitude[i] == 0; --i)

;

if (i >= 0)

throw new NumberFormatException();

return;

}

if (USING_NATIVE)

mpz.fromSignedMagnitude(magnitude, signum == -1);

else

{

// Magnitude is always positive, so don't ever pass a sign of -1.

words = byteArrayToIntArray(magnitude, 0);

BigInteger result = make(words, words.length);

this.ival = result.ival;

this.words = result.words;

if (signum < 0)

setNegative();

}

}

public BigInteger(int numBits, Random rnd)

{

this();

if (numBits < 0)

throw new IllegalArgumentException();

init(numBits, rnd);

}

private void init(int numBits, Random rnd)

{

if (USING_NATIVE)

{

int length = (numBits + 7) / 8;

byte[] magnitude = new byte[length];

rnd.nextBytes(magnitude);

int discardedBitCount = numBits % 8;

if (discardedBitCount != 0)

{

discardedBitCount = 8 - discardedBitCount;

magnitude[0] = (byte)((magnitude[0] & 0xFF) >>> discardedBitCount);

}

mpz.fromSignedMagnitude(magnitude, false);

magnitude = null;

return;

}

int highbits = numBits & 31;

// minimum number of bytes to store the above number of bits

int highBitByteCount = (highbits + 7) / 8;

// number of bits to discard from the last byte

int discardedBitCount = highbits % 8;

if (discardedBitCount != 0)

discardedBitCount = 8 - discardedBitCount;

byte[] highBitBytes = new byte[highBitByteCount];

if (highbits > 0)

{

rnd.nextBytes(highBitBytes);

highbits = (highBitBytes[highBitByteCount - 1] & 0xFF) >>> discardedBitCount;

for (int i = highBitByteCount - 2; i >= 0; i--)

highbits = (highbits << 8) | (highBitBytes[i] & 0xFF);

}

int nwords = numBits / 32;

while (highbits == 0 && nwords > 0)

{

highbits = rnd.nextInt();

--nwords;

}

if (nwords == 0 && highbits >= 0)

{

ival = highbits;

}

else

{

ival = highbits < 0 ? nwords + 2 : nwords + 1;

words = new int[ival];

words[nwords] = highbits;

while (--nwords >= 0)

words[nwords] = rnd.nextInt();

}

}

public BigInteger(int bitLength, int certainty, Random rnd)

{

this();

BigInteger result = new BigInteger();

while (true)

{

result.init(bitLength, rnd);

result = result.setBit(bitLength - 1);

if (result.isProbablePrime(certainty))

break;

}

if (USING_NATIVE)

mpz.fromBI(result.mpz);

else

{

this.ival = result.ival;

this.words = result.words;

}

}

/**

public static BigInteger probablePrime(int bitLength, Random rnd)

{

if (bitLength < 2)

throw new ArithmeticException();

return new BigInteger(bitLength, 100, rnd);

}

/** Return a (possibly-shared) BigInteger with a given long value. */

public static BigInteger valueOf(long val)

{

if (USING_NATIVE)

{

BigInteger result = new BigInteger();

result.mpz.fromLong(val);

return result;

}

if (val >= minFixNum && val <= maxFixNum)

return smallFixNums[(int) val - minFixNum];

int i = (int) val;

if ((long) i == val)

return new BigInteger(i);

BigInteger result = alloc(2);

result.ival = 2;

result.words[0] = i;

result.words[1] = (int)(val >> 32);

return result;

}

/**

private static boolean initializeLibrary()

{

boolean result;

try

{

System.loadLibrary("javamath");

GMP.natInitializeLibrary();

result = true;

}

catch (Throwable x)

{

result = false;

if (Configuration.DEBUG)

{

log.info("Unable to use native BigInteger: " + x);

log.info("Will use a pure Java implementation instead");

}

}

return result;

}

/** Make a canonicalized BigInteger from an array of words.

private static BigInteger make(int[] words, int len)

{

if (words == null)

return valueOf(len);

len = BigInteger.wordsNeeded(words, len);

if (len <= 1)

return len == 0 ? ZERO : valueOf(words[0]);

BigInteger num = new BigInteger();

num.words = words;

num.ival = len;

return num;

}

/** Convert a big-endian byte array to a little-endian array of words. */

private static int[] byteArrayToIntArray(byte[] bytes, int sign)

{

// Determine number of words needed.

int[] words = new int[bytes.length/4 + 1];

int nwords = words.length;

// Create a int out of modulo 4 high order bytes.

int bptr = 0;

int word = sign;

for (int i = bytes.length % 4; i > 0; --i, bptr++)

word = (word << 8) | (bytes[bptr] & 0xff);

words[--nwords] = word;

// Elements remaining in byte[] are a multiple of 4.

while (nwords > 0)

words[--nwords] = bytes[bptr++] << 24 |

(bytes[bptr++] & 0xff) << 16 |

(bytes[bptr++] & 0xff) << 8 |

(bytes[bptr++] & 0xff);

return words;

}

/** Allocate a new non-shared BigInteger.

private static BigInteger alloc(int nwords)

{

BigInteger result = new BigInteger();

if (nwords > 1)

result.words = new int[nwords];

return result;

}

/** Change words.length to nwords.

private void realloc(int nwords)

{

if (nwords == 0)

{

if (words != null)

{

if (ival > 0)

ival = words[0];

words = null;

}

}

else if (words == null

|| words.length < nwords

|| words.length > nwords + 2)

{

int[] new_words = new int [nwords];

if (words == null)

{

new_words[0] = ival;

ival = 1;

}

else

{

if (nwords < ival)

ival = nwords;

System.arraycopy(words, 0, new_words, 0, ival);

}

words = new_words;

}

}

private boolean isNegative()

{

return (words == null ? ival : words[ival - 1]) < 0;

}

public int signum()

{

if (USING_NATIVE)

return mpz.compare(ZERO.mpz);

if (ival == 0 && words == null)

return 0;

int top = words == null ? ival : words[ival-1];

return top < 0 ? -1 : 1;

}

private static int compareTo(BigInteger x, BigInteger y)

{

if (USING_NATIVE)

{

int dummy = y.signum; // force NPE check

return x.mpz.compare(y.mpz);

}

if (x.words == null && y.words == null)

return x.ival < y.ival ? -1 : x.ival > y.ival ? 1 : 0;

boolean x_negative = x.isNegative();

boolean y_negative = y.isNegative();

if (x_negative != y_negative)

return x_negative ? -1 : 1;

int x_len = x.words == null ? 1 : x.ival;

int y_len = y.words == null ? 1 : y.ival;

if (x_len != y_len)

return (x_len > y_len) != x_negative ? 1 : -1;

return MPN.cmp(x.words, y.words, x_len);

}

/** @since 1.2 */

public int compareTo(BigInteger val)

{

return compareTo(this, val);

}

public BigInteger min(BigInteger val)

{

return compareTo(this, val) < 0 ? this : val;

}

public BigInteger max(BigInteger val)

{

return compareTo(this, val) > 0 ? this : val;

}

private boolean isZero()

{

return words == null && ival == 0;

}

private boolean isOne()

{

return words == null && ival == 1;

}

/** Calculate how many words are significant in words[0:len-1].

private static int wordsNeeded(int[] words, int len)

{

int i = len;

if (i > 0)

{

int word = words[--i];

if (word == -1)

{

while (i > 0 && (word = words[i - 1]) < 0)

{

i--;

if (word != -1) break;

}

}

else

{

while (word == 0 && i > 0 && (word = words[i - 1]) >= 0) i--;

}

}

return i + 1;

}

private BigInteger canonicalize()

{

if (words != null

&& (ival = BigInteger.wordsNeeded(words, ival)) <= 1)

{

if (ival == 1)

ival = words[0];

words = null;

}

if (words == null && ival >= minFixNum && ival <= maxFixNum)

return smallFixNums[ival - minFixNum];

return this;

}

/** Add two ints, yielding a BigInteger. */

private static BigInteger add(int x, int y)

{

return valueOf((long) x + (long) y);

}

/** Add a BigInteger and an int, yielding a new BigInteger. */

private static BigInteger add(BigInteger x, int y)

{

if (x.words == null)

return BigInteger.add(x.ival, y);

BigInteger result = new BigInteger(0);

result.setAdd(x, y);

return result.canonicalize();

}

/** Set this to the sum of x and y.

private void setAdd(BigInteger x, int y)

{

if (x.words == null)

{

set((long) x.ival + (long) y);

return;

}

int len = x.ival;

realloc(len + 1);

long carry = y;

for (int i = 0; i < len; i++)

{

carry += ((long) x.words[i] & 0xffffffffL);

words[i] = (int) carry;

carry >>= 32;

}

if (x.words[len - 1] < 0)

carry--;

words[len] = (int) carry;

ival = wordsNeeded(words, len + 1);

}

/** Destructively add an int to this. */

private void setAdd(int y)

{

setAdd(this, y);

}

/** Destructively set the value of this to a long. */

private void set(long y)

{

int i = (int) y;

if ((long) i == y)

{

ival = i;

words = null;

}

else

{

realloc(2);

words[0] = i;

words[1] = (int) (y >> 32);

ival = 2;

}

}

/** Destructively set the value of this to the given words.

private void set(int[] words, int length)

{

this.ival = length;

this.words = words;

}

/** Destructively set the value of this to that of y. */

private void set(BigInteger y)

{

if (y.words == null)

set(y.ival);

else if (this != y)

{

realloc(y.ival);

System.arraycopy(y.words, 0, words, 0, y.ival);

ival = y.ival;

}

}

/** Add two BigIntegers, yielding their sum as another BigInteger. */

private static BigInteger add(BigInteger x, BigInteger y, int k)

{

if (x.words == null && y.words == null)

return valueOf((long) k * (long) y.ival + (long) x.ival);

if (k != 1)

{

if (k == -1)

y = BigInteger.neg(y);

else

y = BigInteger.times(y, valueOf(k));

}

if (x.words == null)

return BigInteger.add(y, x.ival);

if (y.words == null)

return BigInteger.add(x, y.ival);

// Both are big

if (y.ival > x.ival)

{ // Swap so x is longer then y.

BigInteger tmp = x; x = y; y = tmp;

}

BigInteger result = alloc(x.ival + 1);

int i = y.ival;

long carry = MPN.add_n(result.words, x.words, y.words, i);

long y_ext = y.words[i - 1] < 0 ? 0xffffffffL : 0;

for (; i < x.ival; i++)

{

carry += ((long) x.words[i] & 0xffffffffL) + y_ext;

result.words[i] = (int) carry;

carry >>>= 32;

}

if (x.words[i - 1] < 0)

y_ext--;

result.words[i] = (int) (carry + y_ext);

result.ival = i+1;

return result.canonicalize();

}

public BigInteger add(BigInteger val)

{

if (USING_NATIVE)

{

int dummy = val.signum; // force NPE check

BigInteger result = new BigInteger();

mpz.add(val.mpz, result.mpz);

return result;

}

return add(this, val, 1);

}

public BigInteger subtract(BigInteger val)

{

if (USING_NATIVE)

{

int dummy = val.signum; // force NPE check

BigInteger result = new BigInteger();

mpz.subtract(val.mpz, result.mpz);

return result;

}

return add(this, val, -1);

}

private static BigInteger times(BigInteger x, int y)

{

if (y == 0)

return ZERO;

if (y == 1)

return x;

int[] xwords = x.words;

int xlen = x.ival;

if (xwords == null)

return valueOf((long) xlen * (long) y);

boolean negative;

BigInteger result = BigInteger.alloc(xlen + 1);

if (xwords[xlen - 1] < 0)

{

negative = true;

negate(result.words, xwords, xlen);

xwords = result.words;

}

else

negative = false;

if (y < 0)

{

negative = !negative;

y = -y;

}

result.words[xlen] = MPN.mul_1(result.words, xwords, xlen, y);

result.ival = xlen + 1;

if (negative)

result.setNegative();

return result.canonicalize();

}

private static BigInteger times(BigInteger x, BigInteger y)

{

if (y.words == null)

return times(x, y.ival);

if (x.words == null)

return times(y, x.ival);

boolean negative = false;

int[] xwords;

int[] ywords;

int xlen = x.ival;

int ylen = y.ival;

if (x.isNegative())

{

negative = true;

xwords = new int[xlen];

negate(xwords, x.words, xlen);

}

else

{

negative = false;

xwords = x.words;

}

if (y.isNegative())

{

negative = !negative;

ywords = new int[ylen];

negate(ywords, y.words, ylen);

}

else

ywords = y.words;

// Swap if x is shorter then y.

if (xlen < ylen)

{

int[] twords = xwords; xwords = ywords; ywords = twords;

int tlen = xlen; xlen = ylen; ylen = tlen;

}

BigInteger result = BigInteger.alloc(xlen+ylen);

MPN.mul(result.words, xwords, xlen, ywords, ylen);

result.ival = xlen+ylen;

if (negative)

result.setNegative();

return result.canonicalize();

}

public BigInteger multiply(BigInteger y)

{

if (USING_NATIVE)

{

int dummy = y.signum; // force NPE check

BigInteger result = new BigInteger();

mpz.multiply(y.mpz, result.mpz);

return result;

}

return times(this, y);

}

private static void divide(long x, long y,

BigInteger quotient, BigInteger remainder,

int rounding_mode)

{

boolean xNegative, yNegative;

if (x < 0)

{

xNegative = true;

if (x == Long.MIN_VALUE)

{

divide(valueOf(x), valueOf(y),

quotient, remainder, rounding_mode);

return;

}

x = -x;

}

else

xNegative = false;

if (y < 0)

{

yNegative = true;

if (y == Long.MIN_VALUE)

{

if (rounding_mode == TRUNCATE)

{ // x != Long.Min_VALUE implies abs(x) < abs(y)

if (quotient != null)

quotient.set(0);

if (remainder != null)

remainder.set(x);

}

else

divide(valueOf(x), valueOf(y),

quotient, remainder, rounding_mode);

return;

}

y = -y;

}

else

yNegative = false;

long q = x / y;

long r = x % y;

boolean qNegative = xNegative ^ yNegative;

boolean add_one = false;

if (r != 0)

{

switch (rounding_mode)

{

case TRUNCATE:

break;

case CEILING:

case FLOOR:

if (qNegative == (rounding_mode == FLOOR))

add_one = true;

break;

case ROUND:

add_one = r > ((y - (q & 1)) >> 1);

break;

}

}

if (quotient != null)

{

if (add_one)

q++;

if (qNegative)

q = -q;

quotient.set(q);

}

if (remainder != null)

{

// The remainder is by definition: X-Q*Y

if (add_one)

{

// Subtract the remainder from Y.

r = y - r;

// In this case, abs(Q*Y) > abs(X).

// So sign(remainder) = -sign(X).

xNegative = ! xNegative;

}

else

{

// If !add_one, then: abs(Q*Y) <= abs(X).

// So sign(remainder) = sign(X).

}

if (xNegative)

r = -r;

remainder.set(r);

}

}

/** Divide two integers, yielding quotient and remainder.

private static void divide(BigInteger x, BigInteger y,

BigInteger quotient, BigInteger remainder,

int rounding_mode)

{

if ((x.words == null || x.ival <= 2)

&& (y.words == null || y.ival <= 2))

{

long x_l = x.longValue();

long y_l = y.longValue();

if (x_l != Long.MIN_VALUE && y_l != Long.MIN_VALUE)

{

divide(x_l, y_l, quotient, remainder, rounding_mode);

return;

}

}

boolean xNegative = x.isNegative();

boolean yNegative = y.isNegative();

boolean qNegative = xNegative ^ yNegative;

int ylen = y.words == null ? 1 : y.ival;

int[] ywords = new int[ylen];

y.getAbsolute(ywords);

while (ylen > 1 && ywords[ylen - 1] == 0) ylen--;

int xlen = x.words == null ? 1 : x.ival;

int[] xwords = new int[xlen+2];

x.getAbsolute(xwords);

while (xlen > 1 && xwords[xlen-1] == 0) xlen--;

int qlen, rlen;

int cmpval = MPN.cmp(xwords, xlen, ywords, ylen);

if (cmpval < 0) // abs(x) < abs(y)

{ // quotient = 0; remainder = num.

int[] rwords = xwords; xwords = ywords; ywords = rwords;

rlen = xlen; qlen = 1; xwords[0] = 0;

}

else if (cmpval == 0) // abs(x) == abs(y)