public void Add2BigIntXC3()
 {
     IntX int1 = new IntX(new uint[] { uint.MaxValue, uint.MaxValue }, false);
     IntX int2 = new IntX(new uint[] { 1, 1 }, false);
     IntX int3 = new IntX(new uint[] { 0, 1, 1 }, false);
     Assert.IsTrue(int1 + int2 == int3);
 }

 public void Simple()
 {
     IntX int1 = new IntX(8);
     int1 *= int1;
     int1.Normalize();
     Assert.IsTrue(int1 == 64);
 }

 public void Sub2BigIntXC4()
 {
     IntX int1 = new IntX(new uint[] { uint.MaxValue, uint.MaxValue, 1, 1 }, false);
     IntX int2 = new IntX(new uint[] { 1, 1 }, false);
     IntX int3 = new IntX(new uint[] { 0, 1, 2, 1 }, false);
     Assert.IsTrue(int1 == int3 - int2);
 }

 public void Big()
 {
     IntX int1 = new IntX(new uint[] {0, 0, 0x80000000U, 0x7fffffffU}, false);
     IntX int2 = new IntX(new uint[] {1, 0, 0x80000000U}, false);
     IntX intM = new IntX(new uint[] {2, 0xffffffffU, 0x7fffffffU}, false);
     Assert.IsTrue(int1 % int2 == intM);
 }

 public void Add2BigIntX()
 {
     IntX int1 = new IntX(new uint[] { 1, 2, 3 }, false);
     IntX int2 = new IntX(new uint[] { 3, 4, 5 }, false);
     IntX int3 = new IntX(new uint[] { 4, 6, 8 }, false);
     Assert.IsTrue(int1 + int2 == int3);
 }

 public void Big()
 {
     IntX int1   = new IntX(new uint[] { 1, 1 }, false);
     IntX int2   = new IntX(new uint[] { 1, 1 }, false);
     IntX intRes = new IntX(new uint[] { 1, 2, 1 }, false);
     Assert.AreEqual(int1 * int2, intRes);
 }

        /// <summary>
        /// Multiplies two big integers.
        /// </summary>
        /// <param name="int1">First big integer.</param>
        /// <param name="int2">Second big integer.</param>
        /// <returns>Resulting big integer.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="int1" /> or <paramref name="int2" /> is a null reference.</exception>
        /// <exception cref="ArgumentException"><paramref name="int1" /> or <paramref name="int2" /> is too big for multiply operation.</exception>
        public virtual IntX Multiply(IntX int1, IntX int2)
        {
            // Exceptions
            if (ReferenceEquals(int1, null))
            {
                throw new ArgumentNullException("int1", Strings.CantBeNull);
            }
            else if (ReferenceEquals(int2, null))
            {
                throw new ArgumentNullException("int2", Strings.CantBeNull);
            }

            // Special behavior for zero cases
            if (int1._length == 0 || int2._length == 0) return new IntX();

            // Get new big integer length and check it
            ulong newLength = (ulong)int1._length + int2._length;
            if (newLength >> 32 != 0)
            {
                throw new ArgumentException(Strings.IntegerTooBig);
            }

            // Create resulting big int
            IntX newInt = new IntX((uint)newLength, int1._negative ^ int2._negative);

            // Perform actual digits multiplication
            newInt._length = Multiply(int1._digits, int1._length, int2._digits, int2._length, newInt._digits);

            // Normalization may be needed
            newInt.TryNormalize();

            return newInt;
        }

 //Old GCD algorithm.
 public static IntX gcd(IntX a, IntX b) {
   if(b == 0) {
     return a;
   }else {
     return gcd(b, a % b);
   }
 }

 public void Big3()
 {
     IntX int1   = new IntX(new uint[] { uint.MaxValue, uint.MaxValue }, false);
     IntX int2   = new IntX(new uint[] { uint.MaxValue, uint.MaxValue }, false);
     IntX intRes = new IntX(new uint[] { 1, 0, uint.MaxValue - 1, uint.MaxValue }, false);
     Assert.IsTrue(int1 * int2 == intRes);
 }

 public void Sub2BigIntX()
 {
     IntX int1 = new IntX(new uint[] { 1, 2, 3 }, false);
     IntX int2 = new IntX(new uint[] { 3, 4, 5 }, false);
     IntX int3 = new IntX(new uint[] { 2, 2, 2 }, true);
     Assert.IsTrue(int1 - int2 == int3);
 }

 public void Add0IntXNeg()
 {
     IntX int1 = new IntX(-3);
     Assert.IsTrue(int1 + 0 == -3);
     Assert.IsTrue(int1 + new IntX() == -3);
     Assert.IsTrue(new IntX(0) + new IntX(-1) == -1);
 }

        public void ShouldBeFalseForZero()
        {
            IntX value = new IntX();

            bool result = value.IsOdd;

            Assert.That(result, Is.False);
        }

  //Generates p, q, and n.  Returns an array of p, q, and n in that order.
  public static IntX[] genN() {
    IntX[] output = new IntX[3];
    output[0] = genRandPrime();
    output[1] = genRandPrime();
    output[2] = output[0] * output[1];

    return output;
  }

 public void Performance()
 {
     IntX intX  = new IntX(new uint[] { 0, 1 }, false);
     IntX intX2 = intX;
     for (int i = 0; i < 1000; ++i) {
         intX2 *= intX;
     }
 }

 public void Big2()
 {
     IntX int1   = new IntX(new uint[] { 1, 1 }, false);
     IntX int2   = new IntX(new uint[] { 2 }, false);
     IntX intRes = new IntX(new uint[] { 2, 2 }, false);
     Assert.AreEqual(intRes, int1 * int2);
     Assert.AreEqual(intRes, int2 * int1);
 }

        public void ShouldBeTrueForOddNumber()
        {
            IntX value = new IntX(57);

            bool result = value.IsOdd;

            Assert.That(result, Is.True);
        }

        public void ShouldBeFalseForEvenNumber()
        {
            IntX value = new IntX(42);

            bool result = value.IsOdd;

            Assert.That(result, Is.False);
        }

 public void Sub0IntXNeg()
 {
     IntX int1 = new IntX(-3);
     Assert.IsTrue(int1 - 0 == -3);
     Assert.IsTrue(0 - int1 == 3);
     Assert.IsTrue(int1 - new IntX() == -3);
     Assert.IsTrue(new IntX() - int1 == 3);
 }

        public void ShouldOnesComplementZero()
        {
            IntX value = new IntX();

            IntX result = ~value;

            Assert.That(result, Is.EqualTo(0));
        }

        public void ShouldOnesComplementBigIntX()
        {
            IntX value = new IntX(new uint[] { 3, 5, uint.MaxValue }, false);

            IntX result = ~value;

            Assert.That(result, Is.EqualTo(new IntX(new uint[] { ~(uint)3, ~(uint)5 }, true)));
        }