public static BigInteger operator >>(BigInteger leftSide, int shiftCount)
{
if (leftSide == null)
{
throw new ArgumentNullException("leftSide");
}
DigitsArray digitsArray = new DigitsArray(leftSide.m_digits);
digitsArray.DataUsed = digitsArray.ShiftRight(shiftCount);
if (leftSide.IsNegative)
{
for (int i = digitsArray.Count - 1; i >= digitsArray.DataUsed; i--)
{
digitsArray[i] = DigitsArray.AllBits;
}
uint num = DigitsArray.HiBitSet;
for (int j = 0; j < DigitsArray.DataSizeBits; j++)
{
if ((digitsArray[digitsArray.DataUsed - 1] & num) == DigitsArray.HiBitSet)
{
break;
}
DigitsArray digitsArray2;
DigitsArray expr_92 = digitsArray2 = digitsArray;
int index;
int expr_9D = index = digitsArray.DataUsed - 1;
uint num2 = digitsArray2[index];
expr_92[expr_9D] = (num2 | num);
num >>= 1;
}
digitsArray.DataUsed = digitsArray.Count;
}
return(new BigInteger(digitsArray));
}
private static void MultiDivide(BigInteger leftSide, BigInteger rightSide, out BigInteger quotient, out BigInteger remainder)
{
BigInteger k;
object item;
if (rightSide.IsZero)
{
throw new DivideByZeroException();
}
uint num = rightSide.m_digits[rightSide.m_digits.DataUsed - 1];
int num1 = 0;
for (uint i = DigitsArray.HiBitSet; i != 0 && (num & i) == 0; i >>= 1)
{
num1++;
}
int dataUsed = leftSide.m_digits.DataUsed + 1;
uint[] numArray = new uint[dataUsed];
leftSide.m_digits.CopyTo(numArray, 0, leftSide.m_digits.DataUsed);
DigitsArray.ShiftLeft(numArray, num1);
rightSide <<= num1;
ulong item1 = (ulong)rightSide.m_digits[rightSide.m_digits.DataUsed - 1];
if (rightSide.m_digits.DataUsed >= 2)
{
item = rightSide.m_digits[rightSide.m_digits.DataUsed - 2];
}
else
{
item = null;
}
ulong num2 = (ulong)item;
int dataUsed1 = rightSide.m_digits.DataUsed + 1;
DigitsArray digitsArray = new DigitsArray(dataUsed1, dataUsed1);
uint[] numArray1 = new uint[leftSide.m_digits.Count + 1];
int num3 = 0;
ulong dataSizeBits = (ulong)((long)1 << (DigitsArray.DataSizeBits & 63));
int dataUsed2 = dataUsed - rightSide.m_digits.DataUsed;
int num4 = dataUsed - 1;
while (dataUsed2 > 0)
{
ulong dataSizeBits1 = ((ulong)numArray[num4] << (DigitsArray.DataSizeBits & 63)) + (ulong)numArray[num4 - 1];
ulong num5 = dataSizeBits1 / item1;
ulong num6 = dataSizeBits1 % item1;
while (true)
{
if (num4 < 2)
{
goto Label0;
}
if (num5 != dataSizeBits && num5 * num2 <= (num6 << (DigitsArray.DataSizeBits & 63)) + (ulong)numArray[num4 - 2])
{
break;
}
num5 -= (long)1;
num6 += item1;
if (num6 >= dataSizeBits)
{
break;
}
}
for (int j = 0; j < dataUsed1; j++)
{
digitsArray[dataUsed1 - j - 1] = numArray[num4 - j];
}
BigInteger bigInteger = new BigInteger(digitsArray);
for (k = rightSide * num5; k > bigInteger; k -= rightSide)
{
num5 -= (long)1;
}
k = bigInteger - k;
for (int l = 0; l < dataUsed1; l++)
{
numArray[num4 - l] = k.m_digits[rightSide.m_digits.DataUsed - l];
}
int num7 = num3;
num3 = num7 + 1;
numArray1[num7] = (uint)num5;
dataUsed2--;
num4--;
}
Array.Reverse(numArray1, 0, num3);
quotient = new BigInteger(new DigitsArray(numArray1));
int num8 = DigitsArray.ShiftRight(numArray, num1);
DigitsArray digitsArray1 = new DigitsArray(num8, num8);
digitsArray1.CopyFrom(numArray, 0, 0, digitsArray1.DataUsed);
remainder = new BigInteger(digitsArray1);
}
private static void MultiDivide(BigInteger leftSide, BigInteger rightSide, out BigInteger quotient, out BigInteger remainder)
{
if (rightSide.IsZero)
{
throw new DivideByZeroException();
}
uint num = rightSide.m_digits[rightSide.m_digits.DataUsed - 1];
int num2 = 0;
uint num3 = DigitsArray.HiBitSet;
while (num3 != 0u && (num & num3) == 0u)
{
num2++;
num3 >>= 1;
}
int num4 = leftSide.m_digits.DataUsed + 1;
uint[] array = new uint[num4];
leftSide.m_digits.CopyTo(array, 0, leftSide.m_digits.DataUsed);
DigitsArray.ShiftLeft(array, num2);
rightSide <<= num2;
ulong num5 = (ulong)rightSide.m_digits[rightSide.m_digits.DataUsed - 1];
ulong num6 = (ulong)((rightSide.m_digits.DataUsed >= 2) ? rightSide.m_digits[rightSide.m_digits.DataUsed - 2] : 0u);
int num7 = rightSide.m_digits.DataUsed + 1;
DigitsArray digitsArray = new DigitsArray(num7, num7);
uint[] array2 = new uint[leftSide.m_digits.Count + 1];
int num8 = 0;
ulong num9 = 1uL << DigitsArray.DataSizeBits;
int i = num4 - rightSide.m_digits.DataUsed;
int j = num4 - 1;
while (i > 0)
{
ulong num10 = ((ulong)array[j] << DigitsArray.DataSizeBits) + (ulong)array[j - 1];
ulong num11 = num10 / num5;
ulong num12 = num10 % num5;
while (j >= 2)
{
if (num11 == num9 || num11 * num6 > (num12 << DigitsArray.DataSizeBits) + (ulong)array[j - 2])
{
num11 -= 1uL;
num12 += num5;
if (num12 < num9)
{
continue;
}
}
break;
}
for (int k = 0; k < num7; k++)
{
digitsArray[num7 - k - 1] = array[j - k];
}
BigInteger bigInteger = new BigInteger(digitsArray);
BigInteger bigInteger2 = rightSide * (long)num11;
while (bigInteger2 > bigInteger)
{
num11 -= 1uL;
bigInteger2 -= rightSide;
}
bigInteger2 = bigInteger - bigInteger2;
for (int l = 0; l < num7; l++)
{
array[j - l] = bigInteger2.m_digits[rightSide.m_digits.DataUsed - l];
}
array2[num8++] = (uint)num11;
i--;
j--;
}
Array.Reverse(array2, 0, num8);
quotient = new BigInteger(new DigitsArray(array2));
int num13 = DigitsArray.ShiftRight(array, num2);
DigitsArray digitsArray2 = new DigitsArray(num13, num13);
digitsArray2.CopyFrom(array, 0, 0, digitsArray2.DataUsed);
remainder = new BigInteger(digitsArray2);
}
internal int ShiftRight(int shiftCount)
{
return(DigitsArray.ShiftRight(this.m_data, shiftCount));
}
