1233 lines
24 KiB
C#
1233 lines
24 KiB
C#
using System;
|
|
using Org.BouncyCastle.Crypto.Utilities;
|
|
|
|
namespace Org.BouncyCastle.Math.Raw;
|
|
|
|
internal abstract class Nat
|
|
{
|
|
private const ulong M = 4294967295uL;
|
|
|
|
public static uint Add(int len, uint[] x, uint[] y, uint[] z)
|
|
{
|
|
ulong num = 0uL;
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
num += (ulong)((long)x[i] + (long)y[i]);
|
|
z[i] = (uint)num;
|
|
num >>= 32;
|
|
}
|
|
return (uint)num;
|
|
}
|
|
|
|
public static uint Add33At(int len, uint x, uint[] z, int zPos)
|
|
{
|
|
ulong num = (ulong)z[zPos] + (ulong)x;
|
|
z[zPos] = (uint)num;
|
|
num >>= 32;
|
|
num += (ulong)((long)z[zPos + 1] + 1L);
|
|
z[zPos + 1] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return IncAt(len, z, zPos + 2);
|
|
}
|
|
return 0u;
|
|
}
|
|
|
|
public static uint Add33At(int len, uint x, uint[] z, int zOff, int zPos)
|
|
{
|
|
ulong num = (ulong)z[zOff + zPos] + (ulong)x;
|
|
z[zOff + zPos] = (uint)num;
|
|
num >>= 32;
|
|
num += (ulong)((long)z[zOff + zPos + 1] + 1L);
|
|
z[zOff + zPos + 1] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return IncAt(len, z, zOff, zPos + 2);
|
|
}
|
|
return 0u;
|
|
}
|
|
|
|
public static uint Add33To(int len, uint x, uint[] z)
|
|
{
|
|
ulong num = (ulong)z[0] + (ulong)x;
|
|
z[0] = (uint)num;
|
|
num >>= 32;
|
|
num += (ulong)((long)z[1] + 1L);
|
|
z[1] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return IncAt(len, z, 2);
|
|
}
|
|
return 0u;
|
|
}
|
|
|
|
public static uint Add33To(int len, uint x, uint[] z, int zOff)
|
|
{
|
|
ulong num = (ulong)z[zOff] + (ulong)x;
|
|
z[zOff] = (uint)num;
|
|
num >>= 32;
|
|
num += (ulong)((long)z[zOff + 1] + 1L);
|
|
z[zOff + 1] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return IncAt(len, z, zOff, 2);
|
|
}
|
|
return 0u;
|
|
}
|
|
|
|
public static uint AddBothTo(int len, uint[] x, uint[] y, uint[] z)
|
|
{
|
|
ulong num = 0uL;
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
num += (ulong)((long)x[i] + (long)y[i] + z[i]);
|
|
z[i] = (uint)num;
|
|
num >>= 32;
|
|
}
|
|
return (uint)num;
|
|
}
|
|
|
|
public static uint AddBothTo(int len, uint[] x, int xOff, uint[] y, int yOff, uint[] z, int zOff)
|
|
{
|
|
ulong num = 0uL;
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
num += (ulong)((long)x[xOff + i] + (long)y[yOff + i] + z[zOff + i]);
|
|
z[zOff + i] = (uint)num;
|
|
num >>= 32;
|
|
}
|
|
return (uint)num;
|
|
}
|
|
|
|
public static uint AddDWordAt(int len, ulong x, uint[] z, int zPos)
|
|
{
|
|
ulong num = z[zPos] + (x & 0xFFFFFFFFu);
|
|
z[zPos] = (uint)num;
|
|
num >>= 32;
|
|
num += z[zPos + 1] + (x >> 32);
|
|
z[zPos + 1] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return IncAt(len, z, zPos + 2);
|
|
}
|
|
return 0u;
|
|
}
|
|
|
|
public static uint AddDWordAt(int len, ulong x, uint[] z, int zOff, int zPos)
|
|
{
|
|
ulong num = z[zOff + zPos] + (x & 0xFFFFFFFFu);
|
|
z[zOff + zPos] = (uint)num;
|
|
num >>= 32;
|
|
num += z[zOff + zPos + 1] + (x >> 32);
|
|
z[zOff + zPos + 1] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return IncAt(len, z, zOff, zPos + 2);
|
|
}
|
|
return 0u;
|
|
}
|
|
|
|
public static uint AddDWordTo(int len, ulong x, uint[] z)
|
|
{
|
|
ulong num = z[0] + (x & 0xFFFFFFFFu);
|
|
z[0] = (uint)num;
|
|
num >>= 32;
|
|
num += z[1] + (x >> 32);
|
|
z[1] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return IncAt(len, z, 2);
|
|
}
|
|
return 0u;
|
|
}
|
|
|
|
public static uint AddDWordTo(int len, ulong x, uint[] z, int zOff)
|
|
{
|
|
ulong num = z[zOff] + (x & 0xFFFFFFFFu);
|
|
z[zOff] = (uint)num;
|
|
num >>= 32;
|
|
num += z[zOff + 1] + (x >> 32);
|
|
z[zOff + 1] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return IncAt(len, z, zOff, 2);
|
|
}
|
|
return 0u;
|
|
}
|
|
|
|
public static uint AddTo(int len, uint[] x, uint[] z)
|
|
{
|
|
ulong num = 0uL;
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
num += (ulong)((long)x[i] + (long)z[i]);
|
|
z[i] = (uint)num;
|
|
num >>= 32;
|
|
}
|
|
return (uint)num;
|
|
}
|
|
|
|
public static uint AddTo(int len, uint[] x, int xOff, uint[] z, int zOff)
|
|
{
|
|
ulong num = 0uL;
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
num += (ulong)((long)x[xOff + i] + (long)z[zOff + i]);
|
|
z[zOff + i] = (uint)num;
|
|
num >>= 32;
|
|
}
|
|
return (uint)num;
|
|
}
|
|
|
|
public static uint AddWordAt(int len, uint x, uint[] z, int zPos)
|
|
{
|
|
ulong num = (ulong)x + (ulong)z[zPos];
|
|
z[zPos] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return IncAt(len, z, zPos + 1);
|
|
}
|
|
return 0u;
|
|
}
|
|
|
|
public static uint AddWordAt(int len, uint x, uint[] z, int zOff, int zPos)
|
|
{
|
|
ulong num = (ulong)x + (ulong)z[zOff + zPos];
|
|
z[zOff + zPos] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return IncAt(len, z, zOff, zPos + 1);
|
|
}
|
|
return 0u;
|
|
}
|
|
|
|
public static uint AddWordTo(int len, uint x, uint[] z)
|
|
{
|
|
ulong num = (ulong)x + (ulong)z[0];
|
|
z[0] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return IncAt(len, z, 1);
|
|
}
|
|
return 0u;
|
|
}
|
|
|
|
public static uint AddWordTo(int len, uint x, uint[] z, int zOff)
|
|
{
|
|
ulong num = (ulong)x + (ulong)z[zOff];
|
|
z[zOff] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return IncAt(len, z, zOff, 1);
|
|
}
|
|
return 0u;
|
|
}
|
|
|
|
public static uint CAdd(int len, int mask, uint[] x, uint[] y, uint[] z)
|
|
{
|
|
uint num = (uint)(-(mask & 1));
|
|
ulong num2 = 0uL;
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
num2 += (ulong)((long)x[i] + (long)(y[i] & num));
|
|
z[i] = (uint)num2;
|
|
num2 >>= 32;
|
|
}
|
|
return (uint)num2;
|
|
}
|
|
|
|
public static void CMov(int len, int mask, uint[] x, int xOff, uint[] z, int zOff)
|
|
{
|
|
uint num = (uint)(-(mask & 1));
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
uint num2 = z[zOff + i];
|
|
uint num3 = num2 ^ x[xOff + i];
|
|
num2 ^= num3 & num;
|
|
z[zOff + i] = num2;
|
|
}
|
|
}
|
|
|
|
public static void CMov(int len, int mask, int[] x, int xOff, int[] z, int zOff)
|
|
{
|
|
mask = -(mask & 1);
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
int num = z[zOff + i];
|
|
int num2 = num ^ x[xOff + i];
|
|
num ^= num2 & mask;
|
|
z[zOff + i] = num;
|
|
}
|
|
}
|
|
|
|
public static void Copy(int len, uint[] x, uint[] z)
|
|
{
|
|
Array.Copy(x, 0, z, 0, len);
|
|
}
|
|
|
|
public static uint[] Copy(int len, uint[] x)
|
|
{
|
|
uint[] array = new uint[len];
|
|
Array.Copy(x, 0, array, 0, len);
|
|
return array;
|
|
}
|
|
|
|
public static void Copy(int len, uint[] x, int xOff, uint[] z, int zOff)
|
|
{
|
|
Array.Copy(x, xOff, z, zOff, len);
|
|
}
|
|
|
|
public static uint[] Create(int len)
|
|
{
|
|
return new uint[len];
|
|
}
|
|
|
|
public static ulong[] Create64(int len)
|
|
{
|
|
return new ulong[len];
|
|
}
|
|
|
|
public static int Dec(int len, uint[] z)
|
|
{
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
uint[] array2;
|
|
uint[] array = (array2 = z);
|
|
int num = i;
|
|
nint num2 = num;
|
|
if ((array[num] = array2[num2] - 1) != uint.MaxValue)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public static int Dec(int len, uint[] x, uint[] z)
|
|
{
|
|
int i = 0;
|
|
while (i < len)
|
|
{
|
|
uint num = (z[i] = x[i] - 1);
|
|
i++;
|
|
if (num != uint.MaxValue)
|
|
{
|
|
for (; i < len; i++)
|
|
{
|
|
z[i] = x[i];
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public static int DecAt(int len, uint[] z, int zPos)
|
|
{
|
|
for (int i = zPos; i < len; i++)
|
|
{
|
|
uint[] array2;
|
|
uint[] array = (array2 = z);
|
|
int num = i;
|
|
nint num2 = num;
|
|
if ((array[num] = array2[num2] - 1) != uint.MaxValue)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public static int DecAt(int len, uint[] z, int zOff, int zPos)
|
|
{
|
|
for (int i = zPos; i < len; i++)
|
|
{
|
|
uint[] array2;
|
|
uint[] array = (array2 = z);
|
|
int num = zOff + i;
|
|
nint num2 = num;
|
|
if ((array[num] = array2[num2] - 1) != uint.MaxValue)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public static bool Eq(int len, uint[] x, uint[] y)
|
|
{
|
|
for (int num = len - 1; num >= 0; num--)
|
|
{
|
|
if (x[num] != y[num])
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static uint[] FromBigInteger(int bits, BigInteger x)
|
|
{
|
|
if (x.SignValue < 0 || x.BitLength > bits)
|
|
{
|
|
throw new ArgumentException();
|
|
}
|
|
int len = bits + 31 >> 5;
|
|
uint[] array = Create(len);
|
|
int num = 0;
|
|
while (x.SignValue != 0)
|
|
{
|
|
array[num++] = (uint)x.IntValue;
|
|
x = x.ShiftRight(32);
|
|
}
|
|
return array;
|
|
}
|
|
|
|
public static uint GetBit(uint[] x, int bit)
|
|
{
|
|
if (bit == 0)
|
|
{
|
|
return x[0] & 1;
|
|
}
|
|
int num = bit >> 5;
|
|
if (num < 0 || num >= x.Length)
|
|
{
|
|
return 0u;
|
|
}
|
|
int num2 = bit & 0x1F;
|
|
return (x[num] >> num2) & 1;
|
|
}
|
|
|
|
public static bool Gte(int len, uint[] x, uint[] y)
|
|
{
|
|
for (int num = len - 1; num >= 0; num--)
|
|
{
|
|
uint num2 = x[num];
|
|
uint num3 = y[num];
|
|
if (num2 < num3)
|
|
{
|
|
return false;
|
|
}
|
|
if (num2 > num3)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static uint Inc(int len, uint[] z)
|
|
{
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
uint[] array2;
|
|
uint[] array = (array2 = z);
|
|
int num = i;
|
|
nint num2 = num;
|
|
if ((array[num] = array2[num2] + 1) != 0)
|
|
{
|
|
return 0u;
|
|
}
|
|
}
|
|
return 1u;
|
|
}
|
|
|
|
public static uint Inc(int len, uint[] x, uint[] z)
|
|
{
|
|
int i = 0;
|
|
while (i < len)
|
|
{
|
|
uint num = (z[i] = x[i] + 1);
|
|
i++;
|
|
if (num != 0)
|
|
{
|
|
for (; i < len; i++)
|
|
{
|
|
z[i] = x[i];
|
|
}
|
|
return 0u;
|
|
}
|
|
}
|
|
return 1u;
|
|
}
|
|
|
|
public static uint IncAt(int len, uint[] z, int zPos)
|
|
{
|
|
for (int i = zPos; i < len; i++)
|
|
{
|
|
uint[] array2;
|
|
uint[] array = (array2 = z);
|
|
int num = i;
|
|
nint num2 = num;
|
|
if ((array[num] = array2[num2] + 1) != 0)
|
|
{
|
|
return 0u;
|
|
}
|
|
}
|
|
return 1u;
|
|
}
|
|
|
|
public static uint IncAt(int len, uint[] z, int zOff, int zPos)
|
|
{
|
|
for (int i = zPos; i < len; i++)
|
|
{
|
|
uint[] array2;
|
|
uint[] array = (array2 = z);
|
|
int num = zOff + i;
|
|
nint num2 = num;
|
|
if ((array[num] = array2[num2] + 1) != 0)
|
|
{
|
|
return 0u;
|
|
}
|
|
}
|
|
return 1u;
|
|
}
|
|
|
|
public static bool IsOne(int len, uint[] x)
|
|
{
|
|
if (x[0] != 1)
|
|
{
|
|
return false;
|
|
}
|
|
for (int i = 1; i < len; i++)
|
|
{
|
|
if (x[i] != 0)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static bool IsZero(int len, uint[] x)
|
|
{
|
|
if (x[0] != 0)
|
|
{
|
|
return false;
|
|
}
|
|
for (int i = 1; i < len; i++)
|
|
{
|
|
if (x[i] != 0)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static void Mul(int len, uint[] x, uint[] y, uint[] zz)
|
|
{
|
|
zz[len] = MulWord(len, x[0], y, zz);
|
|
for (int i = 1; i < len; i++)
|
|
{
|
|
zz[i + len] = MulWordAddTo(len, x[i], y, 0, zz, i);
|
|
}
|
|
}
|
|
|
|
public static void Mul(int len, uint[] x, int xOff, uint[] y, int yOff, uint[] zz, int zzOff)
|
|
{
|
|
zz[zzOff + len] = MulWord(len, x[xOff], y, yOff, zz, zzOff);
|
|
for (int i = 1; i < len; i++)
|
|
{
|
|
zz[zzOff + i + len] = MulWordAddTo(len, x[xOff + i], y, yOff, zz, zzOff + i);
|
|
}
|
|
}
|
|
|
|
public static void Mul(uint[] x, int xOff, int xLen, uint[] y, int yOff, int yLen, uint[] zz, int zzOff)
|
|
{
|
|
zz[zzOff + yLen] = MulWord(yLen, x[xOff], y, yOff, zz, zzOff);
|
|
for (int i = 1; i < xLen; i++)
|
|
{
|
|
zz[zzOff + i + yLen] = MulWordAddTo(yLen, x[xOff + i], y, yOff, zz, zzOff + i);
|
|
}
|
|
}
|
|
|
|
public static uint MulAddTo(int len, uint[] x, uint[] y, uint[] zz)
|
|
{
|
|
ulong num = 0uL;
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
ulong num2 = (ulong)MulWordAddTo(len, x[i], y, 0, zz, i) & 0xFFFFFFFFuL;
|
|
num2 += num + ((ulong)zz[i + len] & 0xFFFFFFFFuL);
|
|
zz[i + len] = (uint)num2;
|
|
num = num2 >> 32;
|
|
}
|
|
return (uint)num;
|
|
}
|
|
|
|
public static uint MulAddTo(int len, uint[] x, int xOff, uint[] y, int yOff, uint[] zz, int zzOff)
|
|
{
|
|
ulong num = 0uL;
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
ulong num2 = (ulong)MulWordAddTo(len, x[xOff + i], y, yOff, zz, zzOff) & 0xFFFFFFFFuL;
|
|
num2 += num + ((ulong)zz[zzOff + len] & 0xFFFFFFFFuL);
|
|
zz[zzOff + len] = (uint)num2;
|
|
num = num2 >> 32;
|
|
zzOff++;
|
|
}
|
|
return (uint)num;
|
|
}
|
|
|
|
public static uint Mul31BothAdd(int len, uint a, uint[] x, uint b, uint[] y, uint[] z, int zOff)
|
|
{
|
|
ulong num = 0uL;
|
|
ulong num2 = a;
|
|
ulong num3 = b;
|
|
int num4 = 0;
|
|
do
|
|
{
|
|
num += num2 * x[num4] + num3 * y[num4] + z[zOff + num4];
|
|
z[zOff + num4] = (uint)num;
|
|
num >>= 32;
|
|
}
|
|
while (++num4 < len);
|
|
return (uint)num;
|
|
}
|
|
|
|
public static uint MulWord(int len, uint x, uint[] y, uint[] z)
|
|
{
|
|
ulong num = 0uL;
|
|
ulong num2 = x;
|
|
int num3 = 0;
|
|
do
|
|
{
|
|
num += num2 * y[num3];
|
|
z[num3] = (uint)num;
|
|
num >>= 32;
|
|
}
|
|
while (++num3 < len);
|
|
return (uint)num;
|
|
}
|
|
|
|
public static uint MulWord(int len, uint x, uint[] y, int yOff, uint[] z, int zOff)
|
|
{
|
|
ulong num = 0uL;
|
|
ulong num2 = x;
|
|
int num3 = 0;
|
|
do
|
|
{
|
|
num += num2 * y[yOff + num3];
|
|
z[zOff + num3] = (uint)num;
|
|
num >>= 32;
|
|
}
|
|
while (++num3 < len);
|
|
return (uint)num;
|
|
}
|
|
|
|
public static uint MulWordAddTo(int len, uint x, uint[] y, int yOff, uint[] z, int zOff)
|
|
{
|
|
ulong num = 0uL;
|
|
ulong num2 = x;
|
|
int num3 = 0;
|
|
do
|
|
{
|
|
num += num2 * y[yOff + num3] + z[zOff + num3];
|
|
z[zOff + num3] = (uint)num;
|
|
num >>= 32;
|
|
}
|
|
while (++num3 < len);
|
|
return (uint)num;
|
|
}
|
|
|
|
public static uint MulWordDwordAddAt(int len, uint x, ulong y, uint[] z, int zPos)
|
|
{
|
|
ulong num = 0uL;
|
|
ulong num2 = x;
|
|
num += num2 * (uint)y + z[zPos];
|
|
z[zPos] = (uint)num;
|
|
num >>= 32;
|
|
num += num2 * (y >> 32) + z[zPos + 1];
|
|
z[zPos + 1] = (uint)num;
|
|
num >>= 32;
|
|
num += z[zPos + 2];
|
|
z[zPos + 2] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return IncAt(len, z, zPos + 3);
|
|
}
|
|
return 0u;
|
|
}
|
|
|
|
public static uint ShiftDownBit(int len, uint[] z, uint c)
|
|
{
|
|
int num = len;
|
|
while (--num >= 0)
|
|
{
|
|
uint num2 = z[num];
|
|
z[num] = (num2 >> 1) | (c << 31);
|
|
c = num2;
|
|
}
|
|
return c << 31;
|
|
}
|
|
|
|
public static uint ShiftDownBit(int len, uint[] z, int zOff, uint c)
|
|
{
|
|
int num = len;
|
|
while (--num >= 0)
|
|
{
|
|
uint num2 = z[zOff + num];
|
|
z[zOff + num] = (num2 >> 1) | (c << 31);
|
|
c = num2;
|
|
}
|
|
return c << 31;
|
|
}
|
|
|
|
public static uint ShiftDownBit(int len, uint[] x, uint c, uint[] z)
|
|
{
|
|
int num = len;
|
|
while (--num >= 0)
|
|
{
|
|
uint num2 = x[num];
|
|
z[num] = (num2 >> 1) | (c << 31);
|
|
c = num2;
|
|
}
|
|
return c << 31;
|
|
}
|
|
|
|
public static uint ShiftDownBit(int len, uint[] x, int xOff, uint c, uint[] z, int zOff)
|
|
{
|
|
int num = len;
|
|
while (--num >= 0)
|
|
{
|
|
uint num2 = x[xOff + num];
|
|
z[zOff + num] = (num2 >> 1) | (c << 31);
|
|
c = num2;
|
|
}
|
|
return c << 31;
|
|
}
|
|
|
|
public static uint ShiftDownBits(int len, uint[] z, int bits, uint c)
|
|
{
|
|
int num = len;
|
|
while (--num >= 0)
|
|
{
|
|
uint num2 = z[num];
|
|
z[num] = (num2 >> bits) | (c << -bits);
|
|
c = num2;
|
|
}
|
|
return c << -bits;
|
|
}
|
|
|
|
public static uint ShiftDownBits(int len, uint[] z, int zOff, int bits, uint c)
|
|
{
|
|
int num = len;
|
|
while (--num >= 0)
|
|
{
|
|
uint num2 = z[zOff + num];
|
|
z[zOff + num] = (num2 >> bits) | (c << -bits);
|
|
c = num2;
|
|
}
|
|
return c << -bits;
|
|
}
|
|
|
|
public static uint ShiftDownBits(int len, uint[] x, int bits, uint c, uint[] z)
|
|
{
|
|
int num = len;
|
|
while (--num >= 0)
|
|
{
|
|
uint num2 = x[num];
|
|
z[num] = (num2 >> bits) | (c << -bits);
|
|
c = num2;
|
|
}
|
|
return c << -bits;
|
|
}
|
|
|
|
public static uint ShiftDownBits(int len, uint[] x, int xOff, int bits, uint c, uint[] z, int zOff)
|
|
{
|
|
int num = len;
|
|
while (--num >= 0)
|
|
{
|
|
uint num2 = x[xOff + num];
|
|
z[zOff + num] = (num2 >> bits) | (c << -bits);
|
|
c = num2;
|
|
}
|
|
return c << -bits;
|
|
}
|
|
|
|
public static uint ShiftDownWord(int len, uint[] z, uint c)
|
|
{
|
|
int num = len;
|
|
while (--num >= 0)
|
|
{
|
|
uint num2 = z[num];
|
|
z[num] = c;
|
|
c = num2;
|
|
}
|
|
return c;
|
|
}
|
|
|
|
public static uint ShiftUpBit(int len, uint[] z, uint c)
|
|
{
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
uint num = z[i];
|
|
z[i] = (num << 1) | (c >> 31);
|
|
c = num;
|
|
}
|
|
return c >> 31;
|
|
}
|
|
|
|
public static uint ShiftUpBit(int len, uint[] z, int zOff, uint c)
|
|
{
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
uint num = z[zOff + i];
|
|
z[zOff + i] = (num << 1) | (c >> 31);
|
|
c = num;
|
|
}
|
|
return c >> 31;
|
|
}
|
|
|
|
public static uint ShiftUpBit(int len, uint[] x, uint c, uint[] z)
|
|
{
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
uint num = x[i];
|
|
z[i] = (num << 1) | (c >> 31);
|
|
c = num;
|
|
}
|
|
return c >> 31;
|
|
}
|
|
|
|
public static uint ShiftUpBit(int len, uint[] x, int xOff, uint c, uint[] z, int zOff)
|
|
{
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
uint num = x[xOff + i];
|
|
z[zOff + i] = (num << 1) | (c >> 31);
|
|
c = num;
|
|
}
|
|
return c >> 31;
|
|
}
|
|
|
|
public static ulong ShiftUpBit64(int len, ulong[] x, int xOff, ulong c, ulong[] z, int zOff)
|
|
{
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
ulong num = x[xOff + i];
|
|
z[zOff + i] = (num << 1) | (c >> 63);
|
|
c = num;
|
|
}
|
|
return c >> 63;
|
|
}
|
|
|
|
public static uint ShiftUpBits(int len, uint[] z, int bits, uint c)
|
|
{
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
uint num = z[i];
|
|
z[i] = (num << bits) | (c >> -bits);
|
|
c = num;
|
|
}
|
|
return c >> -bits;
|
|
}
|
|
|
|
public static uint ShiftUpBits(int len, uint[] z, int zOff, int bits, uint c)
|
|
{
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
uint num = z[zOff + i];
|
|
z[zOff + i] = (num << bits) | (c >> -bits);
|
|
c = num;
|
|
}
|
|
return c >> -bits;
|
|
}
|
|
|
|
public static ulong ShiftUpBits64(int len, ulong[] z, int zOff, int bits, ulong c)
|
|
{
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
ulong num = z[zOff + i];
|
|
z[zOff + i] = (num << bits) | (c >> -bits);
|
|
c = num;
|
|
}
|
|
return c >> -bits;
|
|
}
|
|
|
|
public static uint ShiftUpBits(int len, uint[] x, int bits, uint c, uint[] z)
|
|
{
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
uint num = x[i];
|
|
z[i] = (num << bits) | (c >> -bits);
|
|
c = num;
|
|
}
|
|
return c >> -bits;
|
|
}
|
|
|
|
public static uint ShiftUpBits(int len, uint[] x, int xOff, int bits, uint c, uint[] z, int zOff)
|
|
{
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
uint num = x[xOff + i];
|
|
z[zOff + i] = (num << bits) | (c >> -bits);
|
|
c = num;
|
|
}
|
|
return c >> -bits;
|
|
}
|
|
|
|
public static ulong ShiftUpBits64(int len, ulong[] x, int xOff, int bits, ulong c, ulong[] z, int zOff)
|
|
{
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
ulong num = x[xOff + i];
|
|
z[zOff + i] = (num << bits) | (c >> -bits);
|
|
c = num;
|
|
}
|
|
return c >> -bits;
|
|
}
|
|
|
|
public static void Square(int len, uint[] x, uint[] zz)
|
|
{
|
|
int num = len << 1;
|
|
uint num2 = 0u;
|
|
int num3 = len;
|
|
int num4 = num;
|
|
do
|
|
{
|
|
ulong num5 = x[--num3];
|
|
ulong num6 = num5 * num5;
|
|
zz[--num4] = (num2 << 31) | (uint)(int)(num6 >> 33);
|
|
zz[--num4] = (uint)(num6 >> 1);
|
|
num2 = (uint)num6;
|
|
}
|
|
while (num3 > 0);
|
|
for (int i = 1; i < len; i++)
|
|
{
|
|
num2 = SquareWordAdd(x, i, zz);
|
|
AddWordAt(num, num2, zz, i << 1);
|
|
}
|
|
ShiftUpBit(num, zz, x[0] << 31);
|
|
}
|
|
|
|
public static void Square(int len, uint[] x, int xOff, uint[] zz, int zzOff)
|
|
{
|
|
int num = len << 1;
|
|
uint num2 = 0u;
|
|
int num3 = len;
|
|
int num4 = num;
|
|
do
|
|
{
|
|
ulong num5 = x[xOff + --num3];
|
|
ulong num6 = num5 * num5;
|
|
zz[zzOff + --num4] = (num2 << 31) | (uint)(int)(num6 >> 33);
|
|
zz[zzOff + --num4] = (uint)(num6 >> 1);
|
|
num2 = (uint)num6;
|
|
}
|
|
while (num3 > 0);
|
|
for (int i = 1; i < len; i++)
|
|
{
|
|
num2 = SquareWordAdd(x, xOff, i, zz, zzOff);
|
|
AddWordAt(num, num2, zz, zzOff, i << 1);
|
|
}
|
|
ShiftUpBit(num, zz, zzOff, x[xOff] << 31);
|
|
}
|
|
|
|
public static uint SquareWordAdd(uint[] x, int xPos, uint[] z)
|
|
{
|
|
ulong num = 0uL;
|
|
ulong num2 = x[xPos];
|
|
int num3 = 0;
|
|
do
|
|
{
|
|
num += num2 * x[num3] + z[xPos + num3];
|
|
z[xPos + num3] = (uint)num;
|
|
num >>= 32;
|
|
}
|
|
while (++num3 < xPos);
|
|
return (uint)num;
|
|
}
|
|
|
|
public static uint SquareWordAdd(uint[] x, int xOff, int xPos, uint[] z, int zOff)
|
|
{
|
|
ulong num = 0uL;
|
|
ulong num2 = x[xOff + xPos];
|
|
int num3 = 0;
|
|
do
|
|
{
|
|
num += num2 * ((ulong)x[xOff + num3] & 0xFFFFFFFFuL) + ((ulong)z[xPos + zOff] & 0xFFFFFFFFuL);
|
|
z[xPos + zOff] = (uint)num;
|
|
num >>= 32;
|
|
zOff++;
|
|
}
|
|
while (++num3 < xPos);
|
|
return (uint)num;
|
|
}
|
|
|
|
public static int Sub(int len, uint[] x, uint[] y, uint[] z)
|
|
{
|
|
long num = 0L;
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
num += (long)x[i] - (long)y[i];
|
|
z[i] = (uint)num;
|
|
num >>= 32;
|
|
}
|
|
return (int)num;
|
|
}
|
|
|
|
public static int Sub(int len, uint[] x, int xOff, uint[] y, int yOff, uint[] z, int zOff)
|
|
{
|
|
long num = 0L;
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
num += (long)x[xOff + i] - (long)y[yOff + i];
|
|
z[zOff + i] = (uint)num;
|
|
num >>= 32;
|
|
}
|
|
return (int)num;
|
|
}
|
|
|
|
public static int Sub33At(int len, uint x, uint[] z, int zPos)
|
|
{
|
|
long num = (long)z[zPos] - (long)x;
|
|
z[zPos] = (uint)num;
|
|
num >>= 32;
|
|
num += (long)z[zPos + 1] - 1L;
|
|
z[zPos + 1] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return DecAt(len, z, zPos + 2);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public static int Sub33At(int len, uint x, uint[] z, int zOff, int zPos)
|
|
{
|
|
long num = (long)z[zOff + zPos] - (long)x;
|
|
z[zOff + zPos] = (uint)num;
|
|
num >>= 32;
|
|
num += (long)z[zOff + zPos + 1] - 1L;
|
|
z[zOff + zPos + 1] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return DecAt(len, z, zOff, zPos + 2);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public static int Sub33From(int len, uint x, uint[] z)
|
|
{
|
|
long num = (long)z[0] - (long)x;
|
|
z[0] = (uint)num;
|
|
num >>= 32;
|
|
num += (long)z[1] - 1L;
|
|
z[1] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return DecAt(len, z, 2);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public static int Sub33From(int len, uint x, uint[] z, int zOff)
|
|
{
|
|
long num = (long)z[zOff] - (long)x;
|
|
z[zOff] = (uint)num;
|
|
num >>= 32;
|
|
num += (long)z[zOff + 1] - 1L;
|
|
z[zOff + 1] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return DecAt(len, z, zOff, 2);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public static int SubBothFrom(int len, uint[] x, uint[] y, uint[] z)
|
|
{
|
|
long num = 0L;
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
num += (long)z[i] - (long)x[i] - y[i];
|
|
z[i] = (uint)num;
|
|
num >>= 32;
|
|
}
|
|
return (int)num;
|
|
}
|
|
|
|
public static int SubBothFrom(int len, uint[] x, int xOff, uint[] y, int yOff, uint[] z, int zOff)
|
|
{
|
|
long num = 0L;
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
num += (long)z[zOff + i] - (long)x[xOff + i] - y[yOff + i];
|
|
z[zOff + i] = (uint)num;
|
|
num >>= 32;
|
|
}
|
|
return (int)num;
|
|
}
|
|
|
|
public static int SubDWordAt(int len, ulong x, uint[] z, int zPos)
|
|
{
|
|
long num = (long)(z[zPos] - (x & 0xFFFFFFFFu));
|
|
z[zPos] = (uint)num;
|
|
num >>= 32;
|
|
num += (long)(z[zPos + 1] - (x >> 32));
|
|
z[zPos + 1] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return DecAt(len, z, zPos + 2);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public static int SubDWordAt(int len, ulong x, uint[] z, int zOff, int zPos)
|
|
{
|
|
long num = (long)(z[zOff + zPos] - (x & 0xFFFFFFFFu));
|
|
z[zOff + zPos] = (uint)num;
|
|
num >>= 32;
|
|
num += (long)(z[zOff + zPos + 1] - (x >> 32));
|
|
z[zOff + zPos + 1] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return DecAt(len, z, zOff, zPos + 2);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public static int SubDWordFrom(int len, ulong x, uint[] z)
|
|
{
|
|
long num = (long)(z[0] - (x & 0xFFFFFFFFu));
|
|
z[0] = (uint)num;
|
|
num >>= 32;
|
|
num += (long)(z[1] - (x >> 32));
|
|
z[1] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return DecAt(len, z, 2);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public static int SubDWordFrom(int len, ulong x, uint[] z, int zOff)
|
|
{
|
|
long num = (long)(z[zOff] - (x & 0xFFFFFFFFu));
|
|
z[zOff] = (uint)num;
|
|
num >>= 32;
|
|
num += (long)(z[zOff + 1] - (x >> 32));
|
|
z[zOff + 1] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return DecAt(len, z, zOff, 2);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public static int SubFrom(int len, uint[] x, uint[] z)
|
|
{
|
|
long num = 0L;
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
num += (long)z[i] - (long)x[i];
|
|
z[i] = (uint)num;
|
|
num >>= 32;
|
|
}
|
|
return (int)num;
|
|
}
|
|
|
|
public static int SubFrom(int len, uint[] x, int xOff, uint[] z, int zOff)
|
|
{
|
|
long num = 0L;
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
num += (long)z[zOff + i] - (long)x[xOff + i];
|
|
z[zOff + i] = (uint)num;
|
|
num >>= 32;
|
|
}
|
|
return (int)num;
|
|
}
|
|
|
|
public static int SubWordAt(int len, uint x, uint[] z, int zPos)
|
|
{
|
|
long num = (long)z[zPos] - (long)x;
|
|
z[zPos] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return DecAt(len, z, zPos + 1);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public static int SubWordAt(int len, uint x, uint[] z, int zOff, int zPos)
|
|
{
|
|
long num = (long)z[zOff + zPos] - (long)x;
|
|
z[zOff + zPos] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return DecAt(len, z, zOff, zPos + 1);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public static int SubWordFrom(int len, uint x, uint[] z)
|
|
{
|
|
long num = (long)z[0] - (long)x;
|
|
z[0] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return DecAt(len, z, 1);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public static int SubWordFrom(int len, uint x, uint[] z, int zOff)
|
|
{
|
|
long num = (long)z[zOff] - (long)x;
|
|
z[zOff] = (uint)num;
|
|
num >>= 32;
|
|
if (num != 0)
|
|
{
|
|
return DecAt(len, z, zOff, 1);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public static BigInteger ToBigInteger(int len, uint[] x)
|
|
{
|
|
byte[] array = new byte[len << 2];
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
uint num = x[i];
|
|
if (num != 0)
|
|
{
|
|
Pack.UInt32_To_BE(num, array, len - 1 - i << 2);
|
|
}
|
|
}
|
|
return new BigInteger(1, array);
|
|
}
|
|
|
|
public static void Zero(int len, uint[] z)
|
|
{
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
z[i] = 0u;
|
|
}
|
|
}
|
|
}
|