public static BigInteger[] multiByteDivide(BigInteger bi1, BigInteger bi2)
			{
				if (Kernel.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]);

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

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

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

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

				uint[] remainder = rem.data;

				bi2 = bi2 << shift;

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

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

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

					ulong q_hat = dividend / (ulong)firstDivisorByte;
					ulong r_hat = dividend % (ulong)firstDivisorByte;

					do
					{

						if (q_hat == 0x100000000 ||
							(q_hat * secondDivisorByte) > ((r_hat << 32) + remainder[pos - 2]))
						{
							q_hat--;
							r_hat += (ulong)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;
					int nPos = pos - divisorLen + 1;
					ulong mc = 0;
					uint uint_q_hat = (uint)q_hat;
					do
					{
						mc += (ulong)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 = ((ulong)remainder[nPos]) + ((ulong)bi2.data[dPos]) + sum;
							remainder[nPos] = (uint)sum;
							sum >>= 32;
							dPos++; nPos++;
						} while (dPos < divisorLen);

					}

					quot.data[resultPos--] = (uint)uint_q_hat;

					pos--;
					j--;
				}

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

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

				return ret;
			}
		public BigInteger ModInverse(BigInteger modulus)
		{
			return Kernel.modInverse(this, modulus);
		}
			public ModulusRing(BigInteger modulus)
			{
				this.mod = modulus;

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

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

				constant = constant / mod;
			}
		/// <summary>
		/// Generates a new, random BigInteger of the specified length.
		/// </summary>
		/// <param name="bits">The number of bits for the new number.</param>
		/// <param name="rng">A random number generator to use to obtain the bits.</param>
		/// <returns>A random number of the specified length.</returns>
		public static BigInteger GenerateRandom(int bits, RandomNumberGenerator rng)
		{
			int dwords = bits >> 5;
			int remBits = bits & 0x1F;

			if (remBits != 0)
				dwords++;

			BigInteger ret = new BigInteger(Sign.Positive, (uint)dwords + 1);
			byte[] random = new byte[dwords << 2];

			rng.GetBytes(random);
			Buffer.BlockCopy(random, 0, ret.data, 0, (int)dwords << 2);

			if (remBits != 0)
			{
				uint mask = (uint)(0x01 << (remBits - 1));
				ret.data[dwords - 1] |= mask;

				mask = (uint)(0xFFFFFFFF >> (32 - remBits));
				ret.data[dwords - 1] &= mask;
			}
			else
				ret.data[dwords - 1] |= 0x80000000;

			ret.Normalize();
			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";

			string result = "";

			BigInteger a = new BigInteger(this);

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

			return result;
		}
		public static BigInteger Divid(BigInteger bi, int i)
		{
			return (bi / i);
		}
		public static BigInteger Multiply(BigInteger bi1, BigInteger bi2)
		{
			return (bi1 * bi2);
		}
			public static uint modInverse(BigInteger bi, uint modulus)
			{
				uint a = modulus, b = bi % modulus;
				uint p0 = 0, p1 = 1;

				while (b != 0)
				{
					if (b == 1)
						return p1;
					p0 += (a / b) * p1;
					a %= b;

					if (a == 0)
						break;
					if (a == 1)
						return modulus - p0;

					p1 += (b / a) * p0;
					b %= a;

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

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

				int step = 0;

				BigInteger a = modulus;
				BigInteger b = bi;

				ModulusRing mr = new ModulusRing(modulus);

				while (b != 0)
				{

					if (step > 1)
					{

						BigInteger pval = mr.Difference(p[0], p[1] * q[0]);
						p[0] = p[1]; p[1] = pval;
					}

					BigInteger[] 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 unsafe void SquarePositive(BigInteger bi, ref uint[] wkSpace)
			{
				uint[] t = wkSpace;
				wkSpace = bi.data;
				uint[] d = bi.data;
				uint dl = bi.length;
				bi.data = t;

				fixed (uint* dd = d, tt = t)
				{

					uint* ttE = tt + t.Length;
					// Clear the dest
					for (uint* ttt = tt; ttt < ttE; ttt++)
						*ttt = 0;

					uint* dP = dd, tP = tt;

					for (uint i = 0; i < dl; i++, dP++)
					{
						if (*dP == 0)
							continue;

						ulong mcarry = 0;
						uint bi1val = *dP;

						uint* dP2 = dP + 1, tP2 = tP + 2 * i + 1;

						for (uint j = i + 1; j < dl; j++, tP2++, dP2++)
						{
							// k = i + j
							mcarry += ((ulong)bi1val * (ulong)*dP2) + *tP2;

							*tP2 = (uint)mcarry;
							mcarry >>= 32;
						}

						if (mcarry != 0)
							*tP2 = (uint)mcarry;
					}

					// Double t. Inlined for speed.

					tP = tt;

					uint x, carry = 0;
					while (tP < ttE)
					{
						x = *tP;
						*tP = (x << 1) | carry;
						carry = x >> (32 - 1);
						tP++;
					}
					if (carry != 0) *tP = carry;

					// Add in the diagnals

					dP = dd;
					tP = tt;
					for (uint* dE = dP + dl; (dP < dE); dP++, tP++)
					{
						ulong val = (ulong)*dP * (ulong)*dP + *tP;
						*tP = (uint)val;
						val >>= 32;
						*(++tP) += (uint)val;
						if (*tP < (uint)val)
						{
							uint* tP3 = tP;
							// Account for the first carry
							(*++tP3)++;

							// Keep adding until no carry
							while ((*tP3++) == 0)
								(*tP3)++;
						}

					}

					bi.length <<= 1;

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

				}
			}
			/* 
			 * Never called in BigInteger (and part of a private class)
			 * 			public static bool Double (uint [] u, int l)
						{
							uint x, carry = 0;
							uint i = 0;
							while (i < l) {
								x = u [i];
								u [i] = (x << 1) | carry;
								carry = x >> (32 - 1);
								i++;
							}
							if (carry != 0) u [l] = carry;
							return carry != 0;
						}*/

			#endregion

			#region Number Theory

			public static BigInteger gcd(BigInteger a, BigInteger b)
			{
				BigInteger x = a;
				BigInteger y = b;

				BigInteger 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.
				//

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

				int 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 BigInteger MultiplyByDword(BigInteger n, uint f)
			{
				BigInteger ret = new BigInteger(Sign.Positive, n.length + 1);

				uint i = 0;
				ulong c = 0;

				do
				{
					c += (ulong)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 BigInteger RightShift(BigInteger bi, int n)
			{
				if (n == 0) return new BigInteger(bi);

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

				BigInteger ret = new BigInteger(Sign.Positive, bi.length - (uint)w + 1);
				uint 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);

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

				BigInteger 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 uint Modulus(BigInteger bi, uint ui)
		{
			return (bi % ui);
		}
		/* This is the BigInteger.Parse method I use. This method works
		because BigInteger.ToString returns the input I gave to Parse. */
		public static BigInteger Parse(string number)
		{
			if (number == null)
				throw new ArgumentNullException("number");

			int i = 0, len = number.Length;
			char c;
			bool digits_seen = false;
			BigInteger val = new BigInteger(0);
			if (number[i] == '+')
			{
				i++;
			}
			else if (number[i] == '-')
			{
				throw new FormatException(WouldReturnNegVal);
			}

			for (; i < len; i++)
			{
				c = number[i];
				if (c == '\0')
				{
					i = len;
					continue;
				}
				if (c >= '0' && c <= '9')
				{
					val = val * 10 + (c - '0');
					digits_seen = true;
				}
				else
				{
					if (Char.IsWhiteSpace(c))
					{
						for (i++; i < len; i++)
						{
							if (!Char.IsWhiteSpace(number[i]))
								throw new FormatException();
						}
						break;
					}
					else
						throw new FormatException();
				}
			}
			if (!digits_seen)
				throw new FormatException();
			return val;
		}
		public static BigInteger Modulus(BigInteger bi1, BigInteger bi2)
		{
			return (bi1 % bi2);
		}
		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");

			BigInteger 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 static BigInteger Divid(BigInteger bi1, BigInteger bi2)
		{
			return (bi1 / bi2);
		}
		// with names suggested by FxCop 1.30

		public static BigInteger Add(BigInteger bi1, BigInteger bi2)
		{
			return (bi1 + bi2);
		}
		public static BigInteger Multiply(BigInteger bi, int i)
		{
			return (bi * i);
		}
		public static BigInteger Subtract(BigInteger bi1, BigInteger bi2)
		{
			return (bi1 - bi2);
		}
		public Sign Compare(BigInteger bi)
		{
			return Kernel.Compare(this, bi);
		}
		public BigInteger Modulus(BigInteger mod)
		{
			return BigInteger.Modulus(this, mod);
		}
		public BigInteger GCD(BigInteger bi)
		{
			return Kernel.gcd(this, bi);
		}
		public BigInteger Multiply(BigInteger mult)
		{
			return BigInteger.Multiply(this, mult);
		}
		public BigInteger ModPow(BigInteger exp, BigInteger n)
		{
			ModulusRing mr = new ModulusRing(n);
			return mr.Pow(this, exp);
		}
		public static int Modulus(BigInteger bi, int i)
		{
			return (bi % i);
		}
			public void BarrettReduction(BigInteger x)
			{
				BigInteger 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

				uint 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

				BigInteger 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
				{
					BigInteger 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 BigInteger(BigInteger bi, uint len)
		{

			this.data = new uint[len];

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

			this.length = bi.length;
		}