niko
1949 lines
52 KiB
C#
1949 lines
52 KiB
C#
using System;
|
|
using System.Security.Cryptography;
|
|
using Mono.Math.Prime;
|
|
using Mono.Math.Prime.Generator;
|
|
|
|
namespace Mono.Math
|
|
{
|
|
// Token: 0x02000004 RID: 4
|
|
public class BigInteger
|
|
{
|
|
// Token: 0x06000004 RID: 4 RVA: 0x00002104 File Offset: 0x00000304
|
|
public BigInteger()
|
|
{
|
|
this.data = new uint[20];
|
|
this.length = 20U;
|
|
}
|
|
|
|
// Token: 0x06000005 RID: 5 RVA: 0x0000212C File Offset: 0x0000032C
|
|
[CLSCompliant(false)]
|
|
public BigInteger(BigInteger.Sign sign, uint len)
|
|
{
|
|
this.data = new uint[len];
|
|
this.length = len;
|
|
}
|
|
|
|
// Token: 0x06000006 RID: 6 RVA: 0x00002150 File Offset: 0x00000350
|
|
public BigInteger(BigInteger bi)
|
|
{
|
|
this.data = (uint[])bi.data.Clone();
|
|
this.length = bi.length;
|
|
}
|
|
|
|
// Token: 0x06000007 RID: 7 RVA: 0x00002184 File Offset: 0x00000384
|
|
[CLSCompliant(false)]
|
|
public BigInteger(BigInteger bi, uint len)
|
|
{
|
|
this.data = new uint[len];
|
|
for (uint num = 0U; num < bi.length; num += 1U)
|
|
{
|
|
this.data[(int)((UIntPtr)num)] = bi.data[(int)((UIntPtr)num)];
|
|
}
|
|
this.length = bi.length;
|
|
}
|
|
|
|
// Token: 0x06000008 RID: 8 RVA: 0x000021E0 File Offset: 0x000003E0
|
|
public BigInteger(byte[] inData)
|
|
{
|
|
this.length = (uint)inData.Length >> 2;
|
|
int num = inData.Length & 3;
|
|
if (num != 0)
|
|
{
|
|
this.length += 1U;
|
|
}
|
|
this.data = new uint[this.length];
|
|
int i = inData.Length - 1;
|
|
int num2 = 0;
|
|
while (i >= 3)
|
|
{
|
|
this.data[num2] = (uint)(((int)inData[i - 3] << 24) | ((int)inData[i - 2] << 16) | ((int)inData[i - 1] << 8) | (int)inData[i]);
|
|
i -= 4;
|
|
num2++;
|
|
}
|
|
switch (num)
|
|
{
|
|
case 1:
|
|
this.data[(int)((UIntPtr)(this.length - 1U))] = (uint)inData[0];
|
|
break;
|
|
case 2:
|
|
this.data[(int)((UIntPtr)(this.length - 1U))] = (uint)(((int)inData[0] << 8) | (int)inData[1]);
|
|
break;
|
|
case 3:
|
|
this.data[(int)((UIntPtr)(this.length - 1U))] = (uint)(((int)inData[0] << 16) | ((int)inData[1] << 8) | (int)inData[2]);
|
|
break;
|
|
}
|
|
this.Normalize();
|
|
}
|
|
|
|
// Token: 0x06000009 RID: 9 RVA: 0x000022F0 File Offset: 0x000004F0
|
|
[CLSCompliant(false)]
|
|
public BigInteger(uint[] inData)
|
|
{
|
|
this.length = (uint)inData.Length;
|
|
this.data = new uint[this.length];
|
|
int i = (int)(this.length - 1U);
|
|
int num = 0;
|
|
while (i >= 0)
|
|
{
|
|
this.data[num] = inData[i];
|
|
i--;
|
|
num++;
|
|
}
|
|
this.Normalize();
|
|
}
|
|
|
|
// Token: 0x0600000A RID: 10 RVA: 0x00002358 File Offset: 0x00000558
|
|
[CLSCompliant(false)]
|
|
public BigInteger(uint ui)
|
|
{
|
|
this.data = new uint[] { ui };
|
|
}
|
|
|
|
// Token: 0x0600000B RID: 11 RVA: 0x00002378 File Offset: 0x00000578
|
|
[CLSCompliant(false)]
|
|
public BigInteger(ulong ul)
|
|
{
|
|
this.data = new uint[]
|
|
{
|
|
(uint)ul,
|
|
(uint)(ul >> 32)
|
|
};
|
|
this.length = 2U;
|
|
this.Normalize();
|
|
}
|
|
|
|
// Token: 0x0600000D RID: 13 RVA: 0x000023D4 File Offset: 0x000005D4
|
|
public static BigInteger Parse(string number)
|
|
{
|
|
if (number == null)
|
|
{
|
|
throw new ArgumentNullException("number");
|
|
}
|
|
int i = 0;
|
|
int num = number.Length;
|
|
bool flag = false;
|
|
BigInteger bigInteger = new BigInteger(0U);
|
|
if (number[i] == '+')
|
|
{
|
|
i++;
|
|
}
|
|
else if (number[i] == '-')
|
|
{
|
|
throw new FormatException("Operation would return a negative value");
|
|
}
|
|
while (i < num)
|
|
{
|
|
char c = number[i];
|
|
if (c == '\0')
|
|
{
|
|
i = num;
|
|
}
|
|
else if (c >= '0' && c <= '9')
|
|
{
|
|
bigInteger = bigInteger * 10 + (int)(c - '0');
|
|
flag = true;
|
|
}
|
|
else
|
|
{
|
|
if (char.IsWhiteSpace(c))
|
|
{
|
|
for (i++; i < num; i++)
|
|
{
|
|
if (!char.IsWhiteSpace(number[i]))
|
|
{
|
|
throw new FormatException();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
throw new FormatException();
|
|
}
|
|
i++;
|
|
}
|
|
if (!flag)
|
|
{
|
|
throw new FormatException();
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x0600000E RID: 14 RVA: 0x000024DC File Offset: 0x000006DC
|
|
public static BigInteger Add(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
return bi1 + bi2;
|
|
}
|
|
|
|
// Token: 0x0600000F RID: 15 RVA: 0x000024E8 File Offset: 0x000006E8
|
|
public static BigInteger Subtract(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
return bi1 - bi2;
|
|
}
|
|
|
|
// Token: 0x06000010 RID: 16 RVA: 0x000024F4 File Offset: 0x000006F4
|
|
public static int Modulus(BigInteger bi, int i)
|
|
{
|
|
return bi % i;
|
|
}
|
|
|
|
// Token: 0x06000011 RID: 17 RVA: 0x00002500 File Offset: 0x00000700
|
|
[CLSCompliant(false)]
|
|
public static uint Modulus(BigInteger bi, uint ui)
|
|
{
|
|
return bi % ui;
|
|
}
|
|
|
|
// Token: 0x06000012 RID: 18 RVA: 0x0000250C File Offset: 0x0000070C
|
|
public static BigInteger Modulus(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
return bi1 % bi2;
|
|
}
|
|
|
|
// Token: 0x06000013 RID: 19 RVA: 0x00002518 File Offset: 0x00000718
|
|
public static BigInteger Divid(BigInteger bi, int i)
|
|
{
|
|
return bi / i;
|
|
}
|
|
|
|
// Token: 0x06000014 RID: 20 RVA: 0x00002524 File Offset: 0x00000724
|
|
public static BigInteger Divid(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
return bi1 / bi2;
|
|
}
|
|
|
|
// Token: 0x06000015 RID: 21 RVA: 0x00002530 File Offset: 0x00000730
|
|
public static BigInteger Multiply(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
return bi1 * bi2;
|
|
}
|
|
|
|
// Token: 0x06000016 RID: 22 RVA: 0x0000253C File Offset: 0x0000073C
|
|
public static BigInteger Multiply(BigInteger bi, int i)
|
|
{
|
|
return bi * i;
|
|
}
|
|
|
|
// Token: 0x17000001 RID: 1
|
|
// (get) Token: 0x06000017 RID: 23 RVA: 0x00002548 File Offset: 0x00000748
|
|
private static RandomNumberGenerator Rng
|
|
{
|
|
get
|
|
{
|
|
if (BigInteger.rng == null)
|
|
{
|
|
BigInteger.rng = RandomNumberGenerator.Create();
|
|
}
|
|
return BigInteger.rng;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000018 RID: 24 RVA: 0x00002564 File Offset: 0x00000764
|
|
public static BigInteger GenerateRandom(int bits, RandomNumberGenerator rng)
|
|
{
|
|
int num = bits >> 5;
|
|
int num2 = bits & 31;
|
|
if (num2 != 0)
|
|
{
|
|
num++;
|
|
}
|
|
BigInteger bigInteger = new BigInteger(BigInteger.Sign.Positive, (uint)(num + 1));
|
|
byte[] array = new byte[num << 2];
|
|
rng.GetBytes(array);
|
|
Buffer.BlockCopy(array, 0, bigInteger.data, 0, num << 2);
|
|
if (num2 != 0)
|
|
{
|
|
uint num3 = 1U << num2 - 1;
|
|
bigInteger.data[num - 1] |= num3;
|
|
num3 = uint.MaxValue >> 32 - num2;
|
|
bigInteger.data[num - 1] &= num3;
|
|
}
|
|
else
|
|
{
|
|
bigInteger.data[num - 1] |= 2147483648U;
|
|
}
|
|
bigInteger.Normalize();
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x06000019 RID: 25 RVA: 0x00002618 File Offset: 0x00000818
|
|
public static BigInteger GenerateRandom(int bits)
|
|
{
|
|
return BigInteger.GenerateRandom(bits, BigInteger.Rng);
|
|
}
|
|
|
|
// Token: 0x0600001A RID: 26 RVA: 0x00002628 File Offset: 0x00000828
|
|
public void Randomize(RandomNumberGenerator rng)
|
|
{
|
|
if (this == 0U)
|
|
{
|
|
return;
|
|
}
|
|
int num = this.BitCount();
|
|
int num2 = num >> 5;
|
|
int num3 = num & 31;
|
|
if (num3 != 0)
|
|
{
|
|
num2++;
|
|
}
|
|
byte[] array = new byte[num2 << 2];
|
|
rng.GetBytes(array);
|
|
Buffer.BlockCopy(array, 0, this.data, 0, num2 << 2);
|
|
if (num3 != 0)
|
|
{
|
|
uint num4 = 1U << num3 - 1;
|
|
this.data[num2 - 1] |= num4;
|
|
num4 = uint.MaxValue >> 32 - num3;
|
|
this.data[num2 - 1] &= num4;
|
|
}
|
|
else
|
|
{
|
|
this.data[num2 - 1] |= 2147483648U;
|
|
}
|
|
this.Normalize();
|
|
}
|
|
|
|
// Token: 0x0600001B RID: 27 RVA: 0x000026E4 File Offset: 0x000008E4
|
|
public void Randomize()
|
|
{
|
|
this.Randomize(BigInteger.Rng);
|
|
}
|
|
|
|
// Token: 0x0600001C RID: 28 RVA: 0x000026F4 File Offset: 0x000008F4
|
|
public int BitCount()
|
|
{
|
|
this.Normalize();
|
|
uint num = this.data[(int)((UIntPtr)(this.length - 1U))];
|
|
uint num2 = 2147483648U;
|
|
uint num3 = 32U;
|
|
while (num3 > 0U && (num & num2) == 0U)
|
|
{
|
|
num3 -= 1U;
|
|
num2 >>= 1;
|
|
}
|
|
return (int)(num3 + (this.length - 1U << 5));
|
|
}
|
|
|
|
// Token: 0x0600001D RID: 29 RVA: 0x0000274C File Offset: 0x0000094C
|
|
[CLSCompliant(false)]
|
|
public bool TestBit(uint bitNum)
|
|
{
|
|
uint num = bitNum >> 5;
|
|
byte b = (byte)(bitNum & 31U);
|
|
uint num2 = 1U << (int)b;
|
|
return (this.data[(int)((UIntPtr)num)] & num2) != 0U;
|
|
}
|
|
|
|
// Token: 0x0600001E RID: 30 RVA: 0x0000277C File Offset: 0x0000097C
|
|
public bool TestBit(int bitNum)
|
|
{
|
|
if (bitNum < 0)
|
|
{
|
|
throw new IndexOutOfRangeException("bitNum out of range");
|
|
}
|
|
uint num = (uint)bitNum >> 5;
|
|
byte b = (byte)(bitNum & 31);
|
|
uint num2 = 1U << (int)b;
|
|
return (this.data[(int)((UIntPtr)num)] | num2) == this.data[(int)((UIntPtr)num)];
|
|
}
|
|
|
|
// Token: 0x0600001F RID: 31 RVA: 0x000027C4 File Offset: 0x000009C4
|
|
[CLSCompliant(false)]
|
|
public void SetBit(uint bitNum)
|
|
{
|
|
this.SetBit(bitNum, true);
|
|
}
|
|
|
|
// Token: 0x06000020 RID: 32 RVA: 0x000027D0 File Offset: 0x000009D0
|
|
[CLSCompliant(false)]
|
|
public void ClearBit(uint bitNum)
|
|
{
|
|
this.SetBit(bitNum, false);
|
|
}
|
|
|
|
// Token: 0x06000021 RID: 33 RVA: 0x000027DC File Offset: 0x000009DC
|
|
[CLSCompliant(false)]
|
|
public void SetBit(uint bitNum, bool value)
|
|
{
|
|
uint num = bitNum >> 5;
|
|
if (num < this.length)
|
|
{
|
|
uint num2 = 1U << (int)bitNum;
|
|
if (value)
|
|
{
|
|
this.data[(int)((UIntPtr)num)] |= num2;
|
|
}
|
|
else
|
|
{
|
|
this.data[(int)((UIntPtr)num)] &= ~num2;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000022 RID: 34 RVA: 0x00002834 File Offset: 0x00000A34
|
|
public int LowestSetBit()
|
|
{
|
|
if (this == 0U)
|
|
{
|
|
return -1;
|
|
}
|
|
int num = 0;
|
|
while (!this.TestBit(num))
|
|
{
|
|
num++;
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x06000023 RID: 35 RVA: 0x00002868 File Offset: 0x00000A68
|
|
public byte[] GetBytes()
|
|
{
|
|
if (this == 0U)
|
|
{
|
|
return new byte[1];
|
|
}
|
|
int num = this.BitCount();
|
|
int num2 = num >> 3;
|
|
if ((num & 7) != 0)
|
|
{
|
|
num2++;
|
|
}
|
|
byte[] array = new byte[num2];
|
|
int num3 = num2 & 3;
|
|
if (num3 == 0)
|
|
{
|
|
num3 = 4;
|
|
}
|
|
int num4 = 0;
|
|
for (int i = (int)(this.length - 1U); i >= 0; i--)
|
|
{
|
|
uint num5 = this.data[i];
|
|
for (int j = num3 - 1; j >= 0; j--)
|
|
{
|
|
array[num4 + j] = (byte)(num5 & 255U);
|
|
num5 >>= 8;
|
|
}
|
|
num4 += num3;
|
|
num3 = 4;
|
|
}
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x06000024 RID: 36 RVA: 0x00002914 File Offset: 0x00000B14
|
|
public BigInteger.Sign Compare(BigInteger bi)
|
|
{
|
|
return BigInteger.Kernel.Compare(this, bi);
|
|
}
|
|
|
|
// Token: 0x06000025 RID: 37 RVA: 0x00002920 File Offset: 0x00000B20
|
|
[CLSCompliant(false)]
|
|
public string ToString(uint radix)
|
|
{
|
|
return this.ToString(radix, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ");
|
|
}
|
|
|
|
// Token: 0x06000026 RID: 38 RVA: 0x00002930 File Offset: 0x00000B30
|
|
[CLSCompliant(false)]
|
|
public string ToString(uint radix, string characterSet)
|
|
{
|
|
if ((long)characterSet.Length < (long)((ulong)radix))
|
|
{
|
|
throw new ArgumentException("charSet length less than radix", "characterSet");
|
|
}
|
|
if (radix == 1U)
|
|
{
|
|
throw new ArgumentException("There is no such thing as radix one notation", "radix");
|
|
}
|
|
if (this == 0U)
|
|
{
|
|
return "0";
|
|
}
|
|
if (this == 1U)
|
|
{
|
|
return "1";
|
|
}
|
|
string text = string.Empty;
|
|
BigInteger bigInteger = new BigInteger(this);
|
|
while (bigInteger != 0U)
|
|
{
|
|
uint num = BigInteger.Kernel.SingleByteDivideInPlace(bigInteger, radix);
|
|
text = characterSet[(int)num] + text;
|
|
}
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x06000027 RID: 39 RVA: 0x000029D0 File Offset: 0x00000BD0
|
|
private void Normalize()
|
|
{
|
|
while (this.length > 0U && this.data[(int)((UIntPtr)(this.length - 1U))] == 0U)
|
|
{
|
|
this.length -= 1U;
|
|
}
|
|
if (this.length == 0U)
|
|
{
|
|
this.length += 1U;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000028 RID: 40 RVA: 0x00002A2C File Offset: 0x00000C2C
|
|
public void Clear()
|
|
{
|
|
int num = 0;
|
|
while ((long)num < (long)((ulong)this.length))
|
|
{
|
|
this.data[num] = 0U;
|
|
num++;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000029 RID: 41 RVA: 0x00002A5C File Offset: 0x00000C5C
|
|
public override int GetHashCode()
|
|
{
|
|
uint num = 0U;
|
|
for (uint num2 = 0U; num2 < this.length; num2 += 1U)
|
|
{
|
|
num ^= this.data[(int)((UIntPtr)num2)];
|
|
}
|
|
return (int)num;
|
|
}
|
|
|
|
// Token: 0x0600002A RID: 42 RVA: 0x00002A90 File Offset: 0x00000C90
|
|
public override string ToString()
|
|
{
|
|
return this.ToString(10U);
|
|
}
|
|
|
|
// Token: 0x0600002B RID: 43 RVA: 0x00002A9C File Offset: 0x00000C9C
|
|
public override bool Equals(object o)
|
|
{
|
|
if (o == null)
|
|
{
|
|
return false;
|
|
}
|
|
if (o is int)
|
|
{
|
|
return (int)o >= 0 && this == (uint)o;
|
|
}
|
|
BigInteger bigInteger = o as BigInteger;
|
|
return !(bigInteger == null) && BigInteger.Kernel.Compare(this, bigInteger) == BigInteger.Sign.Zero;
|
|
}
|
|
|
|
// Token: 0x0600002C RID: 44 RVA: 0x00002AF8 File Offset: 0x00000CF8
|
|
public BigInteger GCD(BigInteger bi)
|
|
{
|
|
return BigInteger.Kernel.gcd(this, bi);
|
|
}
|
|
|
|
// Token: 0x0600002D RID: 45 RVA: 0x00002B04 File Offset: 0x00000D04
|
|
public BigInteger ModInverse(BigInteger modulus)
|
|
{
|
|
return BigInteger.Kernel.modInverse(this, modulus);
|
|
}
|
|
|
|
// Token: 0x0600002E RID: 46 RVA: 0x00002B10 File Offset: 0x00000D10
|
|
public BigInteger ModPow(BigInteger exp, BigInteger n)
|
|
{
|
|
BigInteger.ModulusRing modulusRing = new BigInteger.ModulusRing(n);
|
|
return modulusRing.Pow(this, exp);
|
|
}
|
|
|
|
// Token: 0x0600002F RID: 47 RVA: 0x00002B2C File Offset: 0x00000D2C
|
|
public bool IsProbablePrime()
|
|
{
|
|
if (this <= BigInteger.smallPrimes[BigInteger.smallPrimes.Length - 1])
|
|
{
|
|
for (int i = 0; i < BigInteger.smallPrimes.Length; i++)
|
|
{
|
|
if (this == BigInteger.smallPrimes[i])
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
for (int j = 0; j < BigInteger.smallPrimes.Length; j++)
|
|
{
|
|
if (this % BigInteger.smallPrimes[j] == 0U)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return PrimalityTests.Test(this, ConfidenceFactor.Medium);
|
|
}
|
|
|
|
// Token: 0x06000030 RID: 48 RVA: 0x00002BBC File Offset: 0x00000DBC
|
|
public static BigInteger NextHighestPrime(BigInteger bi)
|
|
{
|
|
NextPrimeFinder nextPrimeFinder = new NextPrimeFinder();
|
|
return nextPrimeFinder.GenerateNewPrime(0, bi);
|
|
}
|
|
|
|
// Token: 0x06000031 RID: 49 RVA: 0x00002BD8 File Offset: 0x00000DD8
|
|
public static BigInteger GeneratePseudoPrime(int bits)
|
|
{
|
|
SequentialSearchPrimeGeneratorBase sequentialSearchPrimeGeneratorBase = new SequentialSearchPrimeGeneratorBase();
|
|
return sequentialSearchPrimeGeneratorBase.GenerateNewPrime(bits);
|
|
}
|
|
|
|
// Token: 0x06000032 RID: 50 RVA: 0x00002BF4 File Offset: 0x00000DF4
|
|
public void Incr2()
|
|
{
|
|
int num = 0;
|
|
this.data[0] += 2U;
|
|
if (this.data[0] < 2U)
|
|
{
|
|
this.data[++num] += 1U;
|
|
while (this.data[num++] == 0U)
|
|
{
|
|
this.data[num] += 1U;
|
|
}
|
|
if (this.length == (uint)num)
|
|
{
|
|
this.length += 1U;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000033 RID: 51 RVA: 0x00002C78 File Offset: 0x00000E78
|
|
[CLSCompliant(false)]
|
|
public static implicit operator BigInteger(uint value)
|
|
{
|
|
return new BigInteger(value);
|
|
}
|
|
|
|
// Token: 0x06000034 RID: 52 RVA: 0x00002C80 File Offset: 0x00000E80
|
|
public static implicit operator BigInteger(int value)
|
|
{
|
|
if (value < 0)
|
|
{
|
|
throw new ArgumentOutOfRangeException("value");
|
|
}
|
|
return new BigInteger((uint)value);
|
|
}
|
|
|
|
// Token: 0x06000035 RID: 53 RVA: 0x00002C9C File Offset: 0x00000E9C
|
|
[CLSCompliant(false)]
|
|
public static implicit operator BigInteger(ulong value)
|
|
{
|
|
return new BigInteger(value);
|
|
}
|
|
|
|
// Token: 0x06000036 RID: 54 RVA: 0x00002CA4 File Offset: 0x00000EA4
|
|
public static BigInteger operator +(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
if (bi1 == 0U)
|
|
{
|
|
return new BigInteger(bi2);
|
|
}
|
|
if (bi2 == 0U)
|
|
{
|
|
return new BigInteger(bi1);
|
|
}
|
|
return BigInteger.Kernel.AddSameSign(bi1, bi2);
|
|
}
|
|
|
|
// Token: 0x06000037 RID: 55 RVA: 0x00002CD4 File Offset: 0x00000ED4
|
|
public static BigInteger operator -(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
if (bi2 == 0U)
|
|
{
|
|
return new BigInteger(bi1);
|
|
}
|
|
if (bi1 == 0U)
|
|
{
|
|
throw new ArithmeticException("Operation would return a negative value");
|
|
}
|
|
BigInteger.Sign sign = BigInteger.Kernel.Compare(bi1, bi2);
|
|
switch (sign + 1)
|
|
{
|
|
case BigInteger.Sign.Zero:
|
|
throw new ArithmeticException("Operation would return a negative value");
|
|
case BigInteger.Sign.Positive:
|
|
return 0;
|
|
case (BigInteger.Sign)2:
|
|
return BigInteger.Kernel.Subtract(bi1, bi2);
|
|
default:
|
|
throw new Exception();
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000038 RID: 56 RVA: 0x00002D4C File Offset: 0x00000F4C
|
|
public static int operator %(BigInteger bi, int i)
|
|
{
|
|
if (i > 0)
|
|
{
|
|
return (int)BigInteger.Kernel.DwordMod(bi, (uint)i);
|
|
}
|
|
return (int)(-(int)BigInteger.Kernel.DwordMod(bi, (uint)(-(uint)i)));
|
|
}
|
|
|
|
// Token: 0x06000039 RID: 57 RVA: 0x00002D68 File Offset: 0x00000F68
|
|
[CLSCompliant(false)]
|
|
public static uint operator %(BigInteger bi, uint ui)
|
|
{
|
|
return BigInteger.Kernel.DwordMod(bi, ui);
|
|
}
|
|
|
|
// Token: 0x0600003A RID: 58 RVA: 0x00002D74 File Offset: 0x00000F74
|
|
public static BigInteger operator %(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
return BigInteger.Kernel.multiByteDivide(bi1, bi2)[1];
|
|
}
|
|
|
|
// Token: 0x0600003B RID: 59 RVA: 0x00002D80 File Offset: 0x00000F80
|
|
public static BigInteger operator /(BigInteger bi, int i)
|
|
{
|
|
if (i > 0)
|
|
{
|
|
return BigInteger.Kernel.DwordDiv(bi, (uint)i);
|
|
}
|
|
throw new ArithmeticException("Operation would return a negative value");
|
|
}
|
|
|
|
// Token: 0x0600003C RID: 60 RVA: 0x00002D9C File Offset: 0x00000F9C
|
|
public static BigInteger operator /(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
return BigInteger.Kernel.multiByteDivide(bi1, bi2)[0];
|
|
}
|
|
|
|
// Token: 0x0600003D RID: 61 RVA: 0x00002DA8 File Offset: 0x00000FA8
|
|
public static BigInteger operator *(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
if (bi1 == 0U || bi2 == 0U)
|
|
{
|
|
return 0;
|
|
}
|
|
if ((long)bi1.data.Length < (long)((ulong)bi1.length))
|
|
{
|
|
throw new IndexOutOfRangeException("bi1 out of range");
|
|
}
|
|
if ((long)bi2.data.Length < (long)((ulong)bi2.length))
|
|
{
|
|
throw new IndexOutOfRangeException("bi2 out of range");
|
|
}
|
|
BigInteger bigInteger = new BigInteger(BigInteger.Sign.Positive, bi1.length + bi2.length);
|
|
BigInteger.Kernel.Multiply(bi1.data, 0U, bi1.length, bi2.data, 0U, bi2.length, bigInteger.data, 0U);
|
|
bigInteger.Normalize();
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x0600003E RID: 62 RVA: 0x00002E58 File Offset: 0x00001058
|
|
public static BigInteger operator *(BigInteger bi, int i)
|
|
{
|
|
if (i < 0)
|
|
{
|
|
throw new ArithmeticException("Operation would return a negative value");
|
|
}
|
|
if (i == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
if (i == 1)
|
|
{
|
|
return new BigInteger(bi);
|
|
}
|
|
return BigInteger.Kernel.MultiplyByDword(bi, (uint)i);
|
|
}
|
|
|
|
// Token: 0x0600003F RID: 63 RVA: 0x00002E9C File Offset: 0x0000109C
|
|
public static BigInteger operator <<(BigInteger bi1, int shiftVal)
|
|
{
|
|
return BigInteger.Kernel.LeftShift(bi1, shiftVal);
|
|
}
|
|
|
|
// Token: 0x06000040 RID: 64 RVA: 0x00002EA8 File Offset: 0x000010A8
|
|
public static BigInteger operator >>(BigInteger bi1, int shiftVal)
|
|
{
|
|
return BigInteger.Kernel.RightShift(bi1, shiftVal);
|
|
}
|
|
|
|
// Token: 0x06000041 RID: 65 RVA: 0x00002EB4 File Offset: 0x000010B4
|
|
[CLSCompliant(false)]
|
|
public static bool operator ==(BigInteger bi1, uint ui)
|
|
{
|
|
if (bi1.length != 1U)
|
|
{
|
|
bi1.Normalize();
|
|
}
|
|
return bi1.length == 1U && bi1.data[0] == ui;
|
|
}
|
|
|
|
// Token: 0x06000042 RID: 66 RVA: 0x00002EF0 File Offset: 0x000010F0
|
|
[CLSCompliant(false)]
|
|
public static bool operator !=(BigInteger bi1, uint ui)
|
|
{
|
|
if (bi1.length != 1U)
|
|
{
|
|
bi1.Normalize();
|
|
}
|
|
return bi1.length != 1U || bi1.data[0] != ui;
|
|
}
|
|
|
|
// Token: 0x06000043 RID: 67 RVA: 0x00002F24 File Offset: 0x00001124
|
|
public static bool operator ==(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
return bi1 == bi2 || (!(null == bi1) && !(null == bi2) && BigInteger.Kernel.Compare(bi1, bi2) == BigInteger.Sign.Zero);
|
|
}
|
|
|
|
// Token: 0x06000044 RID: 68 RVA: 0x00002F54 File Offset: 0x00001154
|
|
public static bool operator !=(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
return bi1 != bi2 && (null == bi1 || null == bi2 || BigInteger.Kernel.Compare(bi1, bi2) != BigInteger.Sign.Zero);
|
|
}
|
|
|
|
// Token: 0x06000045 RID: 69 RVA: 0x00002F94 File Offset: 0x00001194
|
|
public static bool operator >(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
return BigInteger.Kernel.Compare(bi1, bi2) > BigInteger.Sign.Zero;
|
|
}
|
|
|
|
// Token: 0x06000046 RID: 70 RVA: 0x00002FA0 File Offset: 0x000011A0
|
|
public static bool operator <(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
return BigInteger.Kernel.Compare(bi1, bi2) < BigInteger.Sign.Zero;
|
|
}
|
|
|
|
// Token: 0x06000047 RID: 71 RVA: 0x00002FAC File Offset: 0x000011AC
|
|
public static bool operator >=(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
return BigInteger.Kernel.Compare(bi1, bi2) >= BigInteger.Sign.Zero;
|
|
}
|
|
|
|
// Token: 0x06000048 RID: 72 RVA: 0x00002FBC File Offset: 0x000011BC
|
|
public static bool operator <=(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
return BigInteger.Kernel.Compare(bi1, bi2) <= BigInteger.Sign.Zero;
|
|
}
|
|
|
|
// Token: 0x0400001E RID: 30
|
|
private const uint DEFAULT_LEN = 20U;
|
|
|
|
// Token: 0x0400001F RID: 31
|
|
private const string WouldReturnNegVal = "Operation would return a negative value";
|
|
|
|
// Token: 0x04000020 RID: 32
|
|
private uint length = 1U;
|
|
|
|
// Token: 0x04000021 RID: 33
|
|
private uint[] data;
|
|
|
|
// Token: 0x04000022 RID: 34
|
|
internal static readonly uint[] smallPrimes = new uint[]
|
|
{
|
|
2U, 3U, 5U, 7U, 11U, 13U, 17U, 19U, 23U, 29U,
|
|
31U, 37U, 41U, 43U, 47U, 53U, 59U, 61U, 67U, 71U,
|
|
73U, 79U, 83U, 89U, 97U, 101U, 103U, 107U, 109U, 113U,
|
|
127U, 131U, 137U, 139U, 149U, 151U, 157U, 163U, 167U, 173U,
|
|
179U, 181U, 191U, 193U, 197U, 199U, 211U, 223U, 227U, 229U,
|
|
233U, 239U, 241U, 251U, 257U, 263U, 269U, 271U, 277U, 281U,
|
|
283U, 293U, 307U, 311U, 313U, 317U, 331U, 337U, 347U, 349U,
|
|
353U, 359U, 367U, 373U, 379U, 383U, 389U, 397U, 401U, 409U,
|
|
419U, 421U, 431U, 433U, 439U, 443U, 449U, 457U, 461U, 463U,
|
|
467U, 479U, 487U, 491U, 499U, 503U, 509U, 521U, 523U, 541U,
|
|
547U, 557U, 563U, 569U, 571U, 577U, 587U, 593U, 599U, 601U,
|
|
607U, 613U, 617U, 619U, 631U, 641U, 643U, 647U, 653U, 659U,
|
|
661U, 673U, 677U, 683U, 691U, 701U, 709U, 719U, 727U, 733U,
|
|
739U, 743U, 751U, 757U, 761U, 769U, 773U, 787U, 797U, 809U,
|
|
811U, 821U, 823U, 827U, 829U, 839U, 853U, 857U, 859U, 863U,
|
|
877U, 881U, 883U, 887U, 907U, 911U, 919U, 929U, 937U, 941U,
|
|
947U, 953U, 967U, 971U, 977U, 983U, 991U, 997U, 1009U, 1013U,
|
|
1019U, 1021U, 1031U, 1033U, 1039U, 1049U, 1051U, 1061U, 1063U, 1069U,
|
|
1087U, 1091U, 1093U, 1097U, 1103U, 1109U, 1117U, 1123U, 1129U, 1151U,
|
|
1153U, 1163U, 1171U, 1181U, 1187U, 1193U, 1201U, 1213U, 1217U, 1223U,
|
|
1229U, 1231U, 1237U, 1249U, 1259U, 1277U, 1279U, 1283U, 1289U, 1291U,
|
|
1297U, 1301U, 1303U, 1307U, 1319U, 1321U, 1327U, 1361U, 1367U, 1373U,
|
|
1381U, 1399U, 1409U, 1423U, 1427U, 1429U, 1433U, 1439U, 1447U, 1451U,
|
|
1453U, 1459U, 1471U, 1481U, 1483U, 1487U, 1489U, 1493U, 1499U, 1511U,
|
|
1523U, 1531U, 1543U, 1549U, 1553U, 1559U, 1567U, 1571U, 1579U, 1583U,
|
|
1597U, 1601U, 1607U, 1609U, 1613U, 1619U, 1621U, 1627U, 1637U, 1657U,
|
|
1663U, 1667U, 1669U, 1693U, 1697U, 1699U, 1709U, 1721U, 1723U, 1733U,
|
|
1741U, 1747U, 1753U, 1759U, 1777U, 1783U, 1787U, 1789U, 1801U, 1811U,
|
|
1823U, 1831U, 1847U, 1861U, 1867U, 1871U, 1873U, 1877U, 1879U, 1889U,
|
|
1901U, 1907U, 1913U, 1931U, 1933U, 1949U, 1951U, 1973U, 1979U, 1987U,
|
|
1993U, 1997U, 1999U, 2003U, 2011U, 2017U, 2027U, 2029U, 2039U, 2053U,
|
|
2063U, 2069U, 2081U, 2083U, 2087U, 2089U, 2099U, 2111U, 2113U, 2129U,
|
|
2131U, 2137U, 2141U, 2143U, 2153U, 2161U, 2179U, 2203U, 2207U, 2213U,
|
|
2221U, 2237U, 2239U, 2243U, 2251U, 2267U, 2269U, 2273U, 2281U, 2287U,
|
|
2293U, 2297U, 2309U, 2311U, 2333U, 2339U, 2341U, 2347U, 2351U, 2357U,
|
|
2371U, 2377U, 2381U, 2383U, 2389U, 2393U, 2399U, 2411U, 2417U, 2423U,
|
|
2437U, 2441U, 2447U, 2459U, 2467U, 2473U, 2477U, 2503U, 2521U, 2531U,
|
|
2539U, 2543U, 2549U, 2551U, 2557U, 2579U, 2591U, 2593U, 2609U, 2617U,
|
|
2621U, 2633U, 2647U, 2657U, 2659U, 2663U, 2671U, 2677U, 2683U, 2687U,
|
|
2689U, 2693U, 2699U, 2707U, 2711U, 2713U, 2719U, 2729U, 2731U, 2741U,
|
|
2749U, 2753U, 2767U, 2777U, 2789U, 2791U, 2797U, 2801U, 2803U, 2819U,
|
|
2833U, 2837U, 2843U, 2851U, 2857U, 2861U, 2879U, 2887U, 2897U, 2903U,
|
|
2909U, 2917U, 2927U, 2939U, 2953U, 2957U, 2963U, 2969U, 2971U, 2999U,
|
|
3001U, 3011U, 3019U, 3023U, 3037U, 3041U, 3049U, 3061U, 3067U, 3079U,
|
|
3083U, 3089U, 3109U, 3119U, 3121U, 3137U, 3163U, 3167U, 3169U, 3181U,
|
|
3187U, 3191U, 3203U, 3209U, 3217U, 3221U, 3229U, 3251U, 3253U, 3257U,
|
|
3259U, 3271U, 3299U, 3301U, 3307U, 3313U, 3319U, 3323U, 3329U, 3331U,
|
|
3343U, 3347U, 3359U, 3361U, 3371U, 3373U, 3389U, 3391U, 3407U, 3413U,
|
|
3433U, 3449U, 3457U, 3461U, 3463U, 3467U, 3469U, 3491U, 3499U, 3511U,
|
|
3517U, 3527U, 3529U, 3533U, 3539U, 3541U, 3547U, 3557U, 3559U, 3571U,
|
|
3581U, 3583U, 3593U, 3607U, 3613U, 3617U, 3623U, 3631U, 3637U, 3643U,
|
|
3659U, 3671U, 3673U, 3677U, 3691U, 3697U, 3701U, 3709U, 3719U, 3727U,
|
|
3733U, 3739U, 3761U, 3767U, 3769U, 3779U, 3793U, 3797U, 3803U, 3821U,
|
|
3823U, 3833U, 3847U, 3851U, 3853U, 3863U, 3877U, 3881U, 3889U, 3907U,
|
|
3911U, 3917U, 3919U, 3923U, 3929U, 3931U, 3943U, 3947U, 3967U, 3989U,
|
|
4001U, 4003U, 4007U, 4013U, 4019U, 4021U, 4027U, 4049U, 4051U, 4057U,
|
|
4073U, 4079U, 4091U, 4093U, 4099U, 4111U, 4127U, 4129U, 4133U, 4139U,
|
|
4153U, 4157U, 4159U, 4177U, 4201U, 4211U, 4217U, 4219U, 4229U, 4231U,
|
|
4241U, 4243U, 4253U, 4259U, 4261U, 4271U, 4273U, 4283U, 4289U, 4297U,
|
|
4327U, 4337U, 4339U, 4349U, 4357U, 4363U, 4373U, 4391U, 4397U, 4409U,
|
|
4421U, 4423U, 4441U, 4447U, 4451U, 4457U, 4463U, 4481U, 4483U, 4493U,
|
|
4507U, 4513U, 4517U, 4519U, 4523U, 4547U, 4549U, 4561U, 4567U, 4583U,
|
|
4591U, 4597U, 4603U, 4621U, 4637U, 4639U, 4643U, 4649U, 4651U, 4657U,
|
|
4663U, 4673U, 4679U, 4691U, 4703U, 4721U, 4723U, 4729U, 4733U, 4751U,
|
|
4759U, 4783U, 4787U, 4789U, 4793U, 4799U, 4801U, 4813U, 4817U, 4831U,
|
|
4861U, 4871U, 4877U, 4889U, 4903U, 4909U, 4919U, 4931U, 4933U, 4937U,
|
|
4943U, 4951U, 4957U, 4967U, 4969U, 4973U, 4987U, 4993U, 4999U, 5003U,
|
|
5009U, 5011U, 5021U, 5023U, 5039U, 5051U, 5059U, 5077U, 5081U, 5087U,
|
|
5099U, 5101U, 5107U, 5113U, 5119U, 5147U, 5153U, 5167U, 5171U, 5179U,
|
|
5189U, 5197U, 5209U, 5227U, 5231U, 5233U, 5237U, 5261U, 5273U, 5279U,
|
|
5281U, 5297U, 5303U, 5309U, 5323U, 5333U, 5347U, 5351U, 5381U, 5387U,
|
|
5393U, 5399U, 5407U, 5413U, 5417U, 5419U, 5431U, 5437U, 5441U, 5443U,
|
|
5449U, 5471U, 5477U, 5479U, 5483U, 5501U, 5503U, 5507U, 5519U, 5521U,
|
|
5527U, 5531U, 5557U, 5563U, 5569U, 5573U, 5581U, 5591U, 5623U, 5639U,
|
|
5641U, 5647U, 5651U, 5653U, 5657U, 5659U, 5669U, 5683U, 5689U, 5693U,
|
|
5701U, 5711U, 5717U, 5737U, 5741U, 5743U, 5749U, 5779U, 5783U, 5791U,
|
|
5801U, 5807U, 5813U, 5821U, 5827U, 5839U, 5843U, 5849U, 5851U, 5857U,
|
|
5861U, 5867U, 5869U, 5879U, 5881U, 5897U, 5903U, 5923U, 5927U, 5939U,
|
|
5953U, 5981U, 5987U
|
|
};
|
|
|
|
// Token: 0x04000023 RID: 35
|
|
private static RandomNumberGenerator rng;
|
|
|
|
// Token: 0x02000005 RID: 5
|
|
public enum Sign
|
|
{
|
|
// Token: 0x04000025 RID: 37
|
|
Negative = -1,
|
|
// Token: 0x04000026 RID: 38
|
|
Zero,
|
|
// Token: 0x04000027 RID: 39
|
|
Positive
|
|
}
|
|
|
|
// Token: 0x02000006 RID: 6
|
|
public sealed class ModulusRing
|
|
{
|
|
// Token: 0x06000049 RID: 73 RVA: 0x00002FCC File Offset: 0x000011CC
|
|
public ModulusRing(BigInteger modulus)
|
|
{
|
|
this.mod = modulus;
|
|
uint num = this.mod.length << 1;
|
|
this.constant = new BigInteger(BigInteger.Sign.Positive, num + 1U);
|
|
this.constant.data[(int)((UIntPtr)num)] = 1U;
|
|
this.constant /= this.mod;
|
|
}
|
|
|
|
// Token: 0x0600004A RID: 74 RVA: 0x0000302C File Offset: 0x0000122C
|
|
public void BarrettReduction(BigInteger x)
|
|
{
|
|
BigInteger bigInteger = this.mod;
|
|
uint length = bigInteger.length;
|
|
uint num = length + 1U;
|
|
uint num2 = length - 1U;
|
|
if (x.length < length)
|
|
{
|
|
return;
|
|
}
|
|
if ((long)x.data.Length < (long)((ulong)x.length))
|
|
{
|
|
throw new IndexOutOfRangeException("x out of range");
|
|
}
|
|
BigInteger bigInteger2 = new BigInteger(BigInteger.Sign.Positive, x.length - num2 + this.constant.length);
|
|
BigInteger.Kernel.Multiply(x.data, num2, x.length - num2, this.constant.data, 0U, this.constant.length, bigInteger2.data, 0U);
|
|
uint num3 = ((x.length <= num) ? x.length : num);
|
|
x.length = num3;
|
|
x.Normalize();
|
|
BigInteger bigInteger3 = new BigInteger(BigInteger.Sign.Positive, num);
|
|
BigInteger.Kernel.MultiplyMod2p32pmod(bigInteger2.data, (int)num, (int)(bigInteger2.length - num), bigInteger.data, 0, (int)bigInteger.length, bigInteger3.data, 0, (int)num);
|
|
bigInteger3.Normalize();
|
|
if (bigInteger3 <= x)
|
|
{
|
|
BigInteger.Kernel.MinusEq(x, bigInteger3);
|
|
}
|
|
else
|
|
{
|
|
BigInteger bigInteger4 = new BigInteger(BigInteger.Sign.Positive, num + 1U);
|
|
bigInteger4.data[(int)((UIntPtr)num)] = 1U;
|
|
BigInteger.Kernel.MinusEq(bigInteger4, bigInteger3);
|
|
BigInteger.Kernel.PlusEq(x, bigInteger4);
|
|
}
|
|
while (x >= bigInteger)
|
|
{
|
|
BigInteger.Kernel.MinusEq(x, bigInteger);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600004B RID: 75 RVA: 0x00003188 File Offset: 0x00001388
|
|
public BigInteger Multiply(BigInteger a, BigInteger b)
|
|
{
|
|
if (a == 0U || b == 0U)
|
|
{
|
|
return 0;
|
|
}
|
|
if (a > this.mod)
|
|
{
|
|
a %= this.mod;
|
|
}
|
|
if (b > this.mod)
|
|
{
|
|
b %= this.mod;
|
|
}
|
|
BigInteger bigInteger = new BigInteger(a * b);
|
|
this.BarrettReduction(bigInteger);
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x0600004C RID: 76 RVA: 0x00003208 File Offset: 0x00001408
|
|
public BigInteger Difference(BigInteger a, BigInteger b)
|
|
{
|
|
BigInteger.Sign sign = BigInteger.Kernel.Compare(a, b);
|
|
BigInteger.Sign sign2 = sign;
|
|
BigInteger bigInteger;
|
|
switch (sign2 + 1)
|
|
{
|
|
case BigInteger.Sign.Zero:
|
|
bigInteger = b - a;
|
|
break;
|
|
case BigInteger.Sign.Positive:
|
|
return 0;
|
|
case (BigInteger.Sign)2:
|
|
bigInteger = a - b;
|
|
break;
|
|
default:
|
|
throw new Exception();
|
|
}
|
|
if (bigInteger >= this.mod)
|
|
{
|
|
if (bigInteger.length >= this.mod.length << 1)
|
|
{
|
|
bigInteger %= this.mod;
|
|
}
|
|
else
|
|
{
|
|
this.BarrettReduction(bigInteger);
|
|
}
|
|
}
|
|
if (sign == BigInteger.Sign.Negative)
|
|
{
|
|
bigInteger = this.mod - bigInteger;
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x0600004D RID: 77 RVA: 0x000032B8 File Offset: 0x000014B8
|
|
public BigInteger Pow(BigInteger a, BigInteger k)
|
|
{
|
|
BigInteger bigInteger = new BigInteger(1U);
|
|
if (k == 0U)
|
|
{
|
|
return bigInteger;
|
|
}
|
|
BigInteger bigInteger2 = a;
|
|
if (k.TestBit(0))
|
|
{
|
|
bigInteger = a;
|
|
}
|
|
for (int i = 1; i < k.BitCount(); i++)
|
|
{
|
|
bigInteger2 = this.Multiply(bigInteger2, bigInteger2);
|
|
if (k.TestBit(i))
|
|
{
|
|
bigInteger = this.Multiply(bigInteger2, bigInteger);
|
|
}
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x0600004E RID: 78 RVA: 0x00003320 File Offset: 0x00001520
|
|
[CLSCompliant(false)]
|
|
public BigInteger Pow(uint b, BigInteger exp)
|
|
{
|
|
return this.Pow(new BigInteger(b), exp);
|
|
}
|
|
|
|
// Token: 0x04000028 RID: 40
|
|
private BigInteger mod;
|
|
|
|
// Token: 0x04000029 RID: 41
|
|
private BigInteger constant;
|
|
}
|
|
|
|
// Token: 0x02000007 RID: 7
|
|
internal sealed class Montgomery
|
|
{
|
|
// Token: 0x0600004F RID: 79 RVA: 0x00003330 File Offset: 0x00001530
|
|
private Montgomery()
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000050 RID: 80 RVA: 0x00003338 File Offset: 0x00001538
|
|
public static uint Inverse(uint n)
|
|
{
|
|
uint num = n;
|
|
uint num2;
|
|
while ((num2 = n * num) != 1U)
|
|
{
|
|
num *= 2U - num2;
|
|
}
|
|
return (uint)(-(uint)((ulong)num));
|
|
}
|
|
|
|
// Token: 0x06000051 RID: 81 RVA: 0x00003364 File Offset: 0x00001564
|
|
public static BigInteger ToMont(BigInteger n, BigInteger m)
|
|
{
|
|
n.Normalize();
|
|
m.Normalize();
|
|
n <<= (int)(m.length * 32U);
|
|
n %= m;
|
|
return n;
|
|
}
|
|
|
|
// Token: 0x06000052 RID: 82 RVA: 0x00003390 File Offset: 0x00001590
|
|
public unsafe static BigInteger Reduce(BigInteger n, BigInteger m, uint mPrime)
|
|
{
|
|
fixed (uint* ptr = (ref n.data != null && n.data.Length != 0 ? ref n.data[0] : ref *null), ptr2 = (ref m.data != null && m.data.Length != 0 ? ref m.data[0] : ref *null))
|
|
{
|
|
for (uint num = 0U; num < m.length; num += 1U)
|
|
{
|
|
uint num2 = *ptr * mPrime;
|
|
uint* ptr3 = ptr2;
|
|
uint* ptr4 = ptr;
|
|
uint* ptr5 = ptr;
|
|
ulong num3 = (ulong)num2 * (ulong)(*(ptr3++)) + (ulong)(*(ptr4++));
|
|
num3 >>= 32;
|
|
uint num4;
|
|
for (num4 = 1U; num4 < m.length; num4 += 1U)
|
|
{
|
|
num3 += (ulong)num2 * (ulong)(*(ptr3++)) + (ulong)(*(ptr4++));
|
|
*(ptr5++) = (uint)num3;
|
|
num3 >>= 32;
|
|
}
|
|
while (num4 < n.length)
|
|
{
|
|
num3 += (ulong)(*(ptr4++));
|
|
*(ptr5++) = (uint)num3;
|
|
num3 >>= 32;
|
|
if (num3 == 0UL)
|
|
{
|
|
num4 += 1U;
|
|
break;
|
|
}
|
|
num4 += 1U;
|
|
}
|
|
while (num4 < n.length)
|
|
{
|
|
*(ptr5++) = *(ptr4++);
|
|
num4 += 1U;
|
|
}
|
|
*(ptr5++) = (uint)num3;
|
|
}
|
|
while (n.length > 1U && ptr[n.length - 1U] == 0U)
|
|
{
|
|
n.length -= 1U;
|
|
}
|
|
}
|
|
if (n >= m)
|
|
{
|
|
BigInteger.Kernel.MinusEq(n, m);
|
|
}
|
|
return n;
|
|
}
|
|
}
|
|
|
|
// Token: 0x02000008 RID: 8
|
|
private sealed class Kernel
|
|
{
|
|
// Token: 0x06000054 RID: 84 RVA: 0x00003564 File Offset: 0x00001764
|
|
public static BigInteger AddSameSign(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
uint num = 0U;
|
|
uint[] array;
|
|
uint num2;
|
|
uint[] array2;
|
|
uint num3;
|
|
if (bi1.length < bi2.length)
|
|
{
|
|
array = bi2.data;
|
|
num2 = bi2.length;
|
|
array2 = bi1.data;
|
|
num3 = bi1.length;
|
|
}
|
|
else
|
|
{
|
|
array = bi1.data;
|
|
num2 = bi1.length;
|
|
array2 = bi2.data;
|
|
num3 = bi2.length;
|
|
}
|
|
BigInteger bigInteger = new BigInteger(BigInteger.Sign.Positive, num2 + 1U);
|
|
uint[] data = bigInteger.data;
|
|
ulong num4 = 0UL;
|
|
do
|
|
{
|
|
num4 = (ulong)array[(int)((UIntPtr)num)] + (ulong)array2[(int)((UIntPtr)num)] + num4;
|
|
data[(int)((UIntPtr)num)] = (uint)num4;
|
|
num4 >>= 32;
|
|
}
|
|
while ((num += 1U) < num3);
|
|
bool flag = num4 != 0UL;
|
|
if (flag)
|
|
{
|
|
if (num < num2)
|
|
{
|
|
do
|
|
{
|
|
flag = (data[(int)((UIntPtr)num)] = array[(int)((UIntPtr)num)] + 1U) == 0U;
|
|
}
|
|
while ((num += 1U) < num2 && flag);
|
|
}
|
|
if (flag)
|
|
{
|
|
data[(int)((UIntPtr)num)] = 1U;
|
|
bigInteger.length = num + 1U;
|
|
return bigInteger;
|
|
}
|
|
}
|
|
if (num < num2)
|
|
{
|
|
do
|
|
{
|
|
data[(int)((UIntPtr)num)] = array[(int)((UIntPtr)num)];
|
|
}
|
|
while ((num += 1U) < num2);
|
|
}
|
|
bigInteger.Normalize();
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x06000055 RID: 85 RVA: 0x00003698 File Offset: 0x00001898
|
|
public static BigInteger Subtract(BigInteger big, BigInteger small)
|
|
{
|
|
BigInteger bigInteger = new BigInteger(BigInteger.Sign.Positive, big.length);
|
|
uint[] data = bigInteger.data;
|
|
uint[] data2 = big.data;
|
|
uint[] data3 = small.data;
|
|
uint num = 0U;
|
|
uint num2 = 0U;
|
|
do
|
|
{
|
|
uint num3 = data3[(int)((UIntPtr)num)];
|
|
if (((num3 += num2) < num2) | ((data[(int)((UIntPtr)num)] = data2[(int)((UIntPtr)num)] - num3) > ~num3))
|
|
{
|
|
num2 = 1U;
|
|
}
|
|
else
|
|
{
|
|
num2 = 0U;
|
|
}
|
|
}
|
|
while ((num += 1U) < small.length);
|
|
if (num != big.length)
|
|
{
|
|
if (num2 == 1U)
|
|
{
|
|
do
|
|
{
|
|
data[(int)((UIntPtr)num)] = data2[(int)((UIntPtr)num)] - 1U;
|
|
}
|
|
while (data2[(int)((UIntPtr)(num++))] == 0U && num < big.length);
|
|
if (num == big.length)
|
|
{
|
|
goto IL_E5;
|
|
}
|
|
}
|
|
do
|
|
{
|
|
data[(int)((UIntPtr)num)] = data2[(int)((UIntPtr)num)];
|
|
}
|
|
while ((num += 1U) < big.length);
|
|
}
|
|
IL_E5:
|
|
bigInteger.Normalize();
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x06000056 RID: 86 RVA: 0x00003794 File Offset: 0x00001994
|
|
public static void MinusEq(BigInteger big, BigInteger small)
|
|
{
|
|
uint[] data = big.data;
|
|
uint[] data2 = small.data;
|
|
uint num = 0U;
|
|
uint num2 = 0U;
|
|
do
|
|
{
|
|
uint num3 = data2[(int)((UIntPtr)num)];
|
|
if (((num3 += num2) < num2) | ((data[(int)((UIntPtr)num)] -= num3) > ~num3))
|
|
{
|
|
num2 = 1U;
|
|
}
|
|
else
|
|
{
|
|
num2 = 0U;
|
|
}
|
|
}
|
|
while ((num += 1U) < small.length);
|
|
if (num != big.length)
|
|
{
|
|
if (num2 == 1U)
|
|
{
|
|
do
|
|
{
|
|
data[(int)((UIntPtr)num)] -= 1U;
|
|
}
|
|
while (data[(int)((UIntPtr)(num++))] == 0U && num < big.length);
|
|
}
|
|
}
|
|
while (big.length > 0U && big.data[(int)((UIntPtr)(big.length - 1U))] == 0U)
|
|
{
|
|
big.length -= 1U;
|
|
}
|
|
if (big.length == 0U)
|
|
{
|
|
big.length += 1U;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000057 RID: 87 RVA: 0x00003888 File Offset: 0x00001A88
|
|
public static void PlusEq(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
uint num = 0U;
|
|
bool flag = false;
|
|
uint[] array;
|
|
uint num2;
|
|
uint[] array2;
|
|
uint num3;
|
|
if (bi1.length < bi2.length)
|
|
{
|
|
flag = true;
|
|
array = bi2.data;
|
|
num2 = bi2.length;
|
|
array2 = bi1.data;
|
|
num3 = bi1.length;
|
|
}
|
|
else
|
|
{
|
|
array = bi1.data;
|
|
num2 = bi1.length;
|
|
array2 = bi2.data;
|
|
num3 = bi2.length;
|
|
}
|
|
uint[] data = bi1.data;
|
|
ulong num4 = 0UL;
|
|
do
|
|
{
|
|
num4 += (ulong)array[(int)((UIntPtr)num)] + (ulong)array2[(int)((UIntPtr)num)];
|
|
data[(int)((UIntPtr)num)] = (uint)num4;
|
|
num4 >>= 32;
|
|
}
|
|
while ((num += 1U) < num3);
|
|
bool flag2 = num4 != 0UL;
|
|
if (flag2)
|
|
{
|
|
if (num < num2)
|
|
{
|
|
do
|
|
{
|
|
flag2 = (data[(int)((UIntPtr)num)] = array[(int)((UIntPtr)num)] + 1U) == 0U;
|
|
}
|
|
while ((num += 1U) < num2 && flag2);
|
|
}
|
|
if (flag2)
|
|
{
|
|
data[(int)((UIntPtr)num)] = 1U;
|
|
bi1.length = num + 1U;
|
|
return;
|
|
}
|
|
}
|
|
if (flag && num < num2 - 1U)
|
|
{
|
|
do
|
|
{
|
|
data[(int)((UIntPtr)num)] = array[(int)((UIntPtr)num)];
|
|
}
|
|
while ((num += 1U) < num2);
|
|
}
|
|
bi1.length = num2 + 1U;
|
|
bi1.Normalize();
|
|
}
|
|
|
|
// Token: 0x06000058 RID: 88 RVA: 0x000039C0 File Offset: 0x00001BC0
|
|
public static BigInteger.Sign Compare(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
uint num = bi1.length;
|
|
uint num2 = bi2.length;
|
|
while (num > 0U && bi1.data[(int)((UIntPtr)(num - 1U))] == 0U)
|
|
{
|
|
num -= 1U;
|
|
}
|
|
while (num2 > 0U && bi2.data[(int)((UIntPtr)(num2 - 1U))] == 0U)
|
|
{
|
|
num2 -= 1U;
|
|
}
|
|
if (num == 0U && num2 == 0U)
|
|
{
|
|
return BigInteger.Sign.Zero;
|
|
}
|
|
if (num < num2)
|
|
{
|
|
return BigInteger.Sign.Negative;
|
|
}
|
|
if (num > num2)
|
|
{
|
|
return BigInteger.Sign.Positive;
|
|
}
|
|
uint num3 = num - 1U;
|
|
while (num3 != 0U && bi1.data[(int)((UIntPtr)num3)] == bi2.data[(int)((UIntPtr)num3)])
|
|
{
|
|
num3 -= 1U;
|
|
}
|
|
if (bi1.data[(int)((UIntPtr)num3)] < bi2.data[(int)((UIntPtr)num3)])
|
|
{
|
|
return BigInteger.Sign.Negative;
|
|
}
|
|
if (bi1.data[(int)((UIntPtr)num3)] > bi2.data[(int)((UIntPtr)num3)])
|
|
{
|
|
return BigInteger.Sign.Positive;
|
|
}
|
|
return BigInteger.Sign.Zero;
|
|
}
|
|
|
|
// Token: 0x06000059 RID: 89 RVA: 0x00003A98 File Offset: 0x00001C98
|
|
public static uint SingleByteDivideInPlace(BigInteger n, uint d)
|
|
{
|
|
ulong num = 0UL;
|
|
uint length = n.length;
|
|
while (length-- > 0U)
|
|
{
|
|
num <<= 32;
|
|
num |= (ulong)n.data[(int)((UIntPtr)length)];
|
|
n.data[(int)((UIntPtr)length)] = (uint)(num / (ulong)d);
|
|
num %= (ulong)d;
|
|
}
|
|
n.Normalize();
|
|
return (uint)num;
|
|
}
|
|
|
|
// Token: 0x0600005A RID: 90 RVA: 0x00003AEC File Offset: 0x00001CEC
|
|
public static uint DwordMod(BigInteger n, uint d)
|
|
{
|
|
ulong num = 0UL;
|
|
uint length = n.length;
|
|
while (length-- > 0U)
|
|
{
|
|
num <<= 32;
|
|
num |= (ulong)n.data[(int)((UIntPtr)length)];
|
|
num %= (ulong)d;
|
|
}
|
|
return (uint)num;
|
|
}
|
|
|
|
// Token: 0x0600005B RID: 91 RVA: 0x00003B2C File Offset: 0x00001D2C
|
|
public static BigInteger DwordDiv(BigInteger n, uint d)
|
|
{
|
|
BigInteger bigInteger = new BigInteger(BigInteger.Sign.Positive, n.length);
|
|
ulong num = 0UL;
|
|
uint length = n.length;
|
|
while (length-- > 0U)
|
|
{
|
|
num <<= 32;
|
|
num |= (ulong)n.data[(int)((UIntPtr)length)];
|
|
bigInteger.data[(int)((UIntPtr)length)] = (uint)(num / (ulong)d);
|
|
num %= (ulong)d;
|
|
}
|
|
bigInteger.Normalize();
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x0600005C RID: 92 RVA: 0x00003B8C File Offset: 0x00001D8C
|
|
public static BigInteger[] DwordDivMod(BigInteger n, uint d)
|
|
{
|
|
BigInteger bigInteger = new BigInteger(BigInteger.Sign.Positive, n.length);
|
|
ulong num = 0UL;
|
|
uint length = n.length;
|
|
while (length-- > 0U)
|
|
{
|
|
num <<= 32;
|
|
num |= (ulong)n.data[(int)((UIntPtr)length)];
|
|
bigInteger.data[(int)((UIntPtr)length)] = (uint)(num / (ulong)d);
|
|
num %= (ulong)d;
|
|
}
|
|
bigInteger.Normalize();
|
|
BigInteger bigInteger2 = (uint)num;
|
|
return new BigInteger[] { bigInteger, bigInteger2 };
|
|
}
|
|
|
|
// Token: 0x0600005D RID: 93 RVA: 0x00003C04 File Offset: 0x00001E04
|
|
public static BigInteger[] multiByteDivide(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
if (BigInteger.Kernel.Compare(bi1, bi2) == BigInteger.Sign.Negative)
|
|
{
|
|
return new BigInteger[]
|
|
{
|
|
0,
|
|
new BigInteger(bi1)
|
|
};
|
|
}
|
|
bi1.Normalize();
|
|
bi2.Normalize();
|
|
if (bi2.length == 1U)
|
|
{
|
|
return BigInteger.Kernel.DwordDivMod(bi1, bi2.data[0]);
|
|
}
|
|
uint num = bi1.length + 1U;
|
|
int num2 = (int)(bi2.length + 1U);
|
|
uint num3 = 2147483648U;
|
|
uint num4 = bi2.data[(int)((UIntPtr)(bi2.length - 1U))];
|
|
int num5 = 0;
|
|
int num6 = (int)(bi1.length - bi2.length);
|
|
while (num3 != 0U && (num4 & num3) == 0U)
|
|
{
|
|
num5++;
|
|
num3 >>= 1;
|
|
}
|
|
BigInteger bigInteger = new BigInteger(BigInteger.Sign.Positive, bi1.length - bi2.length + 1U);
|
|
BigInteger bigInteger2 = bi1 << num5;
|
|
uint[] data = bigInteger2.data;
|
|
bi2 <<= num5;
|
|
int i = (int)(num - bi2.length);
|
|
int num7 = (int)(num - 1U);
|
|
uint num8 = bi2.data[(int)((UIntPtr)(bi2.length - 1U))];
|
|
ulong num9 = (ulong)bi2.data[(int)((UIntPtr)(bi2.length - 2U))];
|
|
while (i > 0)
|
|
{
|
|
ulong num10 = ((ulong)data[num7] << 32) + (ulong)data[num7 - 1];
|
|
ulong num11 = num10 / (ulong)num8;
|
|
ulong num12 = num10 % (ulong)num8;
|
|
while (num11 == 4294967296UL || num11 * num9 > (num12 << 32) + (ulong)data[num7 - 2])
|
|
{
|
|
num11 -= 1UL;
|
|
num12 += (ulong)num8;
|
|
if (num12 >= 4294967296UL)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
uint num13 = 0U;
|
|
int num14 = num7 - num2 + 1;
|
|
ulong num15 = 0UL;
|
|
uint num16 = (uint)num11;
|
|
do
|
|
{
|
|
num15 += (ulong)bi2.data[(int)((UIntPtr)num13)] * (ulong)num16;
|
|
uint num17 = data[num14];
|
|
data[num14] -= (uint)num15;
|
|
num15 >>= 32;
|
|
if (data[num14] > num17)
|
|
{
|
|
num15 += 1UL;
|
|
}
|
|
num13 += 1U;
|
|
num14++;
|
|
}
|
|
while ((ulong)num13 < (ulong)((long)num2));
|
|
num14 = num7 - num2 + 1;
|
|
num13 = 0U;
|
|
if (num15 != 0UL)
|
|
{
|
|
num16 -= 1U;
|
|
ulong num18 = 0UL;
|
|
do
|
|
{
|
|
num18 = (ulong)data[num14] + (ulong)bi2.data[(int)((UIntPtr)num13)] + num18;
|
|
data[num14] = (uint)num18;
|
|
num18 >>= 32;
|
|
num13 += 1U;
|
|
num14++;
|
|
}
|
|
while ((ulong)num13 < (ulong)((long)num2));
|
|
}
|
|
bigInteger.data[num6--] = num16;
|
|
num7--;
|
|
i--;
|
|
}
|
|
bigInteger.Normalize();
|
|
bigInteger2.Normalize();
|
|
BigInteger[] array = new BigInteger[] { bigInteger, bigInteger2 };
|
|
if (num5 != 0)
|
|
{
|
|
BigInteger[] array2 = array;
|
|
int num19 = 1;
|
|
array2[num19] >>= num5;
|
|
}
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x0600005E RID: 94 RVA: 0x00003EC4 File Offset: 0x000020C4
|
|
public static BigInteger LeftShift(BigInteger bi, int n)
|
|
{
|
|
if (n == 0)
|
|
{
|
|
return new BigInteger(bi, bi.length + 1U);
|
|
}
|
|
int num = n >> 5;
|
|
n &= 31;
|
|
BigInteger bigInteger = new BigInteger(BigInteger.Sign.Positive, bi.length + 1U + (uint)num);
|
|
uint num2 = 0U;
|
|
uint length = bi.length;
|
|
if (n != 0)
|
|
{
|
|
uint num3 = 0U;
|
|
while (num2 < length)
|
|
{
|
|
uint num4 = bi.data[(int)((UIntPtr)num2)];
|
|
checked
|
|
{
|
|
bigInteger.data[(int)((IntPtr)(unchecked((ulong)num2 + (ulong)((long)num))))] = (num4 << n) | num3;
|
|
}
|
|
num3 = num4 >> 32 - n;
|
|
num2 += 1U;
|
|
}
|
|
checked
|
|
{
|
|
bigInteger.data[(int)((IntPtr)(unchecked((ulong)num2 + (ulong)((long)num))))] = num3;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while (num2 < length)
|
|
{
|
|
bigInteger.data[(int)(checked((IntPtr)(unchecked((ulong)num2 + (ulong)((long)num)))))] = bi.data[(int)((UIntPtr)num2)];
|
|
num2 += 1U;
|
|
}
|
|
}
|
|
bigInteger.Normalize();
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x0600005F RID: 95 RVA: 0x00003F94 File Offset: 0x00002194
|
|
public static BigInteger RightShift(BigInteger bi, int n)
|
|
{
|
|
if (n == 0)
|
|
{
|
|
return new BigInteger(bi);
|
|
}
|
|
int num = n >> 5;
|
|
int num2 = n & 31;
|
|
BigInteger bigInteger = new BigInteger(BigInteger.Sign.Positive, bi.length - (uint)num + 1U);
|
|
uint num3 = (uint)(bigInteger.data.Length - 1);
|
|
if (num2 != 0)
|
|
{
|
|
uint num4 = 0U;
|
|
while (num3-- > 0U)
|
|
{
|
|
uint num5;
|
|
checked
|
|
{
|
|
num5 = bi.data[(int)((IntPtr)(unchecked((ulong)num3 + (ulong)((long)num))))];
|
|
}
|
|
bigInteger.data[(int)((UIntPtr)num3)] = (num5 >> n) | num4;
|
|
num4 = num5 << 32 - n;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while (num3-- > 0U)
|
|
{
|
|
bigInteger.data[(int)((UIntPtr)num3)] = bi.data[(int)(checked((IntPtr)(unchecked((ulong)num3 + (ulong)((long)num)))))];
|
|
}
|
|
}
|
|
bigInteger.Normalize();
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x06000060 RID: 96 RVA: 0x0000404C File Offset: 0x0000224C
|
|
public static BigInteger MultiplyByDword(BigInteger n, uint f)
|
|
{
|
|
BigInteger bigInteger = new BigInteger(BigInteger.Sign.Positive, n.length + 1U);
|
|
uint num = 0U;
|
|
ulong num2 = 0UL;
|
|
do
|
|
{
|
|
num2 += (ulong)n.data[(int)((UIntPtr)num)] * (ulong)f;
|
|
bigInteger.data[(int)((UIntPtr)num)] = (uint)num2;
|
|
num2 >>= 32;
|
|
}
|
|
while ((num += 1U) < n.length);
|
|
bigInteger.data[(int)((UIntPtr)num)] = (uint)num2;
|
|
bigInteger.Normalize();
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x06000061 RID: 97 RVA: 0x000040B0 File Offset: 0x000022B0
|
|
public unsafe static void Multiply(uint[] x, uint xOffset, uint xLen, uint[] y, uint yOffset, uint yLen, uint[] d, uint dOffset)
|
|
{
|
|
fixed (uint* ptr = (ref x != null && x.Length != 0 ? ref x[0] : ref *null), ptr2 = (ref y != null && y.Length != 0 ? ref y[0] : ref *null), ptr3 = (ref d != null && d.Length != 0 ? ref d[0] : ref *null))
|
|
{
|
|
uint* ptr4 = ptr + xOffset;
|
|
uint* ptr5 = ptr4 + xLen;
|
|
uint* ptr6 = ptr2 + yOffset;
|
|
uint* ptr7 = ptr6 + yLen;
|
|
uint* ptr8 = ptr3 + dOffset;
|
|
while (ptr4 < ptr5)
|
|
{
|
|
if (*ptr4 != 0U)
|
|
{
|
|
ulong num = 0UL;
|
|
uint* ptr9 = ptr8;
|
|
uint* ptr10 = ptr6;
|
|
while (ptr10 < ptr7)
|
|
{
|
|
num += (ulong)(*ptr4) * (ulong)(*ptr10) + (ulong)(*ptr9);
|
|
*ptr9 = (uint)num;
|
|
num >>= 32;
|
|
ptr10++;
|
|
ptr9++;
|
|
}
|
|
if (num != 0UL)
|
|
{
|
|
*ptr9 = (uint)num;
|
|
}
|
|
}
|
|
ptr4++;
|
|
ptr8++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000062 RID: 98 RVA: 0x000041C4 File Offset: 0x000023C4
|
|
public unsafe static void MultiplyMod2p32pmod(uint[] x, int xOffset, int xLen, uint[] y, int yOffest, int yLen, uint[] d, int dOffset, int mod)
|
|
{
|
|
fixed (uint* ptr = (ref x != null && x.Length != 0 ? ref x[0] : ref *null), ptr2 = (ref y != null && y.Length != 0 ? ref y[0] : ref *null), ptr3 = (ref d != null && d.Length != 0 ? ref d[0] : ref *null))
|
|
{
|
|
uint* ptr4 = ptr + xOffset;
|
|
uint* ptr5 = ptr4 + xLen;
|
|
uint* ptr6 = ptr2 + yOffest;
|
|
uint* ptr7 = ptr6 + yLen;
|
|
uint* ptr8 = ptr3 + dOffset;
|
|
uint* ptr9 = ptr8 + mod;
|
|
while (ptr4 < ptr5)
|
|
{
|
|
if (*ptr4 != 0U)
|
|
{
|
|
ulong num = 0UL;
|
|
uint* ptr10 = ptr8;
|
|
uint* ptr11 = ptr6;
|
|
while (ptr11 < ptr7 && ptr10 < ptr9)
|
|
{
|
|
num += (ulong)(*ptr4) * (ulong)(*ptr11) + (ulong)(*ptr10);
|
|
*ptr10 = (uint)num;
|
|
num >>= 32;
|
|
ptr11++;
|
|
ptr10++;
|
|
}
|
|
if (num != 0UL && ptr10 < ptr9)
|
|
{
|
|
*ptr10 = (uint)num;
|
|
}
|
|
}
|
|
ptr4++;
|
|
ptr8++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000063 RID: 99 RVA: 0x000042F0 File Offset: 0x000024F0
|
|
public unsafe static void SquarePositive(BigInteger bi, ref uint[] wkSpace)
|
|
{
|
|
uint[] array = wkSpace;
|
|
wkSpace = bi.data;
|
|
uint[] data = bi.data;
|
|
uint length = bi.length;
|
|
bi.data = array;
|
|
fixed (uint* ptr = (ref data != null && data.Length != 0 ? ref data[0] : ref *null), ptr2 = (ref array != null && array.Length != 0 ? ref array[0] : ref *null))
|
|
{
|
|
uint* ptr3 = ptr2 + array.Length;
|
|
for (uint* ptr4 = ptr2; ptr4 < ptr3; ptr4++)
|
|
{
|
|
*ptr4 = 0U;
|
|
}
|
|
uint* ptr5 = ptr;
|
|
uint* ptr6 = ptr2;
|
|
uint num = 0U;
|
|
while (num < length)
|
|
{
|
|
if (*ptr5 != 0U)
|
|
{
|
|
ulong num2 = 0UL;
|
|
uint num3 = *ptr5;
|
|
uint* ptr7 = ptr5 + 1;
|
|
uint* ptr8 = ptr6 + 2U * num + 1;
|
|
uint num4 = num + 1U;
|
|
while (num4 < length)
|
|
{
|
|
num2 += (ulong)num3 * (ulong)(*ptr7) + (ulong)(*ptr8);
|
|
*ptr8 = (uint)num2;
|
|
num2 >>= 32;
|
|
num4 += 1U;
|
|
ptr8++;
|
|
ptr7++;
|
|
}
|
|
if (num2 != 0UL)
|
|
{
|
|
*ptr8 = (uint)num2;
|
|
}
|
|
}
|
|
num += 1U;
|
|
ptr5++;
|
|
}
|
|
ptr6 = ptr2;
|
|
uint num5 = 0U;
|
|
while (ptr6 < ptr3)
|
|
{
|
|
uint num6 = *ptr6;
|
|
*ptr6 = (num6 << 1) | num5;
|
|
num5 = num6 >> 31;
|
|
ptr6++;
|
|
}
|
|
if (num5 != 0U)
|
|
{
|
|
*ptr6 = num5;
|
|
}
|
|
ptr5 = ptr;
|
|
ptr6 = ptr2;
|
|
uint* ptr9 = ptr5 + length;
|
|
while (ptr5 < ptr9)
|
|
{
|
|
ulong num7 = (ulong)(*ptr5) * (ulong)(*ptr5) + (ulong)(*ptr6);
|
|
*ptr6 = (uint)num7;
|
|
num7 >>= 32;
|
|
*(++ptr6) += (uint)num7;
|
|
if (*ptr6 < (uint)num7)
|
|
{
|
|
uint* ptr10 = ptr6;
|
|
*(++ptr10) += 1U;
|
|
while (*(ptr10++) == 0U)
|
|
{
|
|
*ptr10 += 1U;
|
|
}
|
|
}
|
|
ptr5++;
|
|
ptr6++;
|
|
}
|
|
bi.length <<= 1;
|
|
while (ptr2[bi.length - 1U] == 0U && bi.length > 1U)
|
|
{
|
|
bi.length -= 1U;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000064 RID: 100 RVA: 0x00004534 File Offset: 0x00002734
|
|
public static BigInteger gcd(BigInteger a, BigInteger b)
|
|
{
|
|
BigInteger bigInteger = a;
|
|
BigInteger bigInteger2 = b;
|
|
BigInteger bigInteger3 = bigInteger2;
|
|
while (bigInteger.length > 1U)
|
|
{
|
|
bigInteger3 = bigInteger;
|
|
bigInteger = bigInteger2 % bigInteger;
|
|
bigInteger2 = bigInteger3;
|
|
}
|
|
if (bigInteger == 0U)
|
|
{
|
|
return bigInteger3;
|
|
}
|
|
uint num = bigInteger.data[0];
|
|
uint num2 = bigInteger2 % num;
|
|
int num3 = 0;
|
|
while (((num2 | num) & 1U) == 0U)
|
|
{
|
|
num2 >>= 1;
|
|
num >>= 1;
|
|
num3++;
|
|
}
|
|
while (num2 != 0U)
|
|
{
|
|
while ((num2 & 1U) == 0U)
|
|
{
|
|
num2 >>= 1;
|
|
}
|
|
while ((num & 1U) == 0U)
|
|
{
|
|
num >>= 1;
|
|
}
|
|
if (num2 >= num)
|
|
{
|
|
num2 = num2 - num >> 1;
|
|
}
|
|
else
|
|
{
|
|
num = num - num2 >> 1;
|
|
}
|
|
}
|
|
return num << num3;
|
|
}
|
|
|
|
// Token: 0x06000065 RID: 101 RVA: 0x00004600 File Offset: 0x00002800
|
|
public static uint modInverse(BigInteger bi, uint modulus)
|
|
{
|
|
uint num = modulus;
|
|
uint num2 = bi % modulus;
|
|
uint num3 = 0U;
|
|
uint num4 = 1U;
|
|
while (num2 != 0U)
|
|
{
|
|
if (num2 == 1U)
|
|
{
|
|
return num4;
|
|
}
|
|
num3 += num / num2 * num4;
|
|
num %= num2;
|
|
if (num == 0U)
|
|
{
|
|
break;
|
|
}
|
|
if (num == 1U)
|
|
{
|
|
return modulus - num3;
|
|
}
|
|
num4 += num2 / num * num3;
|
|
num2 %= num;
|
|
}
|
|
return 0U;
|
|
}
|
|
|
|
// Token: 0x06000066 RID: 102 RVA: 0x00004660 File Offset: 0x00002860
|
|
public static BigInteger modInverse(BigInteger bi, BigInteger modulus)
|
|
{
|
|
if (modulus.length == 1U)
|
|
{
|
|
return BigInteger.Kernel.modInverse(bi, modulus.data[0]);
|
|
}
|
|
BigInteger[] array = new BigInteger[] { 0, 1 };
|
|
BigInteger[] array2 = new BigInteger[2];
|
|
BigInteger[] array3 = new BigInteger[] { 0, 0 };
|
|
int num = 0;
|
|
BigInteger bigInteger = modulus;
|
|
BigInteger bigInteger2 = bi;
|
|
BigInteger.ModulusRing modulusRing = new BigInteger.ModulusRing(modulus);
|
|
while (bigInteger2 != 0U)
|
|
{
|
|
if (num > 1)
|
|
{
|
|
BigInteger bigInteger3 = modulusRing.Difference(array[0], array[1] * array2[0]);
|
|
array[0] = array[1];
|
|
array[1] = bigInteger3;
|
|
}
|
|
BigInteger[] array4 = BigInteger.Kernel.multiByteDivide(bigInteger, bigInteger2);
|
|
array2[0] = array2[1];
|
|
array2[1] = array4[0];
|
|
array3[0] = array3[1];
|
|
array3[1] = array4[1];
|
|
bigInteger = bigInteger2;
|
|
bigInteger2 = array4[1];
|
|
num++;
|
|
}
|
|
if (array3[0] != 1U)
|
|
{
|
|
throw new ArithmeticException("No inverse!");
|
|
}
|
|
return modulusRing.Difference(array[0], array[1] * array2[0]);
|
|
}
|
|
}
|
|
}
|
|
}
|