// 
// Decompiled by Procyon v0.6.0
// 

package org.bouncycastle.math.raw;

import org.bouncycastle.util.Pack;
import java.math.BigInteger;

public abstract class Nat256
{
    private static final long M = 4294967295L;
    
    public static int add(final int[] array, final int[] array2, final int[] array3) {
        final long n = 0L + (((long)array[0] & 0xFFFFFFFFL) + ((long)array2[0] & 0xFFFFFFFFL));
        array3[0] = (int)n;
        final long n2 = (n >>> 32) + (((long)array[1] & 0xFFFFFFFFL) + ((long)array2[1] & 0xFFFFFFFFL));
        array3[1] = (int)n2;
        final long n3 = (n2 >>> 32) + (((long)array[2] & 0xFFFFFFFFL) + ((long)array2[2] & 0xFFFFFFFFL));
        array3[2] = (int)n3;
        final long n4 = (n3 >>> 32) + (((long)array[3] & 0xFFFFFFFFL) + ((long)array2[3] & 0xFFFFFFFFL));
        array3[3] = (int)n4;
        final long n5 = (n4 >>> 32) + (((long)array[4] & 0xFFFFFFFFL) + ((long)array2[4] & 0xFFFFFFFFL));
        array3[4] = (int)n5;
        final long n6 = (n5 >>> 32) + (((long)array[5] & 0xFFFFFFFFL) + ((long)array2[5] & 0xFFFFFFFFL));
        array3[5] = (int)n6;
        final long n7 = (n6 >>> 32) + (((long)array[6] & 0xFFFFFFFFL) + ((long)array2[6] & 0xFFFFFFFFL));
        array3[6] = (int)n7;
        final long n8 = (n7 >>> 32) + (((long)array[7] & 0xFFFFFFFFL) + ((long)array2[7] & 0xFFFFFFFFL));
        array3[7] = (int)n8;
        return (int)(n8 >>> 32);
    }
    
    public static int add(final int[] array, final int n, final int[] array2, final int n2, final int[] array3, final int n3) {
        final long n4 = 0L + (((long)array[n + 0] & 0xFFFFFFFFL) + ((long)array2[n2 + 0] & 0xFFFFFFFFL));
        array3[n3 + 0] = (int)n4;
        final long n5 = (n4 >>> 32) + (((long)array[n + 1] & 0xFFFFFFFFL) + ((long)array2[n2 + 1] & 0xFFFFFFFFL));
        array3[n3 + 1] = (int)n5;
        final long n6 = (n5 >>> 32) + (((long)array[n + 2] & 0xFFFFFFFFL) + ((long)array2[n2 + 2] & 0xFFFFFFFFL));
        array3[n3 + 2] = (int)n6;
        final long n7 = (n6 >>> 32) + (((long)array[n + 3] & 0xFFFFFFFFL) + ((long)array2[n2 + 3] & 0xFFFFFFFFL));
        array3[n3 + 3] = (int)n7;
        final long n8 = (n7 >>> 32) + (((long)array[n + 4] & 0xFFFFFFFFL) + ((long)array2[n2 + 4] & 0xFFFFFFFFL));
        array3[n3 + 4] = (int)n8;
        final long n9 = (n8 >>> 32) + (((long)array[n + 5] & 0xFFFFFFFFL) + ((long)array2[n2 + 5] & 0xFFFFFFFFL));
        array3[n3 + 5] = (int)n9;
        final long n10 = (n9 >>> 32) + (((long)array[n + 6] & 0xFFFFFFFFL) + ((long)array2[n2 + 6] & 0xFFFFFFFFL));
        array3[n3 + 6] = (int)n10;
        final long n11 = (n10 >>> 32) + (((long)array[n + 7] & 0xFFFFFFFFL) + ((long)array2[n2 + 7] & 0xFFFFFFFFL));
        array3[n3 + 7] = (int)n11;
        return (int)(n11 >>> 32);
    }
    
    public static int addBothTo(final int[] array, final int[] array2, final int[] array3) {
        final long n = 0L + (((long)array[0] & 0xFFFFFFFFL) + ((long)array2[0] & 0xFFFFFFFFL) + ((long)array3[0] & 0xFFFFFFFFL));
        array3[0] = (int)n;
        final long n2 = (n >>> 32) + (((long)array[1] & 0xFFFFFFFFL) + ((long)array2[1] & 0xFFFFFFFFL) + ((long)array3[1] & 0xFFFFFFFFL));
        array3[1] = (int)n2;
        final long n3 = (n2 >>> 32) + (((long)array[2] & 0xFFFFFFFFL) + ((long)array2[2] & 0xFFFFFFFFL) + ((long)array3[2] & 0xFFFFFFFFL));
        array3[2] = (int)n3;
        final long n4 = (n3 >>> 32) + (((long)array[3] & 0xFFFFFFFFL) + ((long)array2[3] & 0xFFFFFFFFL) + ((long)array3[3] & 0xFFFFFFFFL));
        array3[3] = (int)n4;
        final long n5 = (n4 >>> 32) + (((long)array[4] & 0xFFFFFFFFL) + ((long)array2[4] & 0xFFFFFFFFL) + ((long)array3[4] & 0xFFFFFFFFL));
        array3[4] = (int)n5;
        final long n6 = (n5 >>> 32) + (((long)array[5] & 0xFFFFFFFFL) + ((long)array2[5] & 0xFFFFFFFFL) + ((long)array3[5] & 0xFFFFFFFFL));
        array3[5] = (int)n6;
        final long n7 = (n6 >>> 32) + (((long)array[6] & 0xFFFFFFFFL) + ((long)array2[6] & 0xFFFFFFFFL) + ((long)array3[6] & 0xFFFFFFFFL));
        array3[6] = (int)n7;
        final long n8 = (n7 >>> 32) + (((long)array[7] & 0xFFFFFFFFL) + ((long)array2[7] & 0xFFFFFFFFL) + ((long)array3[7] & 0xFFFFFFFFL));
        array3[7] = (int)n8;
        return (int)(n8 >>> 32);
    }
    
    public static int addBothTo(final int[] array, final int n, final int[] array2, final int n2, final int[] array3, final int n3) {
        final long n4 = 0L + (((long)array[n + 0] & 0xFFFFFFFFL) + ((long)array2[n2 + 0] & 0xFFFFFFFFL) + ((long)array3[n3 + 0] & 0xFFFFFFFFL));
        array3[n3 + 0] = (int)n4;
        final long n5 = (n4 >>> 32) + (((long)array[n + 1] & 0xFFFFFFFFL) + ((long)array2[n2 + 1] & 0xFFFFFFFFL) + ((long)array3[n3 + 1] & 0xFFFFFFFFL));
        array3[n3 + 1] = (int)n5;
        final long n6 = (n5 >>> 32) + (((long)array[n + 2] & 0xFFFFFFFFL) + ((long)array2[n2 + 2] & 0xFFFFFFFFL) + ((long)array3[n3 + 2] & 0xFFFFFFFFL));
        array3[n3 + 2] = (int)n6;
        final long n7 = (n6 >>> 32) + (((long)array[n + 3] & 0xFFFFFFFFL) + ((long)array2[n2 + 3] & 0xFFFFFFFFL) + ((long)array3[n3 + 3] & 0xFFFFFFFFL));
        array3[n3 + 3] = (int)n7;
        final long n8 = (n7 >>> 32) + (((long)array[n + 4] & 0xFFFFFFFFL) + ((long)array2[n2 + 4] & 0xFFFFFFFFL) + ((long)array3[n3 + 4] & 0xFFFFFFFFL));
        array3[n3 + 4] = (int)n8;
        final long n9 = (n8 >>> 32) + (((long)array[n + 5] & 0xFFFFFFFFL) + ((long)array2[n2 + 5] & 0xFFFFFFFFL) + ((long)array3[n3 + 5] & 0xFFFFFFFFL));
        array3[n3 + 5] = (int)n9;
        final long n10 = (n9 >>> 32) + (((long)array[n + 6] & 0xFFFFFFFFL) + ((long)array2[n2 + 6] & 0xFFFFFFFFL) + ((long)array3[n3 + 6] & 0xFFFFFFFFL));
        array3[n3 + 6] = (int)n10;
        final long n11 = (n10 >>> 32) + (((long)array[n + 7] & 0xFFFFFFFFL) + ((long)array2[n2 + 7] & 0xFFFFFFFFL) + ((long)array3[n3 + 7] & 0xFFFFFFFFL));
        array3[n3 + 7] = (int)n11;
        return (int)(n11 >>> 32);
    }
    
    public static int addTo(final int[] array, final int[] array2) {
        final long n = 0L + (((long)array[0] & 0xFFFFFFFFL) + ((long)array2[0] & 0xFFFFFFFFL));
        array2[0] = (int)n;
        final long n2 = (n >>> 32) + (((long)array[1] & 0xFFFFFFFFL) + ((long)array2[1] & 0xFFFFFFFFL));
        array2[1] = (int)n2;
        final long n3 = (n2 >>> 32) + (((long)array[2] & 0xFFFFFFFFL) + ((long)array2[2] & 0xFFFFFFFFL));
        array2[2] = (int)n3;
        final long n4 = (n3 >>> 32) + (((long)array[3] & 0xFFFFFFFFL) + ((long)array2[3] & 0xFFFFFFFFL));
        array2[3] = (int)n4;
        final long n5 = (n4 >>> 32) + (((long)array[4] & 0xFFFFFFFFL) + ((long)array2[4] & 0xFFFFFFFFL));
        array2[4] = (int)n5;
        final long n6 = (n5 >>> 32) + (((long)array[5] & 0xFFFFFFFFL) + ((long)array2[5] & 0xFFFFFFFFL));
        array2[5] = (int)n6;
        final long n7 = (n6 >>> 32) + (((long)array[6] & 0xFFFFFFFFL) + ((long)array2[6] & 0xFFFFFFFFL));
        array2[6] = (int)n7;
        final long n8 = (n7 >>> 32) + (((long)array[7] & 0xFFFFFFFFL) + ((long)array2[7] & 0xFFFFFFFFL));
        array2[7] = (int)n8;
        return (int)(n8 >>> 32);
    }
    
    public static int addTo(final int[] array, final int[] array2, final int n) {
        final long n2 = ((long)n & 0xFFFFFFFFL) + (((long)array[0] & 0xFFFFFFFFL) + ((long)array2[0] & 0xFFFFFFFFL));
        array2[0] = (int)n2;
        final long n3 = (n2 >>> 32) + (((long)array[1] & 0xFFFFFFFFL) + ((long)array2[1] & 0xFFFFFFFFL));
        array2[1] = (int)n3;
        final long n4 = (n3 >>> 32) + (((long)array[2] & 0xFFFFFFFFL) + ((long)array2[2] & 0xFFFFFFFFL));
        array2[2] = (int)n4;
        final long n5 = (n4 >>> 32) + (((long)array[3] & 0xFFFFFFFFL) + ((long)array2[3] & 0xFFFFFFFFL));
        array2[3] = (int)n5;
        final long n6 = (n5 >>> 32) + (((long)array[4] & 0xFFFFFFFFL) + ((long)array2[4] & 0xFFFFFFFFL));
        array2[4] = (int)n6;
        final long n7 = (n6 >>> 32) + (((long)array[5] & 0xFFFFFFFFL) + ((long)array2[5] & 0xFFFFFFFFL));
        array2[5] = (int)n7;
        final long n8 = (n7 >>> 32) + (((long)array[6] & 0xFFFFFFFFL) + ((long)array2[6] & 0xFFFFFFFFL));
        array2[6] = (int)n8;
        final long n9 = (n8 >>> 32) + (((long)array[7] & 0xFFFFFFFFL) + ((long)array2[7] & 0xFFFFFFFFL));
        array2[7] = (int)n9;
        return (int)(n9 >>> 32);
    }
    
    public static int addTo(final int[] array, final int n, final int[] array2, final int n2, final int n3) {
        final long n4 = ((long)n3 & 0xFFFFFFFFL) + (((long)array[n + 0] & 0xFFFFFFFFL) + ((long)array2[n2 + 0] & 0xFFFFFFFFL));
        array2[n2 + 0] = (int)n4;
        final long n5 = (n4 >>> 32) + (((long)array[n + 1] & 0xFFFFFFFFL) + ((long)array2[n2 + 1] & 0xFFFFFFFFL));
        array2[n2 + 1] = (int)n5;
        final long n6 = (n5 >>> 32) + (((long)array[n + 2] & 0xFFFFFFFFL) + ((long)array2[n2 + 2] & 0xFFFFFFFFL));
        array2[n2 + 2] = (int)n6;
        final long n7 = (n6 >>> 32) + (((long)array[n + 3] & 0xFFFFFFFFL) + ((long)array2[n2 + 3] & 0xFFFFFFFFL));
        array2[n2 + 3] = (int)n7;
        final long n8 = (n7 >>> 32) + (((long)array[n + 4] & 0xFFFFFFFFL) + ((long)array2[n2 + 4] & 0xFFFFFFFFL));
        array2[n2 + 4] = (int)n8;
        final long n9 = (n8 >>> 32) + (((long)array[n + 5] & 0xFFFFFFFFL) + ((long)array2[n2 + 5] & 0xFFFFFFFFL));
        array2[n2 + 5] = (int)n9;
        final long n10 = (n9 >>> 32) + (((long)array[n + 6] & 0xFFFFFFFFL) + ((long)array2[n2 + 6] & 0xFFFFFFFFL));
        array2[n2 + 6] = (int)n10;
        final long n11 = (n10 >>> 32) + (((long)array[n + 7] & 0xFFFFFFFFL) + ((long)array2[n2 + 7] & 0xFFFFFFFFL));
        array2[n2 + 7] = (int)n11;
        return (int)(n11 >>> 32);
    }
    
    public static int addToEachOther(final int[] array, final int n, final int[] array2, final int n2) {
        final long n3 = 0L + (((long)array[n + 0] & 0xFFFFFFFFL) + ((long)array2[n2 + 0] & 0xFFFFFFFFL));
        array[n + 0] = (int)n3;
        array2[n2 + 0] = (int)n3;
        final long n4 = (n3 >>> 32) + (((long)array[n + 1] & 0xFFFFFFFFL) + ((long)array2[n2 + 1] & 0xFFFFFFFFL));
        array[n + 1] = (int)n4;
        array2[n2 + 1] = (int)n4;
        final long n5 = (n4 >>> 32) + (((long)array[n + 2] & 0xFFFFFFFFL) + ((long)array2[n2 + 2] & 0xFFFFFFFFL));
        array[n + 2] = (int)n5;
        array2[n2 + 2] = (int)n5;
        final long n6 = (n5 >>> 32) + (((long)array[n + 3] & 0xFFFFFFFFL) + ((long)array2[n2 + 3] & 0xFFFFFFFFL));
        array[n + 3] = (int)n6;
        array2[n2 + 3] = (int)n6;
        final long n7 = (n6 >>> 32) + (((long)array[n + 4] & 0xFFFFFFFFL) + ((long)array2[n2 + 4] & 0xFFFFFFFFL));
        array[n + 4] = (int)n7;
        array2[n2 + 4] = (int)n7;
        final long n8 = (n7 >>> 32) + (((long)array[n + 5] & 0xFFFFFFFFL) + ((long)array2[n2 + 5] & 0xFFFFFFFFL));
        array[n + 5] = (int)n8;
        array2[n2 + 5] = (int)n8;
        final long n9 = (n8 >>> 32) + (((long)array[n + 6] & 0xFFFFFFFFL) + ((long)array2[n2 + 6] & 0xFFFFFFFFL));
        array[n + 6] = (int)n9;
        array2[n2 + 6] = (int)n9;
        final long n10 = (n9 >>> 32) + (((long)array[n + 7] & 0xFFFFFFFFL) + ((long)array2[n2 + 7] & 0xFFFFFFFFL));
        array[n + 7] = (int)n10;
        array2[n2 + 7] = (int)n10;
        return (int)(n10 >>> 32);
    }
    
    public static void copy(final int[] array, final int[] array2) {
        array2[0] = array[0];
        array2[1] = array[1];
        array2[2] = array[2];
        array2[3] = array[3];
        array2[4] = array[4];
        array2[5] = array[5];
        array2[6] = array[6];
        array2[7] = array[7];
    }
    
    public static void copy(final int[] array, final int n, final int[] array2, final int n2) {
        array2[n2 + 0] = array[n + 0];
        array2[n2 + 1] = array[n + 1];
        array2[n2 + 2] = array[n + 2];
        array2[n2 + 3] = array[n + 3];
        array2[n2 + 4] = array[n + 4];
        array2[n2 + 5] = array[n + 5];
        array2[n2 + 6] = array[n + 6];
        array2[n2 + 7] = array[n + 7];
    }
    
    public static void copy64(final long[] array, final long[] array2) {
        array2[0] = array[0];
        array2[1] = array[1];
        array2[2] = array[2];
        array2[3] = array[3];
    }
    
    public static void copy64(final long[] array, final int n, final long[] array2, final int n2) {
        array2[n2 + 0] = array[n + 0];
        array2[n2 + 1] = array[n + 1];
        array2[n2 + 2] = array[n + 2];
        array2[n2 + 3] = array[n + 3];
    }
    
    public static int[] create() {
        return new int[8];
    }
    
    public static long[] create64() {
        return new long[4];
    }
    
    public static int[] createExt() {
        return new int[16];
    }
    
    public static long[] createExt64() {
        return new long[8];
    }
    
    public static boolean diff(final int[] array, final int n, final int[] array2, final int n2, final int[] array3, final int n3) {
        final boolean gte = gte(array, n, array2, n2);
        if (gte) {
            sub(array, n, array2, n2, array3, n3);
        }
        else {
            sub(array2, n2, array, n, array3, n3);
        }
        return gte;
    }
    
    public static boolean eq(final int[] array, final int[] array2) {
        for (int i = 7; i >= 0; --i) {
            if (array[i] != array2[i]) {
                return false;
            }
        }
        return true;
    }
    
    public static boolean eq64(final long[] array, final long[] array2) {
        for (int i = 3; i >= 0; --i) {
            if (array[i] != array2[i]) {
                return false;
            }
        }
        return true;
    }
    
    public static int[] fromBigInteger(BigInteger shiftRight) {
        if (shiftRight.signum() < 0 || shiftRight.bitLength() > 256) {
            throw new IllegalArgumentException();
        }
        final int[] create = create();
        for (int i = 0; i < 8; ++i) {
            create[i] = shiftRight.intValue();
            shiftRight = shiftRight.shiftRight(32);
        }
        return create;
    }
    
    public static long[] fromBigInteger64(BigInteger shiftRight) {
        if (shiftRight.signum() < 0 || shiftRight.bitLength() > 256) {
            throw new IllegalArgumentException();
        }
        final long[] create64 = create64();
        for (int i = 0; i < 4; ++i) {
            create64[i] = shiftRight.longValue();
            shiftRight = shiftRight.shiftRight(64);
        }
        return create64;
    }
    
    public static int getBit(final int[] array, final int n) {
        if (n == 0) {
            return array[0] & 0x1;
        }
        if ((n & 0xFF) != n) {
            return 0;
        }
        return array[n >>> 5] >>> (n & 0x1F) & 0x1;
    }
    
    public static boolean gte(final int[] array, final int[] array2) {
        for (int i = 7; i >= 0; --i) {
            final int n = array[i] ^ Integer.MIN_VALUE;
            final int n2 = array2[i] ^ Integer.MIN_VALUE;
            if (n < n2) {
                return false;
            }
            if (n > n2) {
                return true;
            }
        }
        return true;
    }
    
    public static boolean gte(final int[] array, final int n, final int[] array2, final int n2) {
        for (int i = 7; i >= 0; --i) {
            final int n3 = array[n + i] ^ Integer.MIN_VALUE;
            final int n4 = array2[n2 + i] ^ Integer.MIN_VALUE;
            if (n3 < n4) {
                return false;
            }
            if (n3 > n4) {
                return true;
            }
        }
        return true;
    }
    
    public static boolean isOne(final int[] array) {
        if (array[0] != 1) {
            return false;
        }
        for (int i = 1; i < 8; ++i) {
            if (array[i] != 0) {
                return false;
            }
        }
        return true;
    }
    
    public static boolean isOne64(final long[] array) {
        if (array[0] != 1L) {
            return false;
        }
        for (int i = 1; i < 4; ++i) {
            if (array[i] != 0L) {
                return false;
            }
        }
        return true;
    }
    
    public static boolean isZero(final int[] array) {
        for (int i = 0; i < 8; ++i) {
            if (array[i] != 0) {
                return false;
            }
        }
        return true;
    }
    
    public static boolean isZero64(final long[] array) {
        for (int i = 0; i < 4; ++i) {
            if (array[i] != 0L) {
                return false;
            }
        }
        return true;
    }
    
    public static void mul(final int[] array, final int[] array2, final int[] array3) {
        final long n = (long)array2[0] & 0xFFFFFFFFL;
        final long n2 = (long)array2[1] & 0xFFFFFFFFL;
        final long n3 = (long)array2[2] & 0xFFFFFFFFL;
        final long n4 = (long)array2[3] & 0xFFFFFFFFL;
        final long n5 = (long)array2[4] & 0xFFFFFFFFL;
        final long n6 = (long)array2[5] & 0xFFFFFFFFL;
        final long n7 = (long)array2[6] & 0xFFFFFFFFL;
        final long n8 = (long)array2[7] & 0xFFFFFFFFL;
        final long n9 = 0L;
        final long n10 = (long)array[0] & 0xFFFFFFFFL;
        final long n11 = n9 + n10 * n;
        array3[0] = (int)n11;
        final long n12 = (n11 >>> 32) + n10 * n2;
        array3[1] = (int)n12;
        final long n13 = (n12 >>> 32) + n10 * n3;
        array3[2] = (int)n13;
        final long n14 = (n13 >>> 32) + n10 * n4;
        array3[3] = (int)n14;
        final long n15 = (n14 >>> 32) + n10 * n5;
        array3[4] = (int)n15;
        final long n16 = (n15 >>> 32) + n10 * n6;
        array3[5] = (int)n16;
        final long n17 = (n16 >>> 32) + n10 * n7;
        array3[6] = (int)n17;
        final long n18 = (n17 >>> 32) + n10 * n8;
        array3[7] = (int)n18;
        array3[8] = (int)(n18 >>> 32);
        for (int i = 1; i < 8; ++i) {
            final long n19 = 0L;
            final long n20 = (long)array[i] & 0xFFFFFFFFL;
            final long n21 = n19 + (n20 * n + ((long)array3[i + 0] & 0xFFFFFFFFL));
            array3[i + 0] = (int)n21;
            final long n22 = (n21 >>> 32) + (n20 * n2 + ((long)array3[i + 1] & 0xFFFFFFFFL));
            array3[i + 1] = (int)n22;
            final long n23 = (n22 >>> 32) + (n20 * n3 + ((long)array3[i + 2] & 0xFFFFFFFFL));
            array3[i + 2] = (int)n23;
            final long n24 = (n23 >>> 32) + (n20 * n4 + ((long)array3[i + 3] & 0xFFFFFFFFL));
            array3[i + 3] = (int)n24;
            final long n25 = (n24 >>> 32) + (n20 * n5 + ((long)array3[i + 4] & 0xFFFFFFFFL));
            array3[i + 4] = (int)n25;
            final long n26 = (n25 >>> 32) + (n20 * n6 + ((long)array3[i + 5] & 0xFFFFFFFFL));
            array3[i + 5] = (int)n26;
            final long n27 = (n26 >>> 32) + (n20 * n7 + ((long)array3[i + 6] & 0xFFFFFFFFL));
            array3[i + 6] = (int)n27;
            final long n28 = (n27 >>> 32) + (n20 * n8 + ((long)array3[i + 7] & 0xFFFFFFFFL));
            array3[i + 7] = (int)n28;
            array3[i + 8] = (int)(n28 >>> 32);
        }
    }
    
    public static void mul(final int[] array, final int n, final int[] array2, final int n2, final int[] array3, int n3) {
        final long n4 = (long)array2[n2 + 0] & 0xFFFFFFFFL;
        final long n5 = (long)array2[n2 + 1] & 0xFFFFFFFFL;
        final long n6 = (long)array2[n2 + 2] & 0xFFFFFFFFL;
        final long n7 = (long)array2[n2 + 3] & 0xFFFFFFFFL;
        final long n8 = (long)array2[n2 + 4] & 0xFFFFFFFFL;
        final long n9 = (long)array2[n2 + 5] & 0xFFFFFFFFL;
        final long n10 = (long)array2[n2 + 6] & 0xFFFFFFFFL;
        final long n11 = (long)array2[n2 + 7] & 0xFFFFFFFFL;
        final long n12 = 0L;
        final long n13 = (long)array[n + 0] & 0xFFFFFFFFL;
        final long n14 = n12 + n13 * n4;
        array3[n3 + 0] = (int)n14;
        final long n15 = (n14 >>> 32) + n13 * n5;
        array3[n3 + 1] = (int)n15;
        final long n16 = (n15 >>> 32) + n13 * n6;
        array3[n3 + 2] = (int)n16;
        final long n17 = (n16 >>> 32) + n13 * n7;
        array3[n3 + 3] = (int)n17;
        final long n18 = (n17 >>> 32) + n13 * n8;
        array3[n3 + 4] = (int)n18;
        final long n19 = (n18 >>> 32) + n13 * n9;
        array3[n3 + 5] = (int)n19;
        final long n20 = (n19 >>> 32) + n13 * n10;
        array3[n3 + 6] = (int)n20;
        final long n21 = (n20 >>> 32) + n13 * n11;
        array3[n3 + 7] = (int)n21;
        array3[n3 + 8] = (int)(n21 >>> 32);
        for (int i = 1; i < 8; ++i) {
            ++n3;
            final long n22 = 0L;
            final long n23 = (long)array[n + i] & 0xFFFFFFFFL;
            final long n24 = n22 + (n23 * n4 + ((long)array3[n3 + 0] & 0xFFFFFFFFL));
            array3[n3 + 0] = (int)n24;
            final long n25 = (n24 >>> 32) + (n23 * n5 + ((long)array3[n3 + 1] & 0xFFFFFFFFL));
            array3[n3 + 1] = (int)n25;
            final long n26 = (n25 >>> 32) + (n23 * n6 + ((long)array3[n3 + 2] & 0xFFFFFFFFL));
            array3[n3 + 2] = (int)n26;
            final long n27 = (n26 >>> 32) + (n23 * n7 + ((long)array3[n3 + 3] & 0xFFFFFFFFL));
            array3[n3 + 3] = (int)n27;
            final long n28 = (n27 >>> 32) + (n23 * n8 + ((long)array3[n3 + 4] & 0xFFFFFFFFL));
            array3[n3 + 4] = (int)n28;
            final long n29 = (n28 >>> 32) + (n23 * n9 + ((long)array3[n3 + 5] & 0xFFFFFFFFL));
            array3[n3 + 5] = (int)n29;
            final long n30 = (n29 >>> 32) + (n23 * n10 + ((long)array3[n3 + 6] & 0xFFFFFFFFL));
            array3[n3 + 6] = (int)n30;
            final long n31 = (n30 >>> 32) + (n23 * n11 + ((long)array3[n3 + 7] & 0xFFFFFFFFL));
            array3[n3 + 7] = (int)n31;
            array3[n3 + 8] = (int)(n31 >>> 32);
        }
    }
    
    public static void mul128(final int[] array, final int[] array2, final int[] array3) {
        final long n = (long)array[0] & 0xFFFFFFFFL;
        final long n2 = (long)array[1] & 0xFFFFFFFFL;
        final long n3 = (long)array[2] & 0xFFFFFFFFL;
        final long n4 = (long)array[3] & 0xFFFFFFFFL;
        final long n5 = (long)array[4] & 0xFFFFFFFFL;
        final long n6 = (long)array[5] & 0xFFFFFFFFL;
        final long n7 = (long)array[6] & 0xFFFFFFFFL;
        final long n8 = (long)array[7] & 0xFFFFFFFFL;
        final long n9 = 0L;
        final long n10 = (long)array2[0] & 0xFFFFFFFFL;
        final long n11 = n9 + n10 * n;
        array3[0] = (int)n11;
        final long n12 = (n11 >>> 32) + n10 * n2;
        array3[1] = (int)n12;
        final long n13 = (n12 >>> 32) + n10 * n3;
        array3[2] = (int)n13;
        final long n14 = (n13 >>> 32) + n10 * n4;
        array3[3] = (int)n14;
        final long n15 = (n14 >>> 32) + n10 * n5;
        array3[4] = (int)n15;
        final long n16 = (n15 >>> 32) + n10 * n6;
        array3[5] = (int)n16;
        final long n17 = (n16 >>> 32) + n10 * n7;
        array3[6] = (int)n17;
        final long n18 = (n17 >>> 32) + n10 * n8;
        array3[7] = (int)n18;
        array3[8] = (int)(n18 >>> 32);
        for (int i = 1; i < 4; ++i) {
            final long n19 = 0L;
            final long n20 = (long)array2[i] & 0xFFFFFFFFL;
            final long n21 = n19 + (n20 * n + ((long)array3[i + 0] & 0xFFFFFFFFL));
            array3[i + 0] = (int)n21;
            final long n22 = (n21 >>> 32) + (n20 * n2 + ((long)array3[i + 1] & 0xFFFFFFFFL));
            array3[i + 1] = (int)n22;
            final long n23 = (n22 >>> 32) + (n20 * n3 + ((long)array3[i + 2] & 0xFFFFFFFFL));
            array3[i + 2] = (int)n23;
            final long n24 = (n23 >>> 32) + (n20 * n4 + ((long)array3[i + 3] & 0xFFFFFFFFL));
            array3[i + 3] = (int)n24;
            final long n25 = (n24 >>> 32) + (n20 * n5 + ((long)array3[i + 4] & 0xFFFFFFFFL));
            array3[i + 4] = (int)n25;
            final long n26 = (n25 >>> 32) + (n20 * n6 + ((long)array3[i + 5] & 0xFFFFFFFFL));
            array3[i + 5] = (int)n26;
            final long n27 = (n26 >>> 32) + (n20 * n7 + ((long)array3[i + 6] & 0xFFFFFFFFL));
            array3[i + 6] = (int)n27;
            final long n28 = (n27 >>> 32) + (n20 * n8 + ((long)array3[i + 7] & 0xFFFFFFFFL));
            array3[i + 7] = (int)n28;
            array3[i + 8] = (int)(n28 >>> 32);
        }
    }
    
    public static int mulAddTo(final int[] array, final int[] array2, final int[] array3) {
        final long n = (long)array2[0] & 0xFFFFFFFFL;
        final long n2 = (long)array2[1] & 0xFFFFFFFFL;
        final long n3 = (long)array2[2] & 0xFFFFFFFFL;
        final long n4 = (long)array2[3] & 0xFFFFFFFFL;
        final long n5 = (long)array2[4] & 0xFFFFFFFFL;
        final long n6 = (long)array2[5] & 0xFFFFFFFFL;
        final long n7 = (long)array2[6] & 0xFFFFFFFFL;
        final long n8 = (long)array2[7] & 0xFFFFFFFFL;
        long n9 = 0L;
        for (int i = 0; i < 8; ++i) {
            final long n10 = 0L;
            final long n11 = (long)array[i] & 0xFFFFFFFFL;
            final long n12 = n10 + (n11 * n + ((long)array3[i + 0] & 0xFFFFFFFFL));
            array3[i + 0] = (int)n12;
            final long n13 = (n12 >>> 32) + (n11 * n2 + ((long)array3[i + 1] & 0xFFFFFFFFL));
            array3[i + 1] = (int)n13;
            final long n14 = (n13 >>> 32) + (n11 * n3 + ((long)array3[i + 2] & 0xFFFFFFFFL));
            array3[i + 2] = (int)n14;
            final long n15 = (n14 >>> 32) + (n11 * n4 + ((long)array3[i + 3] & 0xFFFFFFFFL));
            array3[i + 3] = (int)n15;
            final long n16 = (n15 >>> 32) + (n11 * n5 + ((long)array3[i + 4] & 0xFFFFFFFFL));
            array3[i + 4] = (int)n16;
            final long n17 = (n16 >>> 32) + (n11 * n6 + ((long)array3[i + 5] & 0xFFFFFFFFL));
            array3[i + 5] = (int)n17;
            final long n18 = (n17 >>> 32) + (n11 * n7 + ((long)array3[i + 6] & 0xFFFFFFFFL));
            array3[i + 6] = (int)n18;
            final long n19 = (n18 >>> 32) + (n11 * n8 + ((long)array3[i + 7] & 0xFFFFFFFFL));
            array3[i + 7] = (int)n19;
            final long n20 = n9 + ((n19 >>> 32) + ((long)array3[i + 8] & 0xFFFFFFFFL));
            array3[i + 8] = (int)n20;
            n9 = n20 >>> 32;
        }
        return (int)n9;
    }
    
    public static int mulAddTo(final int[] array, final int n, final int[] array2, final int n2, final int[] array3, int n3) {
        final long n4 = (long)array2[n2 + 0] & 0xFFFFFFFFL;
        final long n5 = (long)array2[n2 + 1] & 0xFFFFFFFFL;
        final long n6 = (long)array2[n2 + 2] & 0xFFFFFFFFL;
        final long n7 = (long)array2[n2 + 3] & 0xFFFFFFFFL;
        final long n8 = (long)array2[n2 + 4] & 0xFFFFFFFFL;
        final long n9 = (long)array2[n2 + 5] & 0xFFFFFFFFL;
        final long n10 = (long)array2[n2 + 6] & 0xFFFFFFFFL;
        final long n11 = (long)array2[n2 + 7] & 0xFFFFFFFFL;
        long n12 = 0L;
        for (int i = 0; i < 8; ++i) {
            final long n13 = 0L;
            final long n14 = (long)array[n + i] & 0xFFFFFFFFL;
            final long n15 = n13 + (n14 * n4 + ((long)array3[n3 + 0] & 0xFFFFFFFFL));
            array3[n3 + 0] = (int)n15;
            final long n16 = (n15 >>> 32) + (n14 * n5 + ((long)array3[n3 + 1] & 0xFFFFFFFFL));
            array3[n3 + 1] = (int)n16;
            final long n17 = (n16 >>> 32) + (n14 * n6 + ((long)array3[n3 + 2] & 0xFFFFFFFFL));
            array3[n3 + 2] = (int)n17;
            final long n18 = (n17 >>> 32) + (n14 * n7 + ((long)array3[n3 + 3] & 0xFFFFFFFFL));
            array3[n3 + 3] = (int)n18;
            final long n19 = (n18 >>> 32) + (n14 * n8 + ((long)array3[n3 + 4] & 0xFFFFFFFFL));
            array3[n3 + 4] = (int)n19;
            final long n20 = (n19 >>> 32) + (n14 * n9 + ((long)array3[n3 + 5] & 0xFFFFFFFFL));
            array3[n3 + 5] = (int)n20;
            final long n21 = (n20 >>> 32) + (n14 * n10 + ((long)array3[n3 + 6] & 0xFFFFFFFFL));
            array3[n3 + 6] = (int)n21;
            final long n22 = (n21 >>> 32) + (n14 * n11 + ((long)array3[n3 + 7] & 0xFFFFFFFFL));
            array3[n3 + 7] = (int)n22;
            final long n23 = n12 + ((n22 >>> 32) + ((long)array3[n3 + 8] & 0xFFFFFFFFL));
            array3[n3 + 8] = (int)n23;
            n12 = n23 >>> 32;
            ++n3;
        }
        return (int)n12;
    }
    
    public static long mul33Add(final int n, final int[] array, final int n2, final int[] array2, final int n3, final int[] array3, final int n4) {
        final long n5 = 0L;
        final long n6 = (long)n & 0xFFFFFFFFL;
        final long n7 = (long)array[n2 + 0] & 0xFFFFFFFFL;
        final long n8 = n5 + (n6 * n7 + ((long)array2[n3 + 0] & 0xFFFFFFFFL));
        array3[n4 + 0] = (int)n8;
        final long n9 = n8 >>> 32;
        final long n10 = (long)array[n2 + 1] & 0xFFFFFFFFL;
        final long n11 = n9 + (n6 * n10 + n7 + ((long)array2[n3 + 1] & 0xFFFFFFFFL));
        array3[n4 + 1] = (int)n11;
        final long n12 = n11 >>> 32;
        final long n13 = (long)array[n2 + 2] & 0xFFFFFFFFL;
        final long n14 = n12 + (n6 * n13 + n10 + ((long)array2[n3 + 2] & 0xFFFFFFFFL));
        array3[n4 + 2] = (int)n14;
        final long n15 = n14 >>> 32;
        final long n16 = (long)array[n2 + 3] & 0xFFFFFFFFL;
        final long n17 = n15 + (n6 * n16 + n13 + ((long)array2[n3 + 3] & 0xFFFFFFFFL));
        array3[n4 + 3] = (int)n17;
        final long n18 = n17 >>> 32;
        final long n19 = (long)array[n2 + 4] & 0xFFFFFFFFL;
        final long n20 = n18 + (n6 * n19 + n16 + ((long)array2[n3 + 4] & 0xFFFFFFFFL));
        array3[n4 + 4] = (int)n20;
        final long n21 = n20 >>> 32;
        final long n22 = (long)array[n2 + 5] & 0xFFFFFFFFL;
        final long n23 = n21 + (n6 * n22 + n19 + ((long)array2[n3 + 5] & 0xFFFFFFFFL));
        array3[n4 + 5] = (int)n23;
        final long n24 = n23 >>> 32;
        final long n25 = (long)array[n2 + 6] & 0xFFFFFFFFL;
        final long n26 = n24 + (n6 * n25 + n22 + ((long)array2[n3 + 6] & 0xFFFFFFFFL));
        array3[n4 + 6] = (int)n26;
        final long n27 = n26 >>> 32;
        final long n28 = (long)array[n2 + 7] & 0xFFFFFFFFL;
        final long n29 = n27 + (n6 * n28 + n25 + ((long)array2[n3 + 7] & 0xFFFFFFFFL));
        array3[n4 + 7] = (int)n29;
        return (n29 >>> 32) + n28;
    }
    
    public static int mulByWord(final int n, final int[] array) {
        final long n2 = 0L;
        final long n3 = (long)n & 0xFFFFFFFFL;
        final long n4 = n2 + n3 * ((long)array[0] & 0xFFFFFFFFL);
        array[0] = (int)n4;
        final long n5 = (n4 >>> 32) + n3 * ((long)array[1] & 0xFFFFFFFFL);
        array[1] = (int)n5;
        final long n6 = (n5 >>> 32) + n3 * ((long)array[2] & 0xFFFFFFFFL);
        array[2] = (int)n6;
        final long n7 = (n6 >>> 32) + n3 * ((long)array[3] & 0xFFFFFFFFL);
        array[3] = (int)n7;
        final long n8 = (n7 >>> 32) + n3 * ((long)array[4] & 0xFFFFFFFFL);
        array[4] = (int)n8;
        final long n9 = (n8 >>> 32) + n3 * ((long)array[5] & 0xFFFFFFFFL);
        array[5] = (int)n9;
        final long n10 = (n9 >>> 32) + n3 * ((long)array[6] & 0xFFFFFFFFL);
        array[6] = (int)n10;
        final long n11 = (n10 >>> 32) + n3 * ((long)array[7] & 0xFFFFFFFFL);
        array[7] = (int)n11;
        return (int)(n11 >>> 32);
    }
    
    public static int mulByWordAddTo(final int n, final int[] array, final int[] array2) {
        final long n2 = 0L;
        final long n3 = (long)n & 0xFFFFFFFFL;
        final long n4 = n2 + (n3 * ((long)array2[0] & 0xFFFFFFFFL) + ((long)array[0] & 0xFFFFFFFFL));
        array2[0] = (int)n4;
        final long n5 = (n4 >>> 32) + (n3 * ((long)array2[1] & 0xFFFFFFFFL) + ((long)array[1] & 0xFFFFFFFFL));
        array2[1] = (int)n5;
        final long n6 = (n5 >>> 32) + (n3 * ((long)array2[2] & 0xFFFFFFFFL) + ((long)array[2] & 0xFFFFFFFFL));
        array2[2] = (int)n6;
        final long n7 = (n6 >>> 32) + (n3 * ((long)array2[3] & 0xFFFFFFFFL) + ((long)array[3] & 0xFFFFFFFFL));
        array2[3] = (int)n7;
        final long n8 = (n7 >>> 32) + (n3 * ((long)array2[4] & 0xFFFFFFFFL) + ((long)array[4] & 0xFFFFFFFFL));
        array2[4] = (int)n8;
        final long n9 = (n8 >>> 32) + (n3 * ((long)array2[5] & 0xFFFFFFFFL) + ((long)array[5] & 0xFFFFFFFFL));
        array2[5] = (int)n9;
        final long n10 = (n9 >>> 32) + (n3 * ((long)array2[6] & 0xFFFFFFFFL) + ((long)array[6] & 0xFFFFFFFFL));
        array2[6] = (int)n10;
        final long n11 = (n10 >>> 32) + (n3 * ((long)array2[7] & 0xFFFFFFFFL) + ((long)array[7] & 0xFFFFFFFFL));
        array2[7] = (int)n11;
        return (int)(n11 >>> 32);
    }
    
    public static int mulWordAddTo(final int n, final int[] array, final int n2, final int[] array2, final int n3) {
        final long n4 = 0L;
        final long n5 = (long)n & 0xFFFFFFFFL;
        final long n6 = n4 + (n5 * ((long)array[n2 + 0] & 0xFFFFFFFFL) + ((long)array2[n3 + 0] & 0xFFFFFFFFL));
        array2[n3 + 0] = (int)n6;
        final long n7 = (n6 >>> 32) + (n5 * ((long)array[n2 + 1] & 0xFFFFFFFFL) + ((long)array2[n3 + 1] & 0xFFFFFFFFL));
        array2[n3 + 1] = (int)n7;
        final long n8 = (n7 >>> 32) + (n5 * ((long)array[n2 + 2] & 0xFFFFFFFFL) + ((long)array2[n3 + 2] & 0xFFFFFFFFL));
        array2[n3 + 2] = (int)n8;
        final long n9 = (n8 >>> 32) + (n5 * ((long)array[n2 + 3] & 0xFFFFFFFFL) + ((long)array2[n3 + 3] & 0xFFFFFFFFL));
        array2[n3 + 3] = (int)n9;
        final long n10 = (n9 >>> 32) + (n5 * ((long)array[n2 + 4] & 0xFFFFFFFFL) + ((long)array2[n3 + 4] & 0xFFFFFFFFL));
        array2[n3 + 4] = (int)n10;
        final long n11 = (n10 >>> 32) + (n5 * ((long)array[n2 + 5] & 0xFFFFFFFFL) + ((long)array2[n3 + 5] & 0xFFFFFFFFL));
        array2[n3 + 5] = (int)n11;
        final long n12 = (n11 >>> 32) + (n5 * ((long)array[n2 + 6] & 0xFFFFFFFFL) + ((long)array2[n3 + 6] & 0xFFFFFFFFL));
        array2[n3 + 6] = (int)n12;
        final long n13 = (n12 >>> 32) + (n5 * ((long)array[n2 + 7] & 0xFFFFFFFFL) + ((long)array2[n3 + 7] & 0xFFFFFFFFL));
        array2[n3 + 7] = (int)n13;
        return (int)(n13 >>> 32);
    }
    
    public static int mul33DWordAdd(final int n, final long n2, final int[] array, final int n3) {
        final long n4 = 0L;
        final long n5 = (long)n & 0xFFFFFFFFL;
        final long n6 = n2 & 0xFFFFFFFFL;
        final long n7 = n4 + (n5 * n6 + ((long)array[n3 + 0] & 0xFFFFFFFFL));
        array[n3 + 0] = (int)n7;
        final long n8 = n7 >>> 32;
        final long n9 = n2 >>> 32;
        final long n10 = n8 + (n5 * n9 + n6 + ((long)array[n3 + 1] & 0xFFFFFFFFL));
        array[n3 + 1] = (int)n10;
        final long n11 = (n10 >>> 32) + (n9 + ((long)array[n3 + 2] & 0xFFFFFFFFL));
        array[n3 + 2] = (int)n11;
        final long n12 = (n11 >>> 32) + ((long)array[n3 + 3] & 0xFFFFFFFFL);
        array[n3 + 3] = (int)n12;
        return (n12 >>> 32 == 0L) ? 0 : Nat.incAt(8, array, n3, 4);
    }
    
    public static int mul33WordAdd(final int n, final int n2, final int[] array, final int n3) {
        final long n4 = 0L;
        final long n5 = (long)n & 0xFFFFFFFFL;
        final long n6 = (long)n2 & 0xFFFFFFFFL;
        final long n7 = n4 + (n6 * n5 + ((long)array[n3 + 0] & 0xFFFFFFFFL));
        array[n3 + 0] = (int)n7;
        final long n8 = (n7 >>> 32) + (n6 + ((long)array[n3 + 1] & 0xFFFFFFFFL));
        array[n3 + 1] = (int)n8;
        final long n9 = (n8 >>> 32) + ((long)array[n3 + 2] & 0xFFFFFFFFL);
        array[n3 + 2] = (int)n9;
        return (n9 >>> 32 == 0L) ? 0 : Nat.incAt(8, array, n3, 3);
    }
    
    public static int mulWordDwordAdd(final int n, final long n2, final int[] array, final int n3) {
        final long n4 = 0L;
        final long n5 = (long)n & 0xFFFFFFFFL;
        final long n6 = n4 + (n5 * (n2 & 0xFFFFFFFFL) + ((long)array[n3 + 0] & 0xFFFFFFFFL));
        array[n3 + 0] = (int)n6;
        final long n7 = (n6 >>> 32) + (n5 * (n2 >>> 32) + ((long)array[n3 + 1] & 0xFFFFFFFFL));
        array[n3 + 1] = (int)n7;
        final long n8 = (n7 >>> 32) + ((long)array[n3 + 2] & 0xFFFFFFFFL);
        array[n3 + 2] = (int)n8;
        return (n8 >>> 32 == 0L) ? 0 : Nat.incAt(8, array, n3, 3);
    }
    
    public static int mulWord(final int n, final int[] array, final int[] array2, final int n2) {
        long n3 = 0L;
        final long n4 = (long)n & 0xFFFFFFFFL;
        int n5 = 0;
        do {
            final long n6 = n3 + n4 * ((long)array[n5] & 0xFFFFFFFFL);
            array2[n2 + n5] = (int)n6;
            n3 = n6 >>> 32;
        } while (++n5 < 8);
        return (int)n3;
    }
    
    public static void square(final int[] array, final int[] array2) {
        final long n = (long)array[0] & 0xFFFFFFFFL;
        int n2 = 0;
        int i = 7;
        int n3 = 16;
        do {
            final long n4 = (long)array[i--] & 0xFFFFFFFFL;
            final long n5 = n4 * n4;
            array2[--n3] = (n2 << 31 | (int)(n5 >>> 33));
            array2[--n3] = (int)(n5 >>> 1);
            n2 = (int)n5;
        } while (i > 0);
        final long n6 = n * n;
        final long n7 = ((long)(n2 << 31) & 0xFFFFFFFFL) | n6 >>> 33;
        array2[0] = (int)n6;
        final int n8 = (int)(n6 >>> 32) & 0x1;
        final long n9 = (long)array[1] & 0xFFFFFFFFL;
        final long n10 = (long)array2[2] & 0xFFFFFFFFL;
        final long n11 = n7 + n9 * n;
        final int n12 = (int)n11;
        array2[1] = (n12 << 1 | n8);
        final int n13 = n12 >>> 31;
        final long n14 = n10 + (n11 >>> 32);
        final long n15 = (long)array[2] & 0xFFFFFFFFL;
        final long n16 = (long)array2[3] & 0xFFFFFFFFL;
        final long n17 = (long)array2[4] & 0xFFFFFFFFL;
        final long n18 = n14 + n15 * n;
        final int n19 = (int)n18;
        array2[2] = (n19 << 1 | n13);
        final int n20 = n19 >>> 31;
        final long n21 = n16 + ((n18 >>> 32) + n15 * n9);
        final long n22 = n17 + (n21 >>> 32);
        final long n23 = n21 & 0xFFFFFFFFL;
        final long n24 = (long)array[3] & 0xFFFFFFFFL;
        final long n25 = ((long)array2[5] & 0xFFFFFFFFL) + (n22 >>> 32);
        final long n26 = n22 & 0xFFFFFFFFL;
        final long n27 = ((long)array2[6] & 0xFFFFFFFFL) + (n25 >>> 32);
        final long n28 = n25 & 0xFFFFFFFFL;
        final long n29 = n23 + n24 * n;
        final int n30 = (int)n29;
        array2[3] = (n30 << 1 | n20);
        final int n31 = n30 >>> 31;
        final long n32 = n26 + ((n29 >>> 32) + n24 * n9);
        final long n33 = n28 + ((n32 >>> 32) + n24 * n15);
        final long n34 = n32 & 0xFFFFFFFFL;
        final long n35 = n27 + (n33 >>> 32);
        final long n36 = n33 & 0xFFFFFFFFL;
        final long n37 = (long)array[4] & 0xFFFFFFFFL;
        final long n38 = ((long)array2[7] & 0xFFFFFFFFL) + (n35 >>> 32);
        final long n39 = n35 & 0xFFFFFFFFL;
        final long n40 = ((long)array2[8] & 0xFFFFFFFFL) + (n38 >>> 32);
        final long n41 = n38 & 0xFFFFFFFFL;
        final long n42 = n34 + n37 * n;
        final int n43 = (int)n42;
        array2[4] = (n43 << 1 | n31);
        final int n44 = n43 >>> 31;
        final long n45 = n36 + ((n42 >>> 32) + n37 * n9);
        final long n46 = n39 + ((n45 >>> 32) + n37 * n15);
        final long n47 = n45 & 0xFFFFFFFFL;
        final long n48 = n41 + ((n46 >>> 32) + n37 * n24);
        final long n49 = n46 & 0xFFFFFFFFL;
        final long n50 = n40 + (n48 >>> 32);
        final long n51 = n48 & 0xFFFFFFFFL;
        final long n52 = (long)array[5] & 0xFFFFFFFFL;
        final long n53 = ((long)array2[9] & 0xFFFFFFFFL) + (n50 >>> 32);
        final long n54 = n50 & 0xFFFFFFFFL;
        final long n55 = ((long)array2[10] & 0xFFFFFFFFL) + (n53 >>> 32);
        final long n56 = n53 & 0xFFFFFFFFL;
        final long n57 = n47 + n52 * n;
        final int n58 = (int)n57;
        array2[5] = (n58 << 1 | n44);
        final int n59 = n58 >>> 31;
        final long n60 = n49 + ((n57 >>> 32) + n52 * n9);
        final long n61 = n51 + ((n60 >>> 32) + n52 * n15);
        final long n62 = n60 & 0xFFFFFFFFL;
        final long n63 = n54 + ((n61 >>> 32) + n52 * n24);
        final long n64 = n61 & 0xFFFFFFFFL;
        final long n65 = n56 + ((n63 >>> 32) + n52 * n37);
        final long n66 = n63 & 0xFFFFFFFFL;
        final long n67 = n55 + (n65 >>> 32);
        final long n68 = n65 & 0xFFFFFFFFL;
        final long n69 = (long)array[6] & 0xFFFFFFFFL;
        final long n70 = ((long)array2[11] & 0xFFFFFFFFL) + (n67 >>> 32);
        final long n71 = n67 & 0xFFFFFFFFL;
        final long n72 = ((long)array2[12] & 0xFFFFFFFFL) + (n70 >>> 32);
        final long n73 = n70 & 0xFFFFFFFFL;
        final long n74 = n62 + n69 * n;
        final int n75 = (int)n74;
        array2[6] = (n75 << 1 | n59);
        final int n76 = n75 >>> 31;
        final long n77 = n64 + ((n74 >>> 32) + n69 * n9);
        final long n78 = n66 + ((n77 >>> 32) + n69 * n15);
        final long n79 = n77 & 0xFFFFFFFFL;
        final long n80 = n68 + ((n78 >>> 32) + n69 * n24);
        final long n81 = n78 & 0xFFFFFFFFL;
        final long n82 = n71 + ((n80 >>> 32) + n69 * n37);
        final long n83 = n80 & 0xFFFFFFFFL;
        final long n84 = n73 + ((n82 >>> 32) + n69 * n52);
        final long n85 = n82 & 0xFFFFFFFFL;
        final long n86 = n72 + (n84 >>> 32);
        final long n87 = n84 & 0xFFFFFFFFL;
        final long n88 = (long)array[7] & 0xFFFFFFFFL;
        final long n89 = ((long)array2[13] & 0xFFFFFFFFL) + (n86 >>> 32);
        final long n90 = n86 & 0xFFFFFFFFL;
        final long n91 = ((long)array2[14] & 0xFFFFFFFFL) + (n89 >>> 32);
        final long n92 = n89 & 0xFFFFFFFFL;
        final long n93 = n79 + n88 * n;
        final int n94 = (int)n93;
        array2[7] = (n94 << 1 | n76);
        final int n95 = n94 >>> 31;
        final long n96 = n81 + ((n93 >>> 32) + n88 * n9);
        final long n97 = n83 + ((n96 >>> 32) + n88 * n15);
        final long n98 = n85 + ((n97 >>> 32) + n88 * n24);
        final long n99 = n87 + ((n98 >>> 32) + n88 * n37);
        final long n100 = n90 + ((n99 >>> 32) + n88 * n52);
        final long n101 = n92 + ((n100 >>> 32) + n88 * n69);
        final long n102 = n91 + (n101 >>> 32);
        final int n103 = (int)n96;
        array2[8] = (n103 << 1 | n95);
        final int n104 = n103 >>> 31;
        final int n105 = (int)n97;
        array2[9] = (n105 << 1 | n104);
        final int n106 = n105 >>> 31;
        final int n107 = (int)n98;
        array2[10] = (n107 << 1 | n106);
        final int n108 = n107 >>> 31;
        final int n109 = (int)n99;
        array2[11] = (n109 << 1 | n108);
        final int n110 = n109 >>> 31;
        final int n111 = (int)n100;
        array2[12] = (n111 << 1 | n110);
        final int n112 = n111 >>> 31;
        final int n113 = (int)n101;
        array2[13] = (n113 << 1 | n112);
        final int n114 = n113 >>> 31;
        final int n115 = (int)n102;
        array2[14] = (n115 << 1 | n114);
        array2[15] = (array2[15] + (int)(n102 >>> 32) << 1 | n115 >>> 31);
    }
    
    public static void square(final int[] array, final int n, final int[] array2, final int n2) {
        final long n3 = (long)array[n + 0] & 0xFFFFFFFFL;
        int n4 = 0;
        int i = 7;
        int n5 = 16;
        do {
            final long n6 = (long)array[n + i--] & 0xFFFFFFFFL;
            final long n7 = n6 * n6;
            array2[n2 + --n5] = (n4 << 31 | (int)(n7 >>> 33));
            array2[n2 + --n5] = (int)(n7 >>> 1);
            n4 = (int)n7;
        } while (i > 0);
        final long n8 = n3 * n3;
        final long n9 = ((long)(n4 << 31) & 0xFFFFFFFFL) | n8 >>> 33;
        array2[n2 + 0] = (int)n8;
        final int n10 = (int)(n8 >>> 32) & 0x1;
        final long n11 = (long)array[n + 1] & 0xFFFFFFFFL;
        final long n12 = (long)array2[n2 + 2] & 0xFFFFFFFFL;
        final long n13 = n9 + n11 * n3;
        final int n14 = (int)n13;
        array2[n2 + 1] = (n14 << 1 | n10);
        final int n15 = n14 >>> 31;
        final long n16 = n12 + (n13 >>> 32);
        final long n17 = (long)array[n + 2] & 0xFFFFFFFFL;
        final long n18 = (long)array2[n2 + 3] & 0xFFFFFFFFL;
        final long n19 = (long)array2[n2 + 4] & 0xFFFFFFFFL;
        final long n20 = n16 + n17 * n3;
        final int n21 = (int)n20;
        array2[n2 + 2] = (n21 << 1 | n15);
        final int n22 = n21 >>> 31;
        final long n23 = n18 + ((n20 >>> 32) + n17 * n11);
        final long n24 = n19 + (n23 >>> 32);
        final long n25 = n23 & 0xFFFFFFFFL;
        final long n26 = (long)array[n + 3] & 0xFFFFFFFFL;
        final long n27 = ((long)array2[n2 + 5] & 0xFFFFFFFFL) + (n24 >>> 32);
        final long n28 = n24 & 0xFFFFFFFFL;
        final long n29 = ((long)array2[n2 + 6] & 0xFFFFFFFFL) + (n27 >>> 32);
        final long n30 = n27 & 0xFFFFFFFFL;
        final long n31 = n25 + n26 * n3;
        final int n32 = (int)n31;
        array2[n2 + 3] = (n32 << 1 | n22);
        final int n33 = n32 >>> 31;
        final long n34 = n28 + ((n31 >>> 32) + n26 * n11);
        final long n35 = n30 + ((n34 >>> 32) + n26 * n17);
        final long n36 = n34 & 0xFFFFFFFFL;
        final long n37 = n29 + (n35 >>> 32);
        final long n38 = n35 & 0xFFFFFFFFL;
        final long n39 = (long)array[n + 4] & 0xFFFFFFFFL;
        final long n40 = ((long)array2[n2 + 7] & 0xFFFFFFFFL) + (n37 >>> 32);
        final long n41 = n37 & 0xFFFFFFFFL;
        final long n42 = ((long)array2[n2 + 8] & 0xFFFFFFFFL) + (n40 >>> 32);
        final long n43 = n40 & 0xFFFFFFFFL;
        final long n44 = n36 + n39 * n3;
        final int n45 = (int)n44;
        array2[n2 + 4] = (n45 << 1 | n33);
        final int n46 = n45 >>> 31;
        final long n47 = n38 + ((n44 >>> 32) + n39 * n11);
        final long n48 = n41 + ((n47 >>> 32) + n39 * n17);
        final long n49 = n47 & 0xFFFFFFFFL;
        final long n50 = n43 + ((n48 >>> 32) + n39 * n26);
        final long n51 = n48 & 0xFFFFFFFFL;
        final long n52 = n42 + (n50 >>> 32);
        final long n53 = n50 & 0xFFFFFFFFL;
        final long n54 = (long)array[n + 5] & 0xFFFFFFFFL;
        final long n55 = ((long)array2[n2 + 9] & 0xFFFFFFFFL) + (n52 >>> 32);
        final long n56 = n52 & 0xFFFFFFFFL;
        final long n57 = ((long)array2[n2 + 10] & 0xFFFFFFFFL) + (n55 >>> 32);
        final long n58 = n55 & 0xFFFFFFFFL;
        final long n59 = n49 + n54 * n3;
        final int n60 = (int)n59;
        array2[n2 + 5] = (n60 << 1 | n46);
        final int n61 = n60 >>> 31;
        final long n62 = n51 + ((n59 >>> 32) + n54 * n11);
        final long n63 = n53 + ((n62 >>> 32) + n54 * n17);
        final long n64 = n62 & 0xFFFFFFFFL;
        final long n65 = n56 + ((n63 >>> 32) + n54 * n26);
        final long n66 = n63 & 0xFFFFFFFFL;
        final long n67 = n58 + ((n65 >>> 32) + n54 * n39);
        final long n68 = n65 & 0xFFFFFFFFL;
        final long n69 = n57 + (n67 >>> 32);
        final long n70 = n67 & 0xFFFFFFFFL;
        final long n71 = (long)array[n + 6] & 0xFFFFFFFFL;
        final long n72 = ((long)array2[n2 + 11] & 0xFFFFFFFFL) + (n69 >>> 32);
        final long n73 = n69 & 0xFFFFFFFFL;
        final long n74 = ((long)array2[n2 + 12] & 0xFFFFFFFFL) + (n72 >>> 32);
        final long n75 = n72 & 0xFFFFFFFFL;
        final long n76 = n64 + n71 * n3;
        final int n77 = (int)n76;
        array2[n2 + 6] = (n77 << 1 | n61);
        final int n78 = n77 >>> 31;
        final long n79 = n66 + ((n76 >>> 32) + n71 * n11);
        final long n80 = n68 + ((n79 >>> 32) + n71 * n17);
        final long n81 = n79 & 0xFFFFFFFFL;
        final long n82 = n70 + ((n80 >>> 32) + n71 * n26);
        final long n83 = n80 & 0xFFFFFFFFL;
        final long n84 = n73 + ((n82 >>> 32) + n71 * n39);
        final long n85 = n82 & 0xFFFFFFFFL;
        final long n86 = n75 + ((n84 >>> 32) + n71 * n54);
        final long n87 = n84 & 0xFFFFFFFFL;
        final long n88 = n74 + (n86 >>> 32);
        final long n89 = n86 & 0xFFFFFFFFL;
        final long n90 = (long)array[n + 7] & 0xFFFFFFFFL;
        final long n91 = ((long)array2[n2 + 13] & 0xFFFFFFFFL) + (n88 >>> 32);
        final long n92 = n88 & 0xFFFFFFFFL;
        final long n93 = ((long)array2[n2 + 14] & 0xFFFFFFFFL) + (n91 >>> 32);
        final long n94 = n91 & 0xFFFFFFFFL;
        final long n95 = n81 + n90 * n3;
        final int n96 = (int)n95;
        array2[n2 + 7] = (n96 << 1 | n78);
        final int n97 = n96 >>> 31;
        final long n98 = n83 + ((n95 >>> 32) + n90 * n11);
        final long n99 = n85 + ((n98 >>> 32) + n90 * n17);
        final long n100 = n87 + ((n99 >>> 32) + n90 * n26);
        final long n101 = n89 + ((n100 >>> 32) + n90 * n39);
        final long n102 = n92 + ((n101 >>> 32) + n90 * n54);
        final long n103 = n94 + ((n102 >>> 32) + n90 * n71);
        final long n104 = n93 + (n103 >>> 32);
        final int n105 = (int)n98;
        array2[n2 + 8] = (n105 << 1 | n97);
        final int n106 = n105 >>> 31;
        final int n107 = (int)n99;
        array2[n2 + 9] = (n107 << 1 | n106);
        final int n108 = n107 >>> 31;
        final int n109 = (int)n100;
        array2[n2 + 10] = (n109 << 1 | n108);
        final int n110 = n109 >>> 31;
        final int n111 = (int)n101;
        array2[n2 + 11] = (n111 << 1 | n110);
        final int n112 = n111 >>> 31;
        final int n113 = (int)n102;
        array2[n2 + 12] = (n113 << 1 | n112);
        final int n114 = n113 >>> 31;
        final int n115 = (int)n103;
        array2[n2 + 13] = (n115 << 1 | n114);
        final int n116 = n115 >>> 31;
        final int n117 = (int)n104;
        array2[n2 + 14] = (n117 << 1 | n116);
        array2[n2 + 15] = (array2[n2 + 15] + (int)(n104 >>> 32) << 1 | n117 >>> 31);
    }
    
    public static int sub(final int[] array, final int[] array2, final int[] array3) {
        final long n = 0L + (((long)array[0] & 0xFFFFFFFFL) - ((long)array2[0] & 0xFFFFFFFFL));
        array3[0] = (int)n;
        final long n2 = (n >> 32) + (((long)array[1] & 0xFFFFFFFFL) - ((long)array2[1] & 0xFFFFFFFFL));
        array3[1] = (int)n2;
        final long n3 = (n2 >> 32) + (((long)array[2] & 0xFFFFFFFFL) - ((long)array2[2] & 0xFFFFFFFFL));
        array3[2] = (int)n3;
        final long n4 = (n3 >> 32) + (((long)array[3] & 0xFFFFFFFFL) - ((long)array2[3] & 0xFFFFFFFFL));
        array3[3] = (int)n4;
        final long n5 = (n4 >> 32) + (((long)array[4] & 0xFFFFFFFFL) - ((long)array2[4] & 0xFFFFFFFFL));
        array3[4] = (int)n5;
        final long n6 = (n5 >> 32) + (((long)array[5] & 0xFFFFFFFFL) - ((long)array2[5] & 0xFFFFFFFFL));
        array3[5] = (int)n6;
        final long n7 = (n6 >> 32) + (((long)array[6] & 0xFFFFFFFFL) - ((long)array2[6] & 0xFFFFFFFFL));
        array3[6] = (int)n7;
        final long n8 = (n7 >> 32) + (((long)array[7] & 0xFFFFFFFFL) - ((long)array2[7] & 0xFFFFFFFFL));
        array3[7] = (int)n8;
        return (int)(n8 >> 32);
    }
    
    public static int sub(final int[] array, final int n, final int[] array2, final int n2, final int[] array3, final int n3) {
        final long n4 = 0L + (((long)array[n + 0] & 0xFFFFFFFFL) - ((long)array2[n2 + 0] & 0xFFFFFFFFL));
        array3[n3 + 0] = (int)n4;
        final long n5 = (n4 >> 32) + (((long)array[n + 1] & 0xFFFFFFFFL) - ((long)array2[n2 + 1] & 0xFFFFFFFFL));
        array3[n3 + 1] = (int)n5;
        final long n6 = (n5 >> 32) + (((long)array[n + 2] & 0xFFFFFFFFL) - ((long)array2[n2 + 2] & 0xFFFFFFFFL));
        array3[n3 + 2] = (int)n6;
        final long n7 = (n6 >> 32) + (((long)array[n + 3] & 0xFFFFFFFFL) - ((long)array2[n2 + 3] & 0xFFFFFFFFL));
        array3[n3 + 3] = (int)n7;
        final long n8 = (n7 >> 32) + (((long)array[n + 4] & 0xFFFFFFFFL) - ((long)array2[n2 + 4] & 0xFFFFFFFFL));
        array3[n3 + 4] = (int)n8;
        final long n9 = (n8 >> 32) + (((long)array[n + 5] & 0xFFFFFFFFL) - ((long)array2[n2 + 5] & 0xFFFFFFFFL));
        array3[n3 + 5] = (int)n9;
        final long n10 = (n9 >> 32) + (((long)array[n + 6] & 0xFFFFFFFFL) - ((long)array2[n2 + 6] & 0xFFFFFFFFL));
        array3[n3 + 6] = (int)n10;
        final long n11 = (n10 >> 32) + (((long)array[n + 7] & 0xFFFFFFFFL) - ((long)array2[n2 + 7] & 0xFFFFFFFFL));
        array3[n3 + 7] = (int)n11;
        return (int)(n11 >> 32);
    }
    
    public static int subBothFrom(final int[] array, final int[] array2, final int[] array3) {
        final long n = 0L + (((long)array3[0] & 0xFFFFFFFFL) - ((long)array[0] & 0xFFFFFFFFL) - ((long)array2[0] & 0xFFFFFFFFL));
        array3[0] = (int)n;
        final long n2 = (n >> 32) + (((long)array3[1] & 0xFFFFFFFFL) - ((long)array[1] & 0xFFFFFFFFL) - ((long)array2[1] & 0xFFFFFFFFL));
        array3[1] = (int)n2;
        final long n3 = (n2 >> 32) + (((long)array3[2] & 0xFFFFFFFFL) - ((long)array[2] & 0xFFFFFFFFL) - ((long)array2[2] & 0xFFFFFFFFL));
        array3[2] = (int)n3;
        final long n4 = (n3 >> 32) + (((long)array3[3] & 0xFFFFFFFFL) - ((long)array[3] & 0xFFFFFFFFL) - ((long)array2[3] & 0xFFFFFFFFL));
        array3[3] = (int)n4;
        final long n5 = (n4 >> 32) + (((long)array3[4] & 0xFFFFFFFFL) - ((long)array[4] & 0xFFFFFFFFL) - ((long)array2[4] & 0xFFFFFFFFL));
        array3[4] = (int)n5;
        final long n6 = (n5 >> 32) + (((long)array3[5] & 0xFFFFFFFFL) - ((long)array[5] & 0xFFFFFFFFL) - ((long)array2[5] & 0xFFFFFFFFL));
        array3[5] = (int)n6;
        final long n7 = (n6 >> 32) + (((long)array3[6] & 0xFFFFFFFFL) - ((long)array[6] & 0xFFFFFFFFL) - ((long)array2[6] & 0xFFFFFFFFL));
        array3[6] = (int)n7;
        final long n8 = (n7 >> 32) + (((long)array3[7] & 0xFFFFFFFFL) - ((long)array[7] & 0xFFFFFFFFL) - ((long)array2[7] & 0xFFFFFFFFL));
        array3[7] = (int)n8;
        return (int)(n8 >> 32);
    }
    
    public static int subFrom(final int[] array, final int[] array2) {
        final long n = 0L + (((long)array2[0] & 0xFFFFFFFFL) - ((long)array[0] & 0xFFFFFFFFL));
        array2[0] = (int)n;
        final long n2 = (n >> 32) + (((long)array2[1] & 0xFFFFFFFFL) - ((long)array[1] & 0xFFFFFFFFL));
        array2[1] = (int)n2;
        final long n3 = (n2 >> 32) + (((long)array2[2] & 0xFFFFFFFFL) - ((long)array[2] & 0xFFFFFFFFL));
        array2[2] = (int)n3;
        final long n4 = (n3 >> 32) + (((long)array2[3] & 0xFFFFFFFFL) - ((long)array[3] & 0xFFFFFFFFL));
        array2[3] = (int)n4;
        final long n5 = (n4 >> 32) + (((long)array2[4] & 0xFFFFFFFFL) - ((long)array[4] & 0xFFFFFFFFL));
        array2[4] = (int)n5;
        final long n6 = (n5 >> 32) + (((long)array2[5] & 0xFFFFFFFFL) - ((long)array[5] & 0xFFFFFFFFL));
        array2[5] = (int)n6;
        final long n7 = (n6 >> 32) + (((long)array2[6] & 0xFFFFFFFFL) - ((long)array[6] & 0xFFFFFFFFL));
        array2[6] = (int)n7;
        final long n8 = (n7 >> 32) + (((long)array2[7] & 0xFFFFFFFFL) - ((long)array[7] & 0xFFFFFFFFL));
        array2[7] = (int)n8;
        return (int)(n8 >> 32);
    }
    
    public static int subFrom(final int[] array, final int[] array2, final int n) {
        final long n2 = ((long)n & 0xFFFFFFFFL) + (((long)array2[0] & 0xFFFFFFFFL) - ((long)array[0] & 0xFFFFFFFFL));
        array2[0] = (int)n2;
        final long n3 = (n2 >> 32) + (((long)array2[1] & 0xFFFFFFFFL) - ((long)array[1] & 0xFFFFFFFFL));
        array2[1] = (int)n3;
        final long n4 = (n3 >> 32) + (((long)array2[2] & 0xFFFFFFFFL) - ((long)array[2] & 0xFFFFFFFFL));
        array2[2] = (int)n4;
        final long n5 = (n4 >> 32) + (((long)array2[3] & 0xFFFFFFFFL) - ((long)array[3] & 0xFFFFFFFFL));
        array2[3] = (int)n5;
        final long n6 = (n5 >> 32) + (((long)array2[4] & 0xFFFFFFFFL) - ((long)array[4] & 0xFFFFFFFFL));
        array2[4] = (int)n6;
        final long n7 = (n6 >> 32) + (((long)array2[5] & 0xFFFFFFFFL) - ((long)array[5] & 0xFFFFFFFFL));
        array2[5] = (int)n7;
        final long n8 = (n7 >> 32) + (((long)array2[6] & 0xFFFFFFFFL) - ((long)array[6] & 0xFFFFFFFFL));
        array2[6] = (int)n8;
        final long n9 = (n8 >> 32) + (((long)array2[7] & 0xFFFFFFFFL) - ((long)array[7] & 0xFFFFFFFFL));
        array2[7] = (int)n9;
        return (int)(n9 >> 32);
    }
    
    public static int subFrom(final int[] array, final int n, final int[] array2, final int n2) {
        final long n3 = 0L + (((long)array2[n2 + 0] & 0xFFFFFFFFL) - ((long)array[n + 0] & 0xFFFFFFFFL));
        array2[n2 + 0] = (int)n3;
        final long n4 = (n3 >> 32) + (((long)array2[n2 + 1] & 0xFFFFFFFFL) - ((long)array[n + 1] & 0xFFFFFFFFL));
        array2[n2 + 1] = (int)n4;
        final long n5 = (n4 >> 32) + (((long)array2[n2 + 2] & 0xFFFFFFFFL) - ((long)array[n + 2] & 0xFFFFFFFFL));
        array2[n2 + 2] = (int)n5;
        final long n6 = (n5 >> 32) + (((long)array2[n2 + 3] & 0xFFFFFFFFL) - ((long)array[n + 3] & 0xFFFFFFFFL));
        array2[n2 + 3] = (int)n6;
        final long n7 = (n6 >> 32) + (((long)array2[n2 + 4] & 0xFFFFFFFFL) - ((long)array[n + 4] & 0xFFFFFFFFL));
        array2[n2 + 4] = (int)n7;
        final long n8 = (n7 >> 32) + (((long)array2[n2 + 5] & 0xFFFFFFFFL) - ((long)array[n + 5] & 0xFFFFFFFFL));
        array2[n2 + 5] = (int)n8;
        final long n9 = (n8 >> 32) + (((long)array2[n2 + 6] & 0xFFFFFFFFL) - ((long)array[n + 6] & 0xFFFFFFFFL));
        array2[n2 + 6] = (int)n9;
        final long n10 = (n9 >> 32) + (((long)array2[n2 + 7] & 0xFFFFFFFFL) - ((long)array[n + 7] & 0xFFFFFFFFL));
        array2[n2 + 7] = (int)n10;
        return (int)(n10 >> 32);
    }
    
    public static int subFrom(final int[] array, final int n, final int[] array2, final int n2, final int n3) {
        final long n4 = ((long)n3 & 0xFFFFFFFFL) + (((long)array2[n2 + 0] & 0xFFFFFFFFL) - ((long)array[n + 0] & 0xFFFFFFFFL));
        array2[n2 + 0] = (int)n4;
        final long n5 = (n4 >> 32) + (((long)array2[n2 + 1] & 0xFFFFFFFFL) - ((long)array[n + 1] & 0xFFFFFFFFL));
        array2[n2 + 1] = (int)n5;
        final long n6 = (n5 >> 32) + (((long)array2[n2 + 2] & 0xFFFFFFFFL) - ((long)array[n + 2] & 0xFFFFFFFFL));
        array2[n2 + 2] = (int)n6;
        final long n7 = (n6 >> 32) + (((long)array2[n2 + 3] & 0xFFFFFFFFL) - ((long)array[n + 3] & 0xFFFFFFFFL));
        array2[n2 + 3] = (int)n7;
        final long n8 = (n7 >> 32) + (((long)array2[n2 + 4] & 0xFFFFFFFFL) - ((long)array[n + 4] & 0xFFFFFFFFL));
        array2[n2 + 4] = (int)n8;
        final long n9 = (n8 >> 32) + (((long)array2[n2 + 5] & 0xFFFFFFFFL) - ((long)array[n + 5] & 0xFFFFFFFFL));
        array2[n2 + 5] = (int)n9;
        final long n10 = (n9 >> 32) + (((long)array2[n2 + 6] & 0xFFFFFFFFL) - ((long)array[n + 6] & 0xFFFFFFFFL));
        array2[n2 + 6] = (int)n10;
        final long n11 = (n10 >> 32) + (((long)array2[n2 + 7] & 0xFFFFFFFFL) - ((long)array[n + 7] & 0xFFFFFFFFL));
        array2[n2 + 7] = (int)n11;
        return (int)(n11 >> 32);
    }
    
    public static BigInteger toBigInteger(final int[] array) {
        final byte[] magnitude = new byte[32];
        for (int i = 0; i < 8; ++i) {
            final int n = array[i];
            if (n != 0) {
                Pack.intToBigEndian(n, magnitude, 7 - i << 2);
            }
        }
        return new BigInteger(1, magnitude);
    }
    
    public static BigInteger toBigInteger64(final long[] array) {
        final byte[] magnitude = new byte[32];
        for (int i = 0; i < 4; ++i) {
            final long n = array[i];
            if (n != 0L) {
                Pack.longToBigEndian(n, magnitude, 3 - i << 3);
            }
        }
        return new BigInteger(1, magnitude);
    }
    
    public static void zero(final int[] array) {
        array[1] = (array[0] = 0);
        array[3] = (array[2] = 0);
        array[5] = (array[4] = 0);
        array[7] = (array[6] = 0);
    }
}