internal static BigInteger Pow(BigInteger value, uint p)
 {
     var b = value;
     for (var i = 0; i < p; i++)
         value = value*b;
     return value;
 }
        internal BigInteger Xor(BigInteger other)
        {
            var len = Math.Min(data.Length, other.data.Length);
            var result = new uint[len];

            for (var i = 0; i < len; i++)
                result[i] = data[i] ^ other.data[i];

            return new BigInteger(result);
        }
            /// <summary>
            ///     Performs n / d and n % d in one operation.
            /// </summary>
            /// <param name="n">A BigInteger, upon exit this will hold n / d</param>
            /// <param name="d">The divisor</param>
            /// <returns>n % d</returns>
            public static uint SingleByteDivideInPlace(BigInteger n, uint d)
            {
                ulong r = 0;
                var i = n.length;

                while (i-- > 0)
                {
                    r <<= 32;
                    r |= n.data[i];
                    n.data[i] = (uint) (r/d);
                    r %= d;
                }
                n.Normalize();

                return (uint) r;
            }
        public BigInteger(BigInteger bi, uint len)
        {
            data = new uint[len];

            for (uint i = 0; i < bi.length; i++)
                data[i] = bi.data[i];

            length = bi.length;
        }
            public static BigInteger modInverse(BigInteger bi, BigInteger modulus)
            {
                if (modulus.length == 1) return modInverse(bi, modulus.data[0]);

                BigInteger[] p = {0, 1};
                var q = new BigInteger[2]; // quotients
                BigInteger[] r = {0, 0}; // remainders

                var step = 0;

                var a = modulus;
                var b = bi;

                var mr = new ModulusRing(modulus);

                while (b != 0)
                {
                    if (step > 1)
                    {
                        var pval = mr.Difference(p[0], p[1]*q[0]);
                        p[0] = p[1];
                        p[1] = pval;
                    }

                    var divret = multiByteDivide(a, b);

                    q[0] = q[1];
                    q[1] = divret[0];
                    r[0] = r[1];
                    r[1] = divret[1];
                    a = b;
                    b = divret[1];

                    step++;
                }

                if (r[0] != 1)
                    throw (new ArithmeticException("No inverse!"));

                return mr.Difference(p[0], p[1]*q[0]);
            }
            public static BigInteger RightShift(BigInteger bi, int n)
            {
                if (n == 0) return new BigInteger(bi);

                var w = n >> 5;
                var s = n & ((1 << 5) - 1);

                var ret = new BigInteger(Sign.Positive, bi.length - (uint) w + 1);
                var l = (uint) ret.data.Length - 1;

                if (s != 0)
                {
                    uint x, carry = 0;

                    while (l-- > 0)
                    {
                        x = bi.data[l + w];
                        ret.data[l] = (x >> n) | carry;
                        carry = x << (32 - n);
                    }
                }
                else
                {
                    while (l-- > 0)
                        ret.data[l] = bi.data[l + w];
                }
                ret.Normalize();
                return ret;
            }
            public static BigInteger LeftShift(BigInteger bi, int n)
            {
                if (n == 0) return new BigInteger(bi, bi.length + 1);

                var w = n >> 5;
                n &= ((1 << 5) - 1);

                var ret = new BigInteger(Sign.Positive, bi.length + 1 + (uint) w);

                uint i = 0, l = bi.length;
                if (n != 0)
                {
                    uint x, carry = 0;
                    while (i < l)
                    {
                        x = bi.data[i];
                        ret.data[i + w] = (x << n) | carry;
                        carry = x >> (32 - n);
                        i++;
                    }
                    ret.data[i + w] = carry;
                }
                else
                {
                    while (i < l)
                    {
                        ret.data[i + w] = bi.data[i];
                        i++;
                    }
                }

                ret.Normalize();
                return ret;
            }
            public static BigInteger[] multiByteDivide(BigInteger bi1, BigInteger bi2)
            {
                if (Compare(bi1, bi2) == Sign.Negative)
                    return new BigInteger[2] {0, new BigInteger(bi1)};

                bi1.Normalize();
                bi2.Normalize();

                if (bi2.length == 1)
                    return DwordDivMod(bi1, bi2.data[0]);

                var remainderLen = bi1.length + 1;
                var divisorLen = (int) bi2.length + 1;

                var mask = 0x80000000;
                var val = bi2.data[bi2.length - 1];
                var shift = 0;
                var resultPos = (int) bi1.length - (int) bi2.length;

                while (mask != 0 && (val & mask) == 0)
                {
                    shift++;
                    mask >>= 1;
                }

                var quot = new BigInteger(Sign.Positive, bi1.length - bi2.length + 1);
                var rem = (bi1 << shift);

                var remainder = rem.data;

                bi2 = bi2 << shift;

                var j = (int) (remainderLen - bi2.length);
                var pos = (int) remainderLen - 1;

                var firstDivisorByte = bi2.data[bi2.length - 1];
                ulong secondDivisorByte = bi2.data[bi2.length - 2];

                while (j > 0)
                {
                    var dividend = ((ulong) remainder[pos] << 32) + remainder[pos - 1];

                    var q_hat = dividend/firstDivisorByte;
                    var r_hat = dividend%firstDivisorByte;

                    do
                    {
                        if (q_hat == 0x100000000 ||
                            (q_hat*secondDivisorByte) > ((r_hat << 32) + remainder[pos - 2]))
                        {
                            q_hat--;
                            r_hat += firstDivisorByte;

                            if (r_hat < 0x100000000)
                                continue;
                        }
                        break;
                    } while (true);

                    //
                    // At this point, q_hat is either exact, or one too large
                    // (more likely to be exact) so, we attempt to multiply the
                    // divisor by q_hat, if we get a borrow, we just subtract
                    // one from q_hat and add the divisor back.
                    //

                    uint t;
                    uint dPos = 0;
                    var nPos = pos - divisorLen + 1;
                    ulong mc = 0;
                    var uint_q_hat = (uint) q_hat;
                    do
                    {
                        mc += bi2.data[dPos]*(ulong) uint_q_hat;
                        t = remainder[nPos];
                        remainder[nPos] -= (uint) mc;
                        mc >>= 32;
                        if (remainder[nPos] > t) mc++;
                        dPos++;
                        nPos++;
                    } while (dPos < divisorLen);

                    nPos = pos - divisorLen + 1;
                    dPos = 0;

                    // Overestimate
                    if (mc != 0)
                    {
                        uint_q_hat--;
                        ulong sum = 0;

                        do
                        {
                            sum = remainder[nPos] + ((ulong) bi2.data[dPos]) + sum;
                            remainder[nPos] = (uint) sum;
                            sum >>= 32;
                            dPos++;
                            nPos++;
                        } while (dPos < divisorLen);
                    }

                    quot.data[resultPos--] = uint_q_hat;

                    pos--;
                    j--;
                }

                quot.Normalize();
                rem.Normalize();
                var ret = new BigInteger[2] {quot, rem};

                if (shift != 0)
                    ret[1] >>= shift;

                return ret;
            }
            public BigInteger Pow(BigInteger a, BigInteger k)
            {
                var b = new BigInteger(1);
                if (k == 0)
                    return b;

                var A = a;
                if (k.TestBit(0))
                    b = a;

                var bitCount = k.BitCount();
                for (var i = 1; i < bitCount; i++)
                {
                    A = Multiply(A, A);
                    if (k.TestBit(i))
                        b = Multiply(A, b);
                }
                return b;
            }
            public BigInteger Difference(BigInteger a, BigInteger b)
            {
                var cmp = Kernel.Compare(a, b);
                BigInteger diff;

                switch (cmp)
                {
                    case Sign.Zero:
                        return 0;
                    case Sign.Positive:
                        diff = a - b;
                        break;
                    case Sign.Negative:
                        diff = b - a;
                        break;
                    default:
                        throw new Exception();
                }

                if (diff >= mod)
                {
                    if (diff.length >= mod.length << 1)
                        diff %= mod;
                    else
                        BarrettReduction(diff);
                }
                if (cmp == Sign.Negative)
                    diff = mod - diff;
                return diff;
            }
            public BigInteger Multiply(BigInteger a, BigInteger b)
            {
                if (a == 0 || b == 0) return 0;

                if (a > mod)
                    a %= mod;

                if (b > mod)
                    b %= mod;

                var ret = a*b;
                BarrettReduction(ret);

                return ret;
            }
        public string ToString(uint radix, string characterSet)
        {
            if (characterSet.Length < radix)
                throw new ArgumentException("charSet length less than radix", "characterSet");
            if (radix == 1)
                throw new ArgumentException("There is no such thing as radix one notation", "radix");

            if (this == 0) return "0";
            if (this == 1) return "1";

            var result = "";

            var a = new BigInteger(this);

            while (a != 0)
            {
                var rem = Kernel.SingleByteDivideInPlace(a, radix);
                result = characterSet[(int) rem] + result;
            }

            return result;
        }
 public Sign Compare(BigInteger bi)
 {
     return Kernel.Compare(this, bi);
 }
        public static BigInteger operator *(BigInteger bi1, BigInteger bi2)
        {
            if (bi1 == 0 || bi2 == 0) return 0;

            //
            // Validate pointers
            //
            if (bi1.data.Length < bi1.length) throw new IndexOutOfRangeException("bi1 out of range");
            if (bi2.data.Length < bi2.length) throw new IndexOutOfRangeException("bi2 out of range");

            var ret = new BigInteger(Sign.Positive, bi1.length + bi2.length);

            Kernel.Multiply(bi1.data, 0, bi1.length, bi2.data, 0, bi2.length, ret.data, 0);

            ret.Normalize();
            return ret;
        }
            public void BarrettReduction(BigInteger x)
            {
                var n = mod;
                uint k = n.length,
                    kPlusOne = k + 1,
                    kMinusOne = k - 1;

                // x < mod, so nothing to do.
                if (x.length < k) return;

                BigInteger q3;

                //
                // Validate pointers
                //
                if (x.data.Length < x.length) throw new IndexOutOfRangeException("x out of range");

                // q1 = x / b^ (k-1)
                // q2 = q1 * constant
                // q3 = q2 / b^ (k+1), Needs to be accessed with an offset of kPlusOne

                // TODO: We should the method in HAC p 604 to do this (14.45)
                q3 = new BigInteger(Sign.Positive, x.length - kMinusOne + constant.length);
                Kernel.Multiply(x.data, kMinusOne, x.length - kMinusOne, constant.data, 0, constant.length, q3.data, 0);

                // r1 = x mod b^ (k+1)
                // i.e. keep the lowest (k+1) words

                var lengthToCopy = (x.length > kPlusOne) ? kPlusOne : x.length;

                x.length = lengthToCopy;
                x.Normalize();

                // r2 = (q3 * n) mod b^ (k+1)
                // partial multiplication of q3 and n

                var r2 = new BigInteger(Sign.Positive, kPlusOne);
                Kernel.MultiplyMod2p32pmod(q3.data, (int) kPlusOne, (int) q3.length - (int) kPlusOne, n.data, 0,
                    (int) n.length, r2.data, 0, (int) kPlusOne);

                r2.Normalize();

                if (r2 <= x)
                {
                    Kernel.MinusEq(x, r2);
                }
                else
                {
                    var val = new BigInteger(Sign.Positive, kPlusOne + 1);
                    val.data[kPlusOne] = 0x00000001;

                    Kernel.MinusEq(val, r2);
                    Kernel.PlusEq(x, val);
                }

                while (x >= n)
                    Kernel.MinusEq(x, n);
            }
            public static uint DwordMod(BigInteger n, uint d)
            {
                ulong r = 0;
                var i = n.length;

                while (i-- > 0)
                {
                    r <<= 32;
                    r |= n.data[i];
                    r %= d;
                }

                return (uint) r;
            }
            public static BigInteger[] DwordDivMod(BigInteger n, uint d)
            {
                var ret = new BigInteger(Sign.Positive, n.length);

                ulong r = 0;
                var i = n.length;

                while (i-- > 0)
                {
                    r <<= 32;
                    r |= n.data[i];
                    ret.data[i] = (uint) (r/d);
                    r %= d;
                }
                ret.Normalize();

                BigInteger rem = (uint) r;

                return new[] {ret, rem};
            }
 public BigInteger Pow(uint b, BigInteger exp)
 {
     return Pow(new BigInteger(b), exp);
 }
 public BigInteger ModPow(BigInteger exp, BigInteger n)
 {
     var mr = new ModulusRing(n);
     return mr.Pow(this, exp);
 }
            /// <summary>
            ///     Compares two BigInteger
            /// </summary>
            /// <param name="bi1">A BigInteger</param>
            /// <param name="bi2">A BigInteger</param>
            /// <returns>The sign of bi1 - bi2</returns>
            public static Sign Compare(BigInteger bi1, BigInteger bi2)
            {
                //
                // Step 1. Compare the lengths
                //
                uint l1 = bi1.length, l2 = bi2.length;

                while (l1 > 0 && bi1.data[l1 - 1] == 0) l1--;
                while (l2 > 0 && bi2.data[l2 - 1] == 0) l2--;

                if (l1 == 0 && l2 == 0) return Sign.Zero;

                // bi1 len < bi2 len
                if (l1 < l2) return Sign.Negative;
                    // bi1 len > bi2 len
                if (l1 > l2) return Sign.Positive;

                //
                // Step 2. Compare the bits
                //

                var pos = l1 - 1;

                while (pos != 0 && bi1.data[pos] == bi2.data[pos]) pos--;

                if (bi1.data[pos] < bi2.data[pos])
                    return Sign.Negative;
                if (bi1.data[pos] > bi2.data[pos])
                    return Sign.Positive;
                return Sign.Zero;
            }
            /// <summary>
            ///     Adds two numbers with the same sign.
            /// </summary>
            /// <param name="bi1">A BigInteger</param>
            /// <param name="bi2">A BigInteger</param>
            /// <returns>bi1 + bi2</returns>
            public static BigInteger AddSameSign(BigInteger bi1, BigInteger bi2)
            {
                uint[] x, y;
                uint yMax, xMax, i = 0;

                // x should be bigger
                if (bi1.length < bi2.length)
                {
                    x = bi2.data;
                    xMax = bi2.length;
                    y = bi1.data;
                    yMax = bi1.length;
                }
                else
                {
                    x = bi1.data;
                    xMax = bi1.length;
                    y = bi2.data;
                    yMax = bi2.length;
                }

                var result = new BigInteger(Sign.Positive, xMax + 1);

                var r = result.data;

                ulong sum = 0;

                // Add common parts of both numbers
                do
                {
                    sum = x[i] + ((ulong) y[i]) + sum;
                    r[i] = (uint) sum;
                    sum >>= 32;
                } while (++i < yMax);

                // Copy remainder of longer number while carry propagation is required
                var carry = (sum != 0);

                if (carry)
                {
                    if (i < xMax)
                    {
                        do
                            carry = ((r[i] = x[i] + 1) == 0); while (++i < xMax && carry);
                    }

                    if (carry)
                    {
                        r[i] = 1;
                        result.length = ++i;
                        return result;
                    }
                }

                // Copy the rest
                if (i < xMax)
                {
                    do
                        r[i] = x[i]; while (++i < xMax);
                }

                result.Normalize();
                return result;
            }
            public static BigInteger Subtract(BigInteger big, BigInteger small)
            {
                var result = new BigInteger(Sign.Positive, big.length);

                uint[] r = result.data, b = big.data, s = small.data;
                uint i = 0, c = 0;

                do
                {
                    var x = s[i];
                    if (((x += c) < c) | ((r[i] = b[i] - x) > ~x))
                        c = 1;
                    else
                        c = 0;
                } while (++i < small.length);

                if (i == big.length) goto fixup;

                if (c == 1)
                {
                    do
                        r[i] = b[i] - 1; while (b[i++] == 0 && i < big.length);

                    if (i == big.length) goto fixup;
                }

                do
                    r[i] = b[i]; while (++i < big.length);

                fixup:

                result.Normalize();
                return result;
            }
            public static BigInteger MultiplyByDword(BigInteger n, uint f)
            {
                var ret = new BigInteger(Sign.Positive, n.length + 1);

                uint i = 0;
                ulong c = 0;

                do
                {
                    c += n.data[i]*(ulong) f;
                    ret.data[i] = (uint) c;
                    c >>= 32;
                } while (++i < n.length);
                ret.data[i] = (uint) c;
                ret.Normalize();
                return ret;
            }
            public static void MinusEq(BigInteger big, BigInteger small)
            {
                uint[] b = big.data, s = small.data;
                uint i = 0, c = 0;

                do
                {
                    var x = s[i];
                    if (((x += c) < c) | ((b[i] -= x) > ~x))
                        c = 1;
                    else
                        c = 0;
                } while (++i < small.length);

                if (i == big.length) goto fixup;

                if (c == 1)
                {
                    do
                        b[i]--; while (b[i++] == 0 && i < big.length);
                }

                fixup:

                // Normalize length
                while (big.length > 0 && big.data[big.length - 1] == 0) big.length--;

                // Check for zero
                if (big.length == 0)
                    big.length++;
            }
            public static BigInteger gcd(BigInteger a, BigInteger b)
            {
                var x = a;
                var y = b;

                var g = y;

                while (x.length > 1)
                {
                    g = x;
                    x = y%x;
                    y = g;
                }
                if (x == 0) return g;

                // TODO: should we have something here if we can convert to long?

                //
                // Now we can just do it with single precision. I am using the binary gcd method,
                // as it should be faster.
                //

                var yy = x.data[0];
                var xx = y%yy;

                var t = 0;

                while (((xx | yy) & 1) == 0)
                {
                    xx >>= 1;
                    yy >>= 1;
                    t++;
                }
                while (xx != 0)
                {
                    while ((xx & 1) == 0) xx >>= 1;
                    while ((yy & 1) == 0) yy >>= 1;
                    if (xx >= yy)
                        xx = (xx - yy) >> 1;
                    else
                        yy = (yy - xx) >> 1;
                }

                return yy << t;
            }
            public static void PlusEq(BigInteger bi1, BigInteger bi2)
            {
                uint[] x, y;
                uint yMax, xMax, i = 0;
                var flag = false;

                // x should be bigger
                if (bi1.length < bi2.length)
                {
                    flag = true;
                    x = bi2.data;
                    xMax = bi2.length;
                    y = bi1.data;
                    yMax = bi1.length;
                }
                else
                {
                    x = bi1.data;
                    xMax = bi1.length;
                    y = bi2.data;
                    yMax = bi2.length;
                }

                var r = bi1.data;

                ulong sum = 0;

                // Add common parts of both numbers
                do
                {
                    sum += x[i] + ((ulong) y[i]);
                    r[i] = (uint) sum;
                    sum >>= 32;
                } while (++i < yMax);

                // Copy remainder of longer number while carry propagation is required
                var carry = (sum != 0);

                if (carry)
                {
                    if (i < xMax)
                    {
                        do
                            carry = ((r[i] = x[i] + 1) == 0); while (++i < xMax && carry);
                    }

                    if (carry)
                    {
                        r[i] = 1;
                        bi1.length = ++i;
                        return;
                    }
                }

                // Copy the rest
                if (flag && i < xMax - 1)
                {
                    do
                        r[i] = x[i]; while (++i < xMax);
                }

                bi1.length = xMax + 1;
                bi1.Normalize();
            }
            public ModulusRing(BigInteger modulus)
            {
                mod = modulus;

                // calculate constant = b^ (2k) / m
                var i = mod.length << 1;

                constant = new BigInteger(Sign.Positive, i + 1);
                constant.data[i] = 0x00000001;

                constant = constant/mod;
            }
 public BigInteger(BigInteger bi)
 {
     data = (uint[]) bi.data.Clone();
     length = bi.length;
 }