Etyuhibosecyu Cryptosystems 1925 Pre-Pre-Alpha 95

public byte[] Encrypt(byte[] bytes, BigInt[] initialization_vector, BigInt[] keys, out int block_count, bool change_pb = true)
{
    List<byte> list = bytes.ToList();
    int num = list.Count % SUBBLOCK_LENGTH;
    while (list.Count % SUBBLOCK_LENGTH != SUBBLOCK_LENGTH - 2)
    {
        list.Add((byte)(random.Next(65536) % 256));
    }
    int num2 = random.Next(65536) / SUBBLOCK_LENGTH * SUBBLOCK_LENGTH + num;
    int num3 = (num2 >= 65536) ? (num2 - SUBBLOCK_LENGTH) : num2;
    list.Add((byte)(num3 / 256));
    list.Add((byte)(num3 % 256));
    List<BigInt> list2 = new List<BigInt>(keys);
    if (change_pb)
    {
        status = 0;
        status_maximum = 816;
    }
    for (int i = 16; i < 832; i++)
    {
        list2.Add(Add(Mul(list2[i - 16], BigInt.Power(9, 9)), BigInt.Power(25, 25)));
        if (change_pb)
        {
            status++;
        }
    }
    BigInt[] array = new BigInt[8];
    Array.Copy(initialization_vector, array, 8);
    if (change_pb)
    {
        status = 0;
        status_maximum = 40 * list.Count / SUBBLOCK_LENGTH;
        current += 10;
    }
    for (int j = 0; j < 2; j++)
    {
        List<byte> list3 = Form1.WorkUpBitsList(initialization_vector.SelectMany((BigInt x) => Form1.ToBitsList((x + BASE).ToByteArray().ToList()).Where((byte y, int index) => index < SUBBLOCK_LENGTH / 8 * 8 || index >= (SUBBLOCK_LENGTH / 8 * 2 + 1) * 8 - SUBBLOCK_LENGTH)).ToList());
        for (int k = 0; k < list.Count; k += SUBBLOCK_LENGTH)
        {
            for (int l = 0; l < 16; l++)
            {
                array = Round(array, list2.GetRange((j * 32 + l) * 13, 13).ToArray());
            }
            List<byte> list4 = Form1.WorkUpBitsList(array.SelectMany((BigInt x) => Form1.ToBitsList((x + BASE).ToByteArray().ToList()).Where((byte y, int index) => index < SUBBLOCK_LENGTH / 8 * 8 || index >= (SUBBLOCK_LENGTH / 8 * 2 + 1) * 8 - SUBBLOCK_LENGTH)).ToList());
            for (int m = 0; m < SUBBLOCK_LENGTH; m++)
            {
                list[k + m] = (byte)(list[k + m] ^ list4[m] ^ list3[m]);
            }
            if (change_pb)
            {
                status += 10;
            }
            BigInt[] array2 = new BigInt[8];
            List<byte> list5 = Form1.ToBitsList(list.GetRange(k, SUBBLOCK_LENGTH).ToList());
            for (int n = 0; n < 8; n++)
            {
                array2[n] = new BigInt(Form1.WorkUpBitsList(list5.GetRange(n * SUBBLOCK_LENGTH, SUBBLOCK_LENGTH)).ToArray());
            }
            for (int num4 = 0; num4 < 16; num4++)
            {
                array2 = Round(array2, list2.GetRange((j * 32 + 16 + num4) * 13, 13).ToArray());
            }
            List<byte> list6 = Form1.WorkUpBitsList(array2.SelectMany((BigInt x) => Form1.ToBitsList((x + BASE).ToByteArray().ToList()).Where((byte y, int index) => index < SUBBLOCK_LENGTH / 8 * 8 || index >= (SUBBLOCK_LENGTH / 8 * 2 + 1) * 8 - SUBBLOCK_LENGTH)).ToList());
            for (int num5 = 0; num5 < SUBBLOCK_LENGTH; num5++)
            {
                list[k + num5] = list6[num5];
                list3[num5] = list[k + num5];
            }
            if (change_pb)
            {
                status += 10;
            }
        }
        list.Reverse();
    }
    block_count = list.Count / SUBBLOCK_LENGTH;
    return list.ToArray();
}

public Symmetrical(int subblock_length)
{
    SUBBLOCK_LENGTH = 64;
    random = new Random();
    base..ctor();
    SUBBLOCK_LENGTH = subblock_length;
}

private BigInt[] Round(BigInt[] m, BigInt[] k)
{
    BigInt[] array = new BigInt[8];
    BigInt[] array2 = new BigInt[8];
    BigInt[] array3 = new BigInt[8];
    BigInt[] array4 = new BigInt[8];
    BigInt[] array5 = new BigInt[8];
    array[0] = Mul(m[0], k[0]);
    array[1] = Xor(m[1], k[1]);
    array[2] = Add(m[2], k[2]);
    array[3] = Xor(m[3], k[3]);
    array[4] = Mul(m[4], k[4]);
    array[5] = Add(m[5], k[5]);
    array[6] = Mul(m[6], k[6]);
    array[7] = Xor(m[7], k[7]);
    array2[0] = Add(array[0], MulInv(array[1]));
    array2[1] = Mul(array[1], k[8]);
    array2[2] = Xor(array[2], array2[1]);
    array2[3] = Mul(array[3], array2[2]);
    array2[7] = Add(array[7], XorInv(array[6]));
    array2[6] = Xor(array[6], k[10]);
    array2[5] = Add(array[4], array2[6]);
    array2[4] = Xor(MulInv(array[5]), array2[5]);
    array3[2] = Add(XorInv(array2[1]), k[11]);
    array3[3] = Xor(array2[3], k[9]);
    array3[4] = Mul(array2[4], k[9]);
    array3[5] = Add(array2[6], k[12]);
    array3[0] = Xor(MulInv(array2[0]), array3[2]);
    array3[1] = Mul(array2[2], array2[5]);
    array3[6] = Mul(AddInv(array2[2]), array2[7]);
    array3[7] = Mul(XorInv(array2[7]), array3[5]);
    array4[0] = Mul(array3[0], XorInv(array3[2]));
    array4[1] = Add(array3[1], XorInv(array3[4]));
    array4[2] = Mul(AddInv(array3[0]), array4[1]);
    array4[3] = Add(array3[3], array4[2]);
    array4[7] = Xor(array3[7], MulInv(array3[5]));
    array4[6] = Add(array3[6], MulInv(array3[3]));
    array4[5] = Xor(AddInv(array3[7]), array4[6]);
    array4[4] = Add(XorInv(array3[4]), array4[5]);
    array5[0] = array4[0];
    array5[1] = array4[2];
    array5[2] = array4[1];
    array5[3] = array4[3];
    array5[4] = array4[4];
    array5[5] = array4[6];
    array5[6] = array4[5];
    array5[7] = array4[7];
    return array5;
}

public static BigComplex GeneralFunctionPlus1(BigComplex a, BigComplex b, BigComplex x)
{
    BigComplex bigComplex = CyclicMultiply(a, x);
    BigReal.Floor(BigReal.CyclicRotateRight2(bigComplex.re, 4095), out BigReal frac);
    BigReal bigReal = BigReal.CyclicRotateLeft(frac, 4095);
    BigComplex bigComplex2 = CyclicMultiply(b, x);
    BigReal.Floor(BigReal.CyclicRotateRight2(bigComplex2.re, 4095), out BigReal frac2);
    BigReal bigReal2 = BigReal.CyclicRotateLeft(frac2, 4095);
    return CyclicMultiply(CyclicMultiply(CyclicAdd(x, BigReal.One), CyclicIExp(CyclicAdd(new BigComplex(bigReal, bigComplex.im), BigReal.One))), CyclicIExp(CyclicIExp(CyclicAdd(new BigComplex(bigReal2, bigComplex2.im), BigReal.One))));
}