[Serializable]
public struct BigInteger : IFormattable, IComparable, IComparable<BigInteger>, IEquatable<BigInteger>
{
    internal uint[] _bits;

    internal int _sign;

    private const int DecimalScaleFactorMask = 16711680;

    private const int DecimalSignMask = -2147483648;

    private const int kcbitUint = 32;

    private const int kcbitUlong = 64;

    private const int knMaskHighBit = -2147483648;

    private const uint kuMaskHighBit = 2147483648;

    private readonly static BigInteger s_bnMinInt;

    private readonly static BigInteger s_bnMinusOneInt;

    private readonly static BigInteger s_bnOneInt;

    private readonly static BigInteger s_bnZeroInt;

    internal uint[] _Bits
    {
        get
        {
            return this._bits;
        }
    }

    internal int _Sign
    {
        get
        {
            return this._sign;
        }
    }

    public bool IsEven
    {
        get
        {
            if (this._bits == null)
            {
                return (this._sign & 1) == 0;
            }
            else
            {
                return (this._bits[0] & 1) == 0;
            }
        }
    }

    public bool IsOne
    {
        get
        {
            if (this._sign != 1)
            {
                return false;
            }
            else
            {
                return this._bits == null;
            }
        }
    }

    public bool IsPowerOfTwo
    {
        get
        {
            if (this._bits != null)
            {
                if (this._sign == 1)
                {
                    int num = BigInteger.Length(this._bits) - 1;
                    if ((this._bits[num] & this._bits[num] - 1) == 0)
                    {
                        do
                        {
                            int num1 = num - 1;
                            num = num1;
                            if (num1 >= 0)
                            {
                                continue;
                            }
                            return true;
                        }
                        while (this._bits[num] == 0);
                        return false;
                    }
                    else
                    {
                        return false;
                    }
                }
                else
                {
                    return false;
                }
            }
            else
            {
                if ((this._sign & this._sign - 1) != 0)
                {
                    return false;
                }
                else
                {
                    return this._sign != 0;
                }
            }
        }
    }

    public bool IsZero
    {
        get
        {
            return this._sign == 0;
        }
    }

    public static BigInteger MinusOne
    {
        [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
        get
        {
            return BigInteger.s_bnMinusOneInt;
        }
    }

    public static BigInteger One
    {
        [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
        get
        {
            return BigInteger.s_bnOneInt;
        }
    }

    public int Sign
    {
        get
        {
            return (this._sign >> 31) - (-this._sign >> 31);
        }
    }

    public static BigInteger Zero
    {
        [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
        get
        {
            return BigInteger.s_bnZeroInt;
        }
    }

    static BigInteger()
    {
        uint[] numArray = new uint[1];
        numArray[0] = -2147483648;
        BigInteger.s_bnMinInt = new BigInteger(-1, numArray);
        BigInteger.s_bnOneInt = new BigInteger(1);
        BigInteger.s_bnZeroInt = new BigInteger(0);
        BigInteger.s_bnMinusOneInt = new BigInteger(-1);
    }

    public BigInteger(int value)
    {
        if (value != -2147483648)
        {
            this._sign = value;
            this._bits = null;
            return;
        }
        else
        {
            *(this) = BigInteger.s_bnMinInt;
            return;
        }
    }

    [CLSCompliant(false)]
    public BigInteger(uint value)
    {
        if (value > 2147483647)
        {
            this._sign = 1;
            this._bits = new uint[1];
            this._bits[0] = value;
            return;
        }
        else
        {
            this._sign = value;
            this._bits = null;
            return;
        }
    }

    public BigInteger(long value)
    {
        ulong num;
        if ((long)-2147483648 > value || value > (long)2147483647)
        {
            if (value >= (long)0)
            {
                num = value;
                this._sign = 1;
            }
            else
            {
                num = -value;
                this._sign = -1;
            }
            this._bits = new uint[2];
            this._bits[0] = (uint)num;
            this._bits[1] = (uint)(num >> 32);
            return;
        }
        else
        {
            if (value != (long)-2147483648)
            {
                this._sign = (int)value;
                this._bits = null;
                return;
            }
            else
            {
                *(this) = BigInteger.s_bnMinInt;
                return;
            }
        }
    }

    [CLSCompliant(false)]
    public BigInteger(ulong value)
    {
        if (value > (long)2147483647)
        {
            this._sign = 1;
            this._bits = new uint[2];
            this._bits[0] = (uint)value;
            this._bits[1] = (uint)(value >> 32);
            return;
        }
        else
        {
            this._sign = (int)value;
            this._bits = null;
            return;
        }
    }

    public BigInteger(float value)
    {
        if (!float.IsInfinity(value))
        {
            if (!float.IsNaN(value))
            {
                this._sign = 0;
                this._bits = null;
                this.SetBitsFromDouble((double)value);
                return;
            }
            else
            {
                throw new OverflowException(SR.GetString("Overflow_NotANumber"));
            }
        }
        else
        {
            throw new OverflowException(SR.GetString("Overflow_BigIntInfinity"));
        }
    }

    public BigInteger(double value)
    {
        if (!double.IsInfinity(value))
        {
            if (!double.IsNaN(value))
            {
                this._sign = 0;
                this._bits = null;
                this.SetBitsFromDouble(value);
                return;
            }
            else
            {
                throw new OverflowException(SR.GetString("Overflow_NotANumber"));
            }
        }
        else
        {
            throw new OverflowException(SR.GetString("Overflow_BigIntInfinity"));
        }
    }

    public BigInteger(decimal value)
    {
        byte num;
        int num1;
        int[] bits = decimal.GetBits(decimal.Truncate(value));
        int num2 = 3;
        while (num2 > 0 && bits[num2 - 1] == 0)
        {
            num2--;
        }
        if (num2 != 0)
        {
            if (num2 != 1 || bits[0] <= 0)
            {
                this._bits = new uint[num2];
                this._bits[0] = bits[0];
                if (num2 > 1)
                {
                    this._bits[1] = bits[1];
                }
                if (num2 > 2)
                {
                    this._bits[2] = bits[2];
                }
                BigInteger bigInteger = this;
                if ((bits[3] & -2147483648) != 0)
                {
                    num = -1;
                }
                else
                {
                    num = 1;
                }
                bigInteger._sign = (int)num;
                return;
            }
            else
            {
                this._sign = bits[0];
                BigInteger bigInteger1 = this;
                int num3 = bigInteger1._sign;
                if ((bits[3] & -2147483648) != 0)
                {
                    num1 = -1;
                }
                else
                {
                    num1 = 1;
                }
                bigInteger1._sign = num3 * num1;
                this._bits = null;
                return;
            }
        }
        else
        {
            *(this) = BigInteger.s_bnZeroInt;
            return;
        }
    }

    [CLSCompliant(false)]
    public BigInteger(byte[] value)
    {
        bool flag;
        int num;
        int num1;
        if (value != null)
        {
            int length = (int)value.Length;
            if (length <= 0)
            {
                flag = false;
            }
            else
            {
                flag = (value[length - 1] & 128) == 128;
            }
            bool flag1 = flag;
            while (length > 0 && value[length - 1] == 0)
            {
                length--;
            }
            if (length != 0)
            {
                if (length > 4)
                {
                    int num2 = length % 4;
                    int num3 = length / 4;
                    if (num2 == 0)
                    {
                        num = 0;
                    }
                    else
                    {
                        num = 1;
                    }
                    int num4 = num3 + num;
                    bool flag2 = true;
                    uint[] numArray = new uint[num4];
                    int j = 3;
                    int num5 = 0;
                    while (true)
                    {
                        int num6 = num5;
                        int num7 = num4;
                        if (num2 == 0)
                        {
                            num1 = 0;
                        }
                        else
                        {
                            num1 = 1;
                        }
                        if (num6 >= num7 - num1)
                        {
                            break;
                        }
                        for (int i = 0; i < 4; i++)
                        {
                            if (value[j] != 0)
                            {
                                flag2 = false;
                            }
                            numArray[num5] = numArray[num5] << 8;
                            numArray[num5] = numArray[num5] | value[j];
                            j--;
                        }
                        j = j + 8;
                        num5++;
                    }
                    if (num2 != 0)
                    {
                        if (flag1)
                        {
                            numArray[num4 - 1] = -1;
                        }
                        for (j = length - 1; j >= length - num2; j--)
                        {
                            if (value[j] != 0)
                            {
                                flag2 = false;
                            }
                            numArray[num5] = numArray[num5] << 8;
                            numArray[num5] = numArray[num5] | value[j];
                        }
                    }
                    if (!flag2)
                    {
                        if (!flag1)
                        {
                            this._sign = 1;
                            this._bits = numArray;
                        }
                        else
                        {
                            NumericsHelpers.DangerousMakeTwosComplement(numArray);
                            int length1 = (int)numArray.Length;
                            while (length1 > 0 && numArray[length1 - 1] == 0)
                            {
                                length1--;
                            }
                            if (length1 != 1 || numArray[0] <= 0)
                            {
                                if (length1 == (int)numArray.Length)
                                {
                                    this._sign = -1;
                                    this._bits = numArray;
                                    return;
                                }
                                else
                                {
                                    this._sign = -1;
                                    this._bits = new uint[length1];
                                    Array.Copy(numArray, this._bits, length1);
                                    return;
                                }
                            }
                            else
                            {
                                if (numArray[0] != 1)
                                {
                                    if (numArray[0] != -2147483648)
                                    {
                                        this._sign = -1 * numArray[0];
                                        this._bits = null;
                                        return;
                                    }
                                    else
                                    {
                                        *(this) = BigInteger.s_bnMinInt;
                                        return;
                                    }
                                }
                                else
                                {
                                    *(this) = BigInteger.s_bnMinusOneInt;
                                    return;
                                }
                            }
                        }
                    }
                    else
                    {
                        *(this) = BigInteger.s_bnZeroInt;
                        return;
                    }
                }
                else
                {
                    if (!flag1)
                    {
                        this._sign = 0;
                    }
                    else
                    {
                        this._sign = -1;
                    }
                    for (int k = length - 1; k >= 0; k--)
                    {
                        BigInteger bigInteger = this;
                        bigInteger._sign = bigInteger._sign << 8;
                        BigInteger bigInteger1 = this;
                        bigInteger1._sign = bigInteger1._sign | value[k];
                    }
                    this._bits = null;
                    if (this._sign < 0 && !flag1)
                    {
                        this._bits = new uint[1];
                        this._bits[0] = this._sign;
                        this._sign = 1;
                    }
                    if (this._sign == -2147483648)
                    {
                        *(this) = BigInteger.s_bnMinInt;
                        return;
                    }
                }
                return;
            }
            else
            {
                this._sign = 0;
                this._bits = null;
                return;
            }
        }
        else
        {
            throw new ArgumentNullException("value");
        }
    }

    internal BigInteger(int n, uint[] rgu)
    {
        this._sign = n;
        this._bits = rgu;
    }

    internal BigInteger(uint[] value, bool negative)
    {
        byte num;
        uint num1;
        if (value != null)
        {
            int length = (int)value.Length;
            while (length > 0 && value[length - 1] == 0)
            {
                length--;
            }
            if (length != 0)
            {
                if (length != 1 || value[0] >= -2147483648)
                {
                    BigInteger bigInteger = this;
                    if (negative)
                    {
                        num = -1;
                    }
                    else
                    {
                        num = 1;
                    }
                    bigInteger._sign = (int)num;
                    this._bits = new uint[length];
                    Array.Copy(value, this._bits, length);
                }
                else
                {
                    BigInteger bigInteger1 = this;
                    if (negative)
                    {
                        num1 = -value[0];
                    }
                    else
                    {
                        num1 = value[0];
                    }
                    bigInteger1._sign = (int)num1;
                    this._bits = null;
                    if (this._sign == -2147483648)
                    {
                        *(this) = BigInteger.s_bnMinInt;
                        return;
                    }
                }
                return;
            }
            else
            {
                *(this) = BigInteger.s_bnZeroInt;
                return;
            }
        }
        else
        {
            throw new ArgumentNullException("value");
        }
    }

    private BigInteger(uint[] value)
    {
        bool flag;
        if (value != null)
        {
            int length = (int)value.Length;
            if (length <= 0)
            {
                flag = false;
            }
            else
            {
                flag = (value[length - 1] & -2147483648) == -2147483648;
            }
            bool flag1 = flag;
            while (length > 0 && value[length - 1] == 0)
            {
                length--;
            }
            if (length != 0)
            {
                if (length != 1)
                {
                    if (flag1)
                    {
                        NumericsHelpers.DangerousMakeTwosComplement(value);
                        int num = (int)value.Length;
                        while (num > 0 && value[num - 1] == 0)
                        {
                            num--;
                        }
                        if (num != 1 || value[0] <= 0)
                        {
                            if (num == (int)value.Length)
                            {
                                this._sign = -1;
                                this._bits = value;
                                return;
                            }
                            else
                            {
                                this._sign = -1;
                                this._bits = new uint[num];
                                Array.Copy(value, this._bits, num);
                                return;
                            }
                        }
                        else
                        {
                            if (value[0] != 1)
                            {
                                if (value[0] != -2147483648)
                                {
                                    this._sign = -1 * value[0];
                                    this._bits = null;
                                    return;
                                }
                                else
                                {
                                    *(this) = BigInteger.s_bnMinInt;
                                    return;
                                }
                            }
                            else
                            {
                                *(this) = BigInteger.s_bnMinusOneInt;
                                return;
                            }
                        }
                    }
                    else
                    {
                        if (length == (int)value.Length)
                        {
                            this._sign = 1;
                            this._bits = value;
                            return;
                        }
                        else
                        {
                            this._sign = 1;
                            this._bits = new uint[length];
                            Array.Copy(value, this._bits, length);
                            return;
                        }
                    }
                }
                else
                {
                    if (value[0] >= 0 || flag1)
                    {
                        if (-2147483648 != value[0])
                        {
                            this._sign = value[0];
                            this._bits = null;
                            return;
                        }
                        else
                        {
                            *(this) = BigInteger.s_bnMinInt;
                            return;
                        }
                    }
                    else
                    {
                        this._bits = new uint[1];
                        this._bits[0] = value[0];
                        this._sign = 1;
                        return;
                    }
                }
            }
            else
            {
                *(this) = BigInteger.s_bnZeroInt;
                return;
            }
        }
        else
        {
            throw new ArgumentNullException("value");
        }
    }

    public static BigInteger Abs(BigInteger value)
    {
        if (value >= BigInteger.Zero)
        {
            return value;
        }
        else
        {
            return -value;
        }
    }

    [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
    public static BigInteger Add(BigInteger left, BigInteger right)
    {
        return left + right;
    }

    [Conditional("DEBUG")]
    private void AssertValid()
    {
        if (this._bits != null)
        {
            BigInteger.Length(this._bits);
        }
    }

    internal static int BitLengthOfUInt(uint x)
    {
        int num = 0;
        while (x > 0)
        {
            x = x >> 1;
            num++;
        }
        return num;
    }

    public static int Compare(BigInteger left, BigInteger right)
    {
        return left.CompareTo(right);
    }

    public int CompareTo(long other)
    {
        long num;
        ulong num1;
        if (this._bits != null)
        {
            if (((long)this._sign ^ other) >= (long)0)
            {
                int num2 = BigInteger.Length(this._bits);
                int num3 = num2;
                if (num2 <= 2)
                {
                    if (other < (long)0)
                    {
                        num = -other;
                    }
                    else
                    {
                        num = other;
                    }
                    ulong num4 = (ulong)num;
                    if (num3 == 2)
                    {
                        num1 = NumericsHelpers.MakeUlong(this._bits[1], this._bits[0]);
                    }
                    else
                    {
                        num1 = (ulong)this._bits[0];
                    }
                    ulong num5 = num1;
                    return this._sign * num5.CompareTo(num4);
                }
            }
            return this._sign;
        }
        else
        {
            long num6 = (long)this._sign;
            return num6.CompareTo(other);
        }
    }

    [CLSCompliant(false)]
    public int CompareTo(ulong other)
    {
        ulong num;
        if (this._sign >= 0)
        {
            if (this._bits != null)
            {
                int num1 = BigInteger.Length(this._bits);
                if (num1 <= 2)
                {
                    if (num1 == 2)
                    {
                        num = NumericsHelpers.MakeUlong(this._bits[1], this._bits[0]);
                    }
                    else
                    {
                        num = (ulong)this._bits[0];
                    }
                    ulong num2 = num;
                    return num2.CompareTo(other);
                }
                else
                {
                    return 1;
                }
            }
            else
            {
                ulong num3 = (long)this._sign;
                return num3.CompareTo(other);
            }
        }
        else
        {
            return -1;
        }
    }

    public int CompareTo(BigInteger other)
    {
        if ((this._sign ^ other._sign) >= 0)
        {
            if (this._bits != null)
            {
                if (other._bits != null)
                {
                    int num = BigInteger.Length(this._bits);
                    int num1 = num;
                    int num2 = BigInteger.Length(other._bits);
                    int num3 = num2;
                    if (num <= num2)
                    {
                        if (num1 >= num3)
                        {
                            int diffLength = BigInteger.GetDiffLength(this._bits, other._bits, num1);
                            if (diffLength != 0)
                            {
                                if (this._bits[diffLength - 1] < other._bits[diffLength - 1])
                                {
                                    return -this._sign;
                                }
                                else
                                {
                                    return this._sign;
                                }
                            }
                            else
                            {
                                return 0;
                            }
                        }
                        else
                        {
                            return -this._sign;
                        }
                    }
                }
                return this._sign;
            }
            else
            {
                if (other._bits != null)
                {
                    return -other._sign;
                }
                else
                {
                    if (this._sign < other._sign)
                    {
                        return -1;
                    }
                    else
                    {
                        if (this._sign > other._sign)
                        {
                            return 1;
                        }
                        else
                        {
                            return 0;
                        }
                    }
                }
            }
        }
        else
        {
            if (this._sign < 0)
            {
                return -1;
            }
            else
            {
                return 1;
            }
        }
    }

    public int CompareTo(object obj)
    {
        if (obj != null)
        {
            if (obj as BigInteger != null)
            {
                return this.CompareTo((BigInteger)obj);
            }
            else
            {
                throw new ArgumentException(SR.GetString("Argument_MustBeBigInt"));
            }
        }
        else
        {
            return 1;
        }
    }

    [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
    public static BigInteger Divide(BigInteger dividend, BigInteger divisor)
    {
        return dividend / divisor;
    }

    public static BigInteger DivRem(BigInteger dividend, BigInteger divisor, out BigInteger remainder)
    {
        int num = 1;
        int num1 = 1;
        BigIntegerBuilder bigIntegerBuilder = new BigIntegerBuilder(dividend, ref num);
        BigIntegerBuilder bigIntegerBuilder1 = new BigIntegerBuilder(divisor, ref num1);
        BigIntegerBuilder bigIntegerBuilder2 = new BigIntegerBuilder();
        bigIntegerBuilder.ModDiv(ref bigIntegerBuilder1, ref bigIntegerBuilder2);
        remainder = bigIntegerBuilder.GetInteger(num);
        return bigIntegerBuilder2.GetInteger(num * num1);
    }

    public override bool Equals(object obj)
    {
        if (obj as BigInteger != null)
        {
            return this.Equals((BigInteger)obj);
        }
        else
        {
            return false;
        }
    }

    public bool Equals(long other)
    {
        long num;
        if (this._bits != null)
        {
            if (((long)this._sign ^ other) >= (long)0)
            {
                int num1 = BigInteger.Length(this._bits);
                int num2 = num1;
                if (num1 <= 2)
                {
                    if (other < (long)0)
                    {
                        num = -other;
                    }
                    else
                    {
                        num = other;
                    }
                    ulong num3 = (ulong)num;
                    if (num2 != 1)
                    {
                        return NumericsHelpers.MakeUlong(this._bits[1], this._bits[0]) == num3;
                    }
                    else
                    {
                        return (ulong)this._bits[0] == num3;
                    }
                }
            }
            return false;
        }
        else
        {
            return (long)this._sign == other;
        }
    }

    [CLSCompliant(false)]
    public bool Equals(ulong other)
    {
        if (this._sign >= 0)
        {
            if (this._bits != null)
            {
                int num = BigInteger.Length(this._bits);
                if (num <= 2)
                {
                    if (num != 1)
                    {
                        return NumericsHelpers.MakeUlong(this._bits[1], this._bits[0]) == other;
                    }
                    else
                    {
                        return (ulong)this._bits[0] == other;
                    }
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return (long)this._sign == other;
            }
        }
        else
        {
            return false;
        }
    }

    public bool Equals(BigInteger other)
    {
        if (this._sign == other._sign)
        {
            if (this._bits != other._bits)
            {
                if (this._bits == null || other._bits == null)
                {
                    return false;
                }
                else
                {
                    int num = BigInteger.Length(this._bits);
                    if (num == BigInteger.Length(other._bits))
                    {
                        int diffLength = BigInteger.GetDiffLength(this._bits, other._bits, num);
                        return diffLength == 0;
                    }
                    else
                    {
                        return false;
                    }
                }
            }
            else
            {
                return true;
            }
        }
        else
        {
            return false;
        }
    }

    internal static int GetDiffLength(uint[] rgu1, uint[] rgu2, int cu)
    {
        int num = cu;
        do
        {
            int num1 = num - 1;
            num = num1;
            if (num1 >= 0)
            {
                continue;
            }
            return 0;
        }
        while (rgu1[num] == rgu2[num]);
        return num + 1;
    }

    public override int GetHashCode()
    {
        if (this._bits != null)
        {
            int num = this._sign;
            int num1 = BigInteger.Length(this._bits);
            while (true)
            {
                int num2 = num1 - 1;
                num1 = num2;
                if (num2 < 0)
                {
                    break;
                }
                num = NumericsHelpers.CombineHash(num, this._bits[num1]);
            }
            return num;
        }
        else
        {
            return this._sign;
        }
    }

    private static bool GetPartsForBitManipulation(ref BigInteger x, out uint[] xd, out int xl)
    {
        int length;
        if (x._bits != null)
        {
            xd = x._bits;
        }
        else
        {
            if (x._sign >= 0)
            {
                uint[] numArray = new uint[1];
                numArray[0] = x._sign;
                xd = numArray;
            }
            else
            {
                uint[] numArray1 = new uint[1];
                numArray1[0] = -x._sign;
                xd = numArray1;
            }
        }
        int& numPointer = xl;
        if (x._bits == null)
        {
            length = 1;
        }
        else
        {
            length = (int)x._bits.Length;
        }
        *(numPointer) = length;
        return x._sign < 0;
    }

    public static BigInteger GreatestCommonDivisor(BigInteger left, BigInteger right)
    {
        if (left._sign != 0)
        {
            if (right._sign != 0)
            {
                BigIntegerBuilder bigIntegerBuilder = new BigIntegerBuilder(left);
                BigIntegerBuilder bigIntegerBuilder1 = new BigIntegerBuilder(right);
                BigIntegerBuilder.GCD(ref bigIntegerBuilder, ref bigIntegerBuilder1);
                return bigIntegerBuilder.GetInteger(1);
            }
            else
            {
                return BigInteger.Abs(left);
            }
        }
        else
        {
            return BigInteger.Abs(right);
        }
    }

    internal static int Length(uint[] rgu)
    {
        int length = (int)rgu.Length;
        if (rgu[length - 1] == 0)
        {
            return length - 1;
        }
        else
        {
            return length;
        }
    }

    [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
    public static double Log(BigInteger value)
    {
        return BigInteger.Log(value, 2.71828182845905);
    }

    public static double Log(BigInteger value, double baseValue)
    {
        if (value._sign < 0 || baseValue == 1)
        {
            return double.NaN;
        }
        else
        {
            if (baseValue != double.PositiveInfinity)
            {
                if (baseValue != 0 || value.IsOne)
                {
                    if (value._bits != null)
                    {
                        double num = 0;
                        double num1 = 0.5;
                        int num2 = BigInteger.Length(value._bits);
                        int num3 = BigInteger.BitLengthOfUInt(value._bits[num2 - 1]);
                        int num4 = (num2 - 1) * 32 + num3;
                        uint num5 = 1 << (num3 - 1 & 31);
                        for (int i = num2 - 1; i >= 0; i--)
                        {
                            while (num5 != 0)
                            {
                                if ((value._bits[i] & num5) != 0)
                                {
                                    num = num + num1;
                                }
                                num1 = num1 * 0.5;
                                num5 = num5 >> 1;
                            }
                            num5 = -2147483648;
                        }
                        return (Math.Log(num) + 0.693147180559945 * (double)num4) / Math.Log(baseValue);
                    }
                    else
                    {
                        return Math.Log((double)value._sign, baseValue);
                    }
                }
                else
                {
                    return double.NaN;
                }
            }
            else
            {
                if (value.IsOne)
                {
                    return 0;
                }
                else
                {
                    return double.NaN;
                }
            }
        }
    }

    [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
    public static double Log10(BigInteger value)
    {
        return BigInteger.Log(value, 10);
    }

    public static BigInteger Max(BigInteger left, BigInteger right)
    {
        if (left.CompareTo(right) >= 0)
        {
            return left;
        }
        else
        {
            return right;
        }
    }

    public static BigInteger Min(BigInteger left, BigInteger right)
    {
        if (left.CompareTo(right) > 0)
        {
            return right;
        }
        else
        {
            return left;
        }
    }

    public static BigInteger ModPow(BigInteger value, BigInteger exponent, BigInteger modulus)
    {
        byte num;
        if (exponent.Sign >= 0)
        {
            int num1 = 1;
            int num2 = 1;
            int num3 = 1;
            bool isEven = exponent.IsEven;
            BigIntegerBuilder bigIntegerBuilder = new BigIntegerBuilder(BigInteger.One, ref num1);
            BigIntegerBuilder bigIntegerBuilder1 = new BigIntegerBuilder(value, ref num2);
            BigIntegerBuilder bigIntegerBuilder2 = new BigIntegerBuilder(modulus, ref num3);
            BigIntegerBuilder bigIntegerBuilder3 = new BigIntegerBuilder(bigIntegerBuilder1.Size);
            bigIntegerBuilder.Mod(ref bigIntegerBuilder2);
            if (exponent._bits != null)
            {
                int num4 = BigInteger.Length(exponent._bits);
                for (int i = 0; i < num4 - 1; i++)
                {
                    uint num5 = exponent._bits[i];
                    BigInteger.ModPowInner32(num5, ref bigIntegerBuilder, ref bigIntegerBuilder1, ref bigIntegerBuilder2, ref bigIntegerBuilder3);
                }
                BigInteger.ModPowInner(exponent._bits[num4 - 1], ref bigIntegerBuilder, ref bigIntegerBuilder1, ref bigIntegerBuilder2, ref bigIntegerBuilder3);
            }
            else
            {
                BigInteger.ModPowInner(exponent._sign, ref bigIntegerBuilder, ref bigIntegerBuilder1, ref bigIntegerBuilder2, ref bigIntegerBuilder3);
            }
            BigIntegerBuilder& bigIntegerBuilderPointer = &bigIntegerBuilder;
            if (value._sign > 0)
            {
                num = 1;
            }
            else
            {
                if (isEven)
                {
                    num = 1;
                }
                else
                {
                    num = -1;
                }
            }
            return bigIntegerBuilderPointer.GetInteger(num);
        }
        else
        {
            throw new ArgumentOutOfRangeException("exponent", SR.GetString("ArgumentOutOfRange_MustBeNonNeg"));
        }
    }

    private static void ModPowInner(uint exp, ref BigIntegerBuilder regRes, ref BigIntegerBuilder regVal, ref BigIntegerBuilder regMod, ref BigIntegerBuilder regTmp)
    {
        while (exp != 0)
        {
            if ((exp & 1) == 1)
            {
                BigInteger.ModPowUpdateResult(ref regRes, ref regVal, ref regMod, ref regTmp);
            }
            if (exp != 1)
            {
                BigInteger.ModPowSquareModValue(ref regVal, ref regMod, ref regTmp);
                exp = exp >> 1;
            }
            else
            {
                return;
            }
        }
    }

    private static void ModPowInner32(uint exp, ref BigIntegerBuilder regRes, ref BigIntegerBuilder regVal, ref BigIntegerBuilder regMod, ref BigIntegerBuilder regTmp)
    {
        for (int i = 0; i < 32; i++)
        {
            if ((exp & 1) == 1)
            {
                BigInteger.ModPowUpdateResult(ref regRes, ref regVal, ref regMod, ref regTmp);
            }
            BigInteger.ModPowSquareModValue(ref regVal, ref regMod, ref regTmp);
            exp = exp >> 1;
        }
    }

    private static void ModPowSquareModValue(ref BigIntegerBuilder regVal, ref BigIntegerBuilder regMod, ref BigIntegerBuilder regTmp)
    {
        NumericsHelpers.<BigIntegerBuilder>(ref regVal, ref regTmp);
        regVal.Mul(ref regTmp, ref regTmp);
        regVal.Mod(ref regMod);
    }

    private static void ModPowUpdateResult(ref BigIntegerBuilder regRes, ref BigIntegerBuilder regVal, ref BigIntegerBuilder regMod, ref BigIntegerBuilder regTmp)
    {
        NumericsHelpers.<BigIntegerBuilder>(ref regRes, ref regTmp);
        regRes.Mul(ref regTmp, ref regVal);
        regRes.Mod(ref regMod);
    }

    private static void MulLower(ref uint uHiRes, ref int cuRes, uint uHiMul, int cuMul)
    {
        ulong num = (ulong)uHiRes * (ulong)uHiMul;
        uint hi = NumericsHelpers.GetHi(num);
        if (hi == 0)
        {
            uHiRes = NumericsHelpers.GetLo(num);
            cuRes = cuRes + cuMul - 1;
            return;
        }
        else
        {
            uHiRes = hi;
            cuRes = cuRes + cuMul;
            return;
        }
    }

    [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
    public static BigInteger Multiply(BigInteger left, BigInteger right)
    {
        return left * right;
    }

    private static void MulUpper(ref uint uHiRes, ref int cuRes, uint uHiMul, int cuMul)
    {
        ulong num = (ulong)uHiRes * (ulong)uHiMul;
        uint hi = NumericsHelpers.GetHi(num);
        if (hi == 0)
        {
            uHiRes = NumericsHelpers.GetLo(num);
            cuRes = cuRes + cuMul - 1;
            return;
        }
        else
        {
            if (NumericsHelpers.GetLo(num) != 0)
            {
                int num1 = hi + 1;
                hi = (uint)num1;
                if (num1 == 0)
                {
                    hi = 1;
                    cuRes = cuRes + 1;
                }
            }
            uHiRes = hi;
            cuRes = cuRes + cuMul;
            return;
        }
    }

    [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
    public static BigInteger Negate(BigInteger value)
    {
        return -value;
    }

    public static BigInteger operator +(BigInteger left, BigInteger right)
    {
        if (!right.IsZero)
        {
            if (!left.IsZero)
            {
                int num = 1;
                int num1 = 1;
                BigIntegerBuilder bigIntegerBuilder = new BigIntegerBuilder(left, ref num);
                BigIntegerBuilder bigIntegerBuilder1 = new BigIntegerBuilder(right, ref num1);
                if (num != num1)
                {
                    bigIntegerBuilder.Sub(ref num, ref bigIntegerBuilder1);
                }
                else
                {
                    bigIntegerBuilder.Add(ref bigIntegerBuilder1);
                }
                return bigIntegerBuilder.GetInteger(num);
            }
            else
            {
                return right;
            }
        }
        else
        {
            return left;
        }
    }

    public static BigInteger operator &(BigInteger left, BigInteger right)
    {
        byte num;
        byte num1;
        uint num2;
        uint num3;
        if (left.IsZero || right.IsZero)
        {
            return BigInteger.Zero;
        }
        else
        {
            uint[] uInt32Array = left.ToUInt32Array();
            uint[] numArray = right.ToUInt32Array();
            uint[] numArray1 = new uint[Math.Max((int)uInt32Array.Length, (int)numArray.Length)];
            if (left._sign < 0)
            {
                num = -1;
            }
            else
            {
                num = 0;
            }
            uint num4 = (uint)num;
            if (right._sign < 0)
            {
                num1 = -1;
            }
            else
            {
                num1 = 0;
            }
            uint num5 = (uint)num1;
            for (int i = 0; i < (int)numArray1.Length; i++)
            {
                if (i < (int)uInt32Array.Length)
                {
                    num2 = uInt32Array[i];
                }
                else
                {
                    num2 = num4;
                }
                uint num6 = num2;
                if (i < (int)numArray.Length)
                {
                    num3 = numArray[i];
                }
                else
                {
                    num3 = num5;
                }
                uint num7 = num3;
                numArray1[i] = num6 & num7;
            }
            return new BigInteger(numArray1);
        }
    }

    public static BigInteger operator |(BigInteger left, BigInteger right)
    {
        byte num;
        byte num1;
        uint num2;
        uint num3;
        if (!left.IsZero)
        {
            if (!right.IsZero)
            {
                uint[] uInt32Array = left.ToUInt32Array();
                uint[] numArray = right.ToUInt32Array();
                uint[] numArray1 = new uint[Math.Max((int)uInt32Array.Length, (int)numArray.Length)];
                if (left._sign < 0)
                {
                    num = -1;
                }
                else
                {
                    num = 0;
                }
                uint num4 = (uint)num;
                if (right._sign < 0)
                {
                    num1 = -1;
                }
                else
                {
                    num1 = 0;
                }
                uint num5 = (uint)num1;
                for (int i = 0; i < (int)numArray1.Length; i++)
                {
                    if (i < (int)uInt32Array.Length)
                    {
                        num2 = uInt32Array[i];
                    }
                    else
                    {
                        num2 = num4;
                    }
                    uint num6 = num2;
                    if (i < (int)numArray.Length)
                    {
                        num3 = numArray[i];
                    }
                    else
                    {
                        num3 = num5;
                    }
                    uint num7 = num3;
                    numArray1[i] = num6 | num7;
                }
                return new BigInteger(numArray1);
            }
            else
            {
                return left;
            }
        }
        else
        {
            return right;
        }
    }

    public static BigInteger operator --(BigInteger value)
    {
        return value - BigInteger.One;
    }

    public static BigInteger operator /(BigInteger dividend, BigInteger divisor)
    {
        int num = 1;
        BigIntegerBuilder bigIntegerBuilder = new BigIntegerBuilder(dividend, ref num);
        BigIntegerBuilder bigIntegerBuilder1 = new BigIntegerBuilder(divisor, ref num);
        bigIntegerBuilder.Div(ref bigIntegerBuilder1);
        return bigIntegerBuilder.GetInteger(num);
    }

    public static bool operator ==(BigInteger left, BigInteger right)
    {
        return left.Equals(right);
    }

    public static bool operator ==(BigInteger left, long right)
    {
        return left.Equals(right);
    }

    public static bool operator ==(long left, BigInteger right)
    {
        return right.Equals(left);
    }

    [CLSCompliant(false)]
    public static bool operator ==(BigInteger left, ulong right)
    {
        return left.Equals(right);
    }

    [CLSCompliant(false)]
    public static bool operator ==(ulong left, BigInteger right)
    {
        return right.Equals(left);
    }

    public static BigInteger operator ^(BigInteger left, BigInteger right)
    {
        byte num;
        byte num1;
        uint num2;
        uint num3;
        uint[] uInt32Array = left.ToUInt32Array();
        uint[] numArray = right.ToUInt32Array();
        uint[] numArray1 = new uint[Math.Max((int)uInt32Array.Length, (int)numArray.Length)];
        if (left._sign < 0)
        {
            num = -1;
        }
        else
        {
            num = 0;
        }
        uint num4 = (uint)num;
        if (right._sign < 0)
        {
            num1 = -1;
        }
        else
        {
            num1 = 0;
        }
        uint num5 = (uint)num1;
        for (int i = 0; i < (int)numArray1.Length; i++)
        {
            if (i < (int)uInt32Array.Length)
            {
                num2 = uInt32Array[i];
            }
            else
            {
                num2 = num4;
            }
            uint num6 = num2;
            if (i < (int)numArray.Length)
            {
                num3 = numArray[i];
            }
            else
            {
                num3 = num5;
            }
            uint num7 = num3;
            numArray1[i] = num6 ^ num7;
        }
        return new BigInteger(numArray1);
    }

    public static explicit operator BigInteger(float value)
    {
        return new BigInteger(value);
    }

    public static explicit operator BigInteger(double value)
    {
        return new BigInteger(value);
    }

    public static explicit operator BigInteger(decimal value)
    {
        return new BigInteger(value);
    }

    public static explicit operator Byte(BigInteger value)
    {
        return (byte)((int)value);
    }

    [CLSCompliant(false)]
    public static explicit operator SByte(BigInteger value)
    {
        return (sbyte)((int)value);
    }

    public static explicit operator Int16(BigInteger value)
    {
        return (short)((int)value);
    }

    [CLSCompliant(false)]
    public static explicit operator UInt16(BigInteger value)
    {
        return (ushort)((int)value);
    }

    public static explicit operator Int32(BigInteger value)
    {
        if (value._bits != null)
        {
            if (BigInteger.Length(value._bits) <= 1)
            {
                if (value._sign <= 0)
                {
                    if (value._bits[0] <= -2147483648)
                    {
                        return -value._bits[0];
                    }
                    else
                    {
                        throw new OverflowException(SR.GetString("Overflow_Int32"));
                    }
                }
                else
                {
                    return (void*)((int)value._bits[0]);
                }
            }
            else
            {
                throw new OverflowException(SR.GetString("Overflow_Int32"));
            }
        }
        else
        {
            return value._sign;
        }
    }

    [CLSCompliant(false)]
    public static explicit operator UInt32(BigInteger value)
    {
        if (value._bits != null)
        {
            if (BigInteger.Length(value._bits) > 1 || value._sign < 0)
            {
                throw new OverflowException(SR.GetString("Overflow_UInt32"));
            }
            else
            {
                return value._bits[0];
            }
        }
        else
        {
            return (uint)value._sign;
        }
    }

    public static explicit operator Int64(BigInteger value)
    {
        ulong num;
        ulong num1;
        if (value._bits != null)
        {
            int num2 = BigInteger.Length(value._bits);
            if (num2 <= 2)
            {
                if (num2 <= 1)
                {
                    num = (ulong)value._bits[0];
                }
                else
                {
                    num = NumericsHelpers.MakeUlong(value._bits[1], value._bits[0]);
                }
                if (value._sign > 0)
                {
                    num1 = num;
                }
                else
                {
                    num1 = -num;
                }
                long num3 = (long)num1;
                if ((num3 <= (long)0 || value._sign <= 0) && (num3 >= (long)0 || value._sign >= 0))
                {
                    throw new OverflowException(SR.GetString("Overflow_Int64"));
                }
                else
                {
                    return num3;
                }
            }
            else
            {
                throw new OverflowException(SR.GetString("Overflow_Int64"));
            }
        }
        else
        {
            return (long)value._sign;
        }
    }

    [CLSCompliant(false)]
    public static explicit operator UInt64(BigInteger value)
    {
        if (value._bits != null)
        {
            int num = BigInteger.Length(value._bits);
            if (num > 2 || value._sign < 0)
            {
                throw new OverflowException(SR.GetString("Overflow_UInt64"));
            }
            else
            {
                if (num <= 1)
                {
                    return (ulong)value._bits[0];
                }
                else
                {
                    return NumericsHelpers.MakeUlong(value._bits[1], value._bits[0]);
                }
            }
        }
        else
        {
            return (ulong)value._sign;
        }
    }

    public static explicit operator Single(BigInteger value)
    {
        return (float)((double)((double)value));
    }

    public static explicit operator Double(BigInteger value)
    {
        ulong num = 0L;
        int num1 = 0;
        if (value._bits != null)
        {
            int num2 = 1;
            BigIntegerBuilder bigIntegerBuilder = new BigIntegerBuilder(value, ref num2);
            bigIntegerBuilder.GetApproxParts(out num1, out num);
            return NumericsHelpers.GetDoubleFromParts(num2, num1, num);
        }
        else
        {
            return (double)value._sign;
        }
    }

    public static explicit operator Decimal(BigInteger value)
    {
        if (value._bits != null)
        {
            int num = BigInteger.Length(value._bits);
            if (num <= 3)
            {
                int num1 = 0;
                int num2 = 0;
                int num3 = 0;
                if (num > 2)
                {
                    num3 = value._bits[2];
                }
                if (num > 1)
                {
                    num2 = value._bits[1];
                }
                if (num > 0)
                {
                    num1 = value._bits[0];
                }
                return new decimal(num1, num2, num3, value._sign < 0, 0);
            }
            else
            {
                throw new OverflowException(SR.GetString("Overflow_Decimal"));
            }
        }
        else
        {
            return value._sign;
        }
    }

    public static bool operator >(BigInteger left, BigInteger right)
    {
        return left.CompareTo(right) > 0;
    }

    public static bool operator >(BigInteger left, long right)
    {
        return left.CompareTo(right) > 0;
    }

    public static bool operator >(long left, BigInteger right)
    {
        return right.CompareTo(left) < 0;
    }

    [CLSCompliant(false)]
    public static bool operator >(BigInteger left, ulong right)
    {
        return left.CompareTo(right) > 0;
    }

    [CLSCompliant(false)]
    public static bool operator >(ulong left, BigInteger right)
    {
        return right.CompareTo(left) < 0;
    }

    public static bool operator >=(BigInteger left, BigInteger right)
    {
        return left.CompareTo(right) >= 0;
    }

    public static bool operator >=(BigInteger left, long right)
    {
        return left.CompareTo(right) >= 0;
    }

    public static bool operator >=(long left, BigInteger right)
    {
        return right.CompareTo(left) <= 0;
    }

    [CLSCompliant(false)]
    public static bool operator >=(BigInteger left, ulong right)
    {
        return left.CompareTo(right) >= 0;
    }

    [CLSCompliant(false)]
    public static bool operator >=(ulong left, BigInteger right)
    {
        return right.CompareTo(left) <= 0;
    }

    public static implicit operator BigInteger(byte value)
    {
        return new BigInteger(value);
    }

    [CLSCompliant(false)]
    public static implicit operator BigInteger(sbyte value)
    {
        return new BigInteger(value);
    }

    public static implicit operator BigInteger(short value)
    {
        return new BigInteger(value);
    }

    [CLSCompliant(false)]
    public static implicit operator BigInteger(ushort value)
    {
        return new BigInteger(value);
    }

    public static implicit operator BigInteger(int value)
    {
        return new BigInteger(value);
    }

    [CLSCompliant(false)]
    public static implicit operator BigInteger(uint value)
    {
        return new BigInteger(value);
    }

    public static implicit operator BigInteger(long value)
    {
        return new BigInteger(value);
    }

    [CLSCompliant(false)]
    public static implicit operator BigInteger(ulong value)
    {
        return new BigInteger(value);
    }

    public static BigInteger operator ++(BigInteger value)
    {
        return value + BigInteger.One;
    }

    public static bool operator !=(BigInteger left, BigInteger right)
    {
        return !left.Equals(right);
    }

    public static bool operator !=(BigInteger left, long right)
    {
        return !left.Equals(right);
    }

    public static bool operator !=(long left, BigInteger right)
    {
        return !right.Equals(left);
    }

    [CLSCompliant(false)]
    public static bool operator !=(BigInteger left, ulong right)
    {
        return !left.Equals(right);
    }

    [CLSCompliant(false)]
    public static bool operator !=(ulong left, BigInteger right)
    {
        return !right.Equals(left);
    }

    public static BigInteger operator <<(BigInteger value, int shift)
    {
        uint[] numArray = 0;
        int num = 0;
        if (shift != 0)
        {
            if (shift != -2147483648)
            {
                if (shift >= 0)
                {
                    int num1 = shift / 32;
                    int num2 = shift - num1 * 32;
                    bool partsForBitManipulation = BigInteger.GetPartsForBitManipulation(ref value, out numArray, out num);
                    int num3 = num + num1 + 1;
                    uint[] numArray1 = new uint[num3];
                    if (num2 != 0)
                    {
                        int num4 = 32 - num2;
                        uint num5 = 0;
                        for (int i = 0; i < num; i++)
                        {
                            uint num6 = numArray[i];
                            numArray1[i + num1] = num6 << (num2 & 31) | num5;
                            num5 = num6 >> (num4 & 31);
                        }
                        numArray1[i + num1] = num5;
                    }
                    else
                    {
                        for (int j = 0; j < num; j++)
                        {
                            numArray1[j + num1] = numArray[j];
                        }
                    }
                    return new BigInteger(numArray1, partsForBitManipulation);
                }
                else
                {
                    return value >> -shift;
                }
            }
            else
            {
                return value >> 2147483647 >> 1;
            }
        }
        else
        {
            return value;
        }
    }

    public static bool operator <(BigInteger left, BigInteger right)
    {
        return left.CompareTo(right) < 0;
    }

    public static bool operator <(BigInteger left, long right)
    {
        return left.CompareTo(right) < 0;
    }

    public static bool operator <(long left, BigInteger right)
    {
        return right.CompareTo(left) > 0;
    }

    [CLSCompliant(false)]
    public static bool operator <(BigInteger left, ulong right)
    {
        return left.CompareTo(right) < 0;
    }

    [CLSCompliant(false)]
    public static bool operator <(ulong left, BigInteger right)
    {
        return right.CompareTo(left) > 0;
    }

    public static bool operator <=(BigInteger left, BigInteger right)
    {
        return left.CompareTo(right) <= 0;
    }

    public static bool operator <=(BigInteger left, long right)
    {
        return left.CompareTo(right) <= 0;
    }

    public static bool operator <=(long left, BigInteger right)
    {
        return right.CompareTo(left) >= 0;
    }

    [CLSCompliant(false)]
    public static bool operator <=(BigInteger left, ulong right)
    {
        return left.CompareTo(right) <= 0;
    }

    [CLSCompliant(false)]
    public static bool operator <=(ulong left, BigInteger right)
    {
        return right.CompareTo(left) >= 0;
    }

    public static BigInteger operator %(BigInteger dividend, BigInteger divisor)
    {
        int num = 1;
        int num1 = 1;
        BigIntegerBuilder bigIntegerBuilder = new BigIntegerBuilder(dividend, ref num);
        BigIntegerBuilder bigIntegerBuilder1 = new BigIntegerBuilder(divisor, ref num1);
        bigIntegerBuilder.Mod(ref bigIntegerBuilder1);
        return bigIntegerBuilder.GetInteger(num);
    }

    public static BigInteger operator *(BigInteger left, BigInteger right)
    {
        int num = 1;
        BigIntegerBuilder bigIntegerBuilder = new BigIntegerBuilder(left, ref num);
        BigIntegerBuilder bigIntegerBuilder1 = new BigIntegerBuilder(right, ref num);
        bigIntegerBuilder.Mul(ref bigIntegerBuilder1);
        return bigIntegerBuilder.GetInteger(num);
    }

    public static BigInteger operator ~(BigInteger value)
    {
        return -(value + BigInteger.One);
    }

    public static BigInteger operator >>(BigInteger value, int shift)
    {
        uint[] numArray = 0;
        int num = 0;
        if (shift != 0)
        {
            if (shift != -2147483648)
            {
                if (shift >= 0)
                {
                    int num1 = shift / 32;
                    int num2 = shift - num1 * 32;
                    bool partsForBitManipulation = BigInteger.GetPartsForBitManipulation(ref value, out numArray, out num);
                    if (partsForBitManipulation)
                    {
                        if (shift < 32 * num)
                        {
                            uint[] numArray1 = new uint[num];
                            Array.Copy(numArray, numArray1, num);
                            numArray = numArray1;
                            NumericsHelpers.DangerousMakeTwosComplement(numArray);
                        }
                        else
                        {
                            return BigInteger.MinusOne;
                        }
                    }
                    int num3 = num - num1;
                    if (num3 < 0)
                    {
                        num3 = 0;
                    }
                    uint[] numArray2 = new uint[num3];
                    if (num2 != 0)
                    {
                        int num4 = 32 - num2;
                        uint num5 = 0;
                        for (int i = num - 1; i >= num1; i--)
                        {
                            uint num6 = numArray[i];
                            if (!partsForBitManipulation || i != num - 1)
                            {
                                numArray2[i - num1] = num6 >> (num2 & 31) | num5;
                            }
                            else
                            {
                                numArray2[i - num1] = num6 >> (num2 & 31) | -1 << (num4 & 31);
                            }
                            num5 = num6 << (num4 & 31);
                        }
                    }
                    else
                    {
                        for (int j = num - 1; j >= num1; j--)
                        {
                            numArray2[j - num1] = numArray[j];
                        }
                    }
                    if (partsForBitManipulation)
                    {
                        NumericsHelpers.DangerousMakeTwosComplement(numArray2);
                    }
                    return new BigInteger(numArray2, partsForBitManipulation);
                }
                else
                {
                    return value << -shift;
                }
            }
            else
            {
                return value << 2147483647 << 1;
            }
        }
        else
        {
            return value;
        }
    }

    public static BigInteger operator -(BigInteger left, BigInteger right)
    {
        if (!right.IsZero)
        {
            if (!left.IsZero)
            {
                int num = 1;
                int num1 = -1;
                BigIntegerBuilder bigIntegerBuilder = new BigIntegerBuilder(left, ref num);
                BigIntegerBuilder bigIntegerBuilder1 = new BigIntegerBuilder(right, ref num1);
                if (num != num1)
                {
                    bigIntegerBuilder.Sub(ref num, ref bigIntegerBuilder1);
                }
                else
                {
                    bigIntegerBuilder.Add(ref bigIntegerBuilder1);
                }
                return bigIntegerBuilder.GetInteger(num);
            }
            else
            {
                return -right;
            }
        }
        else
        {
            return left;
        }
    }

    public static BigInteger operator -(BigInteger value)
    {
        value._sign = -value._sign;
        return value;
    }

    public static BigInteger operator +(BigInteger value)
    {
        return value;
    }

    public static BigInteger Parse(string value)
    {
        return BigNumber.ParseBigInteger(value, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
    }

    public static BigInteger Parse(string value, NumberStyles style)
    {
        return BigNumber.ParseBigInteger(value, style, NumberFormatInfo.CurrentInfo);
    }

    public static BigInteger Parse(string value, IFormatProvider provider)
    {
        return BigNumber.ParseBigInteger(value, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
    }

    public static BigInteger Parse(string value, NumberStyles style, IFormatProvider provider)
    {
        return BigNumber.ParseBigInteger(value, style, NumberFormatInfo.GetInstance(provider));
    }

    public static BigInteger Pow(BigInteger value, int exponent)
    {
        if (exponent >= 0)
        {
            if (exponent != 0)
            {
                if (exponent != 1)
                {
                    if (value._bits == null)
                    {
                        if (value._sign != 1)
                        {
                            if (value._sign != -1)
                            {
                                if (value._sign == 0)
                                {
                                    return value;
                                }
                            }
                            else
                            {
                                if ((exponent & 1) != 0)
                                {
                                    return value;
                                }
                                else
                                {
                                    return 1;
                                }
                            }
                        }
                        else
                        {
                            return value;
                        }
                    }
                    int num = 1;
                    BigIntegerBuilder bigIntegerBuilder = new BigIntegerBuilder(value, ref num);
                    int size = bigIntegerBuilder.Size;
                    int num1 = size;
                    uint high = bigIntegerBuilder.High;
                    uint num2 = high + 1;
                    if (num2 == 0)
                    {
                        num1++;
                        num2 = 1;
                    }
                    int num3 = 1;
                    int num4 = 1;
                    uint num5 = 1;
                    uint num6 = 1;
                    int num7 = exponent;
                    while (true)
                    {
                        if ((num7 & 1) != 0)
                        {
                            BigInteger.MulUpper(ref num6, ref num4, num2, num1);
                            BigInteger.MulLower(ref num5, ref num3, high, size);
                        }
                        int num8 = num7 >> 1;
                        num7 = num8;
                        if (num8 == 0)
                        {
                            break;
                        }
                        BigInteger.MulUpper(ref num2, ref num1, num2, num1);
                        BigInteger.MulLower(ref high, ref size, high, size);
                    }
                    if (num4 > 1)
                    {
                        bigIntegerBuilder.EnsureWritable(num4, 0);
                    }
                    BigIntegerBuilder bigIntegerBuilder1 = new BigIntegerBuilder(num4);
                    BigIntegerBuilder bigIntegerBuilder2 = new BigIntegerBuilder(num4);
                    bigIntegerBuilder2.Set(1);
                    if ((exponent & 1) == 0)
                    {
                        num = 1;
                    }
                    int num9 = exponent;
                    while (true)
                    {
                        if ((num9 & 1) != 0)
                        {
                            NumericsHelpers.<BigIntegerBuilder>(ref bigIntegerBuilder2, ref bigIntegerBuilder1);
                            bigIntegerBuilder2.Mul(ref bigIntegerBuilder, ref bigIntegerBuilder1);
                        }
                        int num10 = num9 >> 1;
                        num9 = num10;
                        if (num10 == 0)
                        {
                            break;
                        }
                        NumericsHelpers.<BigIntegerBuilder>(ref bigIntegerBuilder, ref bigIntegerBuilder1);
                        bigIntegerBuilder.Mul(ref bigIntegerBuilder1, ref bigIntegerBuilder1);
                    }
                    return bigIntegerBuilder2.GetInteger(num);
                }
                else
                {
                    return value;
                }
            }
            else
            {
                return BigInteger.One;
            }
        }
        else
        {
            throw new ArgumentOutOfRangeException("exponent", SR.GetString("ArgumentOutOfRange_MustBeNonNeg"));
        }
    }

    [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
    public static BigInteger Remainder(BigInteger dividend, BigInteger divisor)
    {
        return dividend % divisor;
    }

    private void SetBitsFromDouble(double value)
    {
        int num = 0;
        int num1 = 0;
        ulong num2 = 0L;
        bool flag;
        NumericsHelpers.GetDoubleParts(value, out num, out num1, out num2, out flag);
        if (num2 != (long)0)
        {
            if (num1 > 0)
            {
                if (num1 > 11)
                {
                    num2 = num2 << 11;
                    num1 = num1 - 11;
                    int num3 = (num1 - 1) / 32 + 1;
                    int num4 = num3 * 32 - num1;
                    this._bits = new uint[num3 + 2];
                    this._bits[num3 + 1] = (uint)(num2 >> (num4 + 32 & 63));
                    this._bits[num3] = (uint)(num2 >> (num4 & 63));
                    if (num4 > 0)
                    {
                        this._bits[num3 - 1] = (uint)num2 << (32 - num4 & 31);
                    }
                    this._sign = num;
                }
                else
                {
                    *(this) = num2 << (num1 & 63);
                    if (num < 0)
                    {
                        this._sign = -this._sign;
                        return;
                    }
                }
            }
            else
            {
                if (num1 > -64)
                {
                    *(this) = num2 >> (-num1 & 63);
                    if (num < 0)
                    {
                        this._sign = -this._sign;
                        return;
                    }
                }
                else
                {
                    *(this) = BigInteger.Zero;
                    return;
                }
            }
            return;
        }
        else
        {
            *(this) = BigInteger.Zero;
            return;
        }
    }

    [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
    public static BigInteger Subtract(BigInteger left, BigInteger right)
    {
        return left - right;
    }

    public byte[] ToByteArray()
    {
        uint[] numArray;
        byte num;
        int num1;
        byte num2;
        if (this._bits != null || this._sign != 0)
        {
            if (this._bits != null)
            {
                if (this._sign != -1)
                {
                    numArray = this._bits;
                    num = 0;
                }
                else
                {
                    numArray = (uint[])this._bits.Clone();
                    NumericsHelpers.DangerousMakeTwosComplement(numArray);
                    num = 255;
                }
            }
            else
            {
                uint[] numArray1 = new uint[1];
                numArray1[0] = this._sign;
                numArray = numArray1;
                if (this._sign < 0)
                {
                    num2 = 255;
                }
                else
                {
                    num2 = 0;
                }
                num = (byte)num2;
            }
            byte[] numArray2 = new byte[4 * (int)numArray.Length];
            int num3 = 0;
            for (int i = 0; i < (int)numArray.Length; i++)
            {
                uint num4 = numArray[i];
                for (int j = 0; j < 4; j++)
                {
                    int num5 = num3;
                    num3 = num5 + 1;
                    numArray2[num5] = (byte)(num4 & 255);
                    num4 = num4 >> 8;
                }
            }
            int length = (int)numArray2.Length - 1;
            while (length > 0 && numArray2[length] == num)
            {
                length--;
            }
            bool flag = (numArray2[length] & 128) != (num & 128);
            int num6 = length + 1;
            if (flag)
            {
                num1 = 1;
            }
            else
            {
                num1 = 0;
            }
            byte[] numArray3 = new byte[num6 + num1];
            Array.Copy(numArray2, numArray3, length + 1);
            if (flag)
            {
                numArray3[(int)numArray3.Length - 1] = num;
            }
            return numArray3;
        }
        else
        {
            byte[] numArray4 = new byte[1];
            return numArray4;
        }
    }

    public override string ToString()
    {
        return BigNumber.FormatBigInteger(this, null, NumberFormatInfo.CurrentInfo);
    }

    public string ToString(IFormatProvider provider)
    {
        return BigNumber.FormatBigInteger(this, null, NumberFormatInfo.GetInstance(provider));
    }

    public string ToString(string format)
    {
        return BigNumber.FormatBigInteger(this, format, NumberFormatInfo.CurrentInfo);
    }

    public string ToString(string format, IFormatProvider provider)
    {
        return BigNumber.FormatBigInteger(this, format, NumberFormatInfo.GetInstance(provider));
    }

    private uint[] ToUInt32Array()
    {
        uint[] numArray;
        uint num;
        int num1;
        byte num2;
        if (this._bits != null || this._sign != 0)
        {
            if (this._bits != null)
            {
                if (this._sign != -1)
                {
                    numArray = this._bits;
                    num = 0;
                }
                else
                {
                    numArray = (uint[])this._bits.Clone();
                    NumericsHelpers.DangerousMakeTwosComplement(numArray);
                    num = -1;
                }
            }
            else
            {
                uint[] numArray1 = new uint[1];
                numArray1[0] = this._sign;
                numArray = numArray1;
                if (this._sign < 0)
                {
                    num2 = -1;
                }
                else
                {
                    num2 = 0;
                }
                num = (uint)num2;
            }
            int length = (int)numArray.Length - 1;
            while (length > 0 && numArray[length] == num)
            {
                length--;
            }
            bool flag = (numArray[length] & -2147483648) != (num & -2147483648);
            int num3 = length + 1;
            if (flag)
            {
                num1 = 1;
            }
            else
            {
                num1 = 0;
            }
            uint[] numArray2 = new uint[num3 + num1];
            Array.Copy(numArray, numArray2, length + 1);
            if (flag)
            {
                numArray2[(int)numArray2.Length - 1] = num;
            }
            return numArray2;
        }
        else
        {
            uint[] numArray3 = new uint[1];
            return numArray3;
        }
    }

    public static bool TryParse(string value, out BigInteger result)
    {
        return BigNumber.TryParseBigInteger(value, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result);
    }

    public static bool TryParse(string value, NumberStyles style, IFormatProvider provider, out BigInteger result)
    {
        return BigNumber.TryParseBigInteger(value, style, NumberFormatInfo.GetInstance(provider), out result);
    }
}

 Expand All Members