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

package org.bouncycastle.math.raw;

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

public abstract class Nat448
{
    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];
        array2[4] = array[4];
        array2[5] = array[5];
        array2[6] = array[6];
    }
    
    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];
        array2[n2 + 4] = array[n + 4];
        array2[n2 + 5] = array[n + 5];
        array2[n2 + 6] = array[n + 6];
    }
    
    public static long[] create64() {
        return new long[7];
    }
    
    public static long[] createExt64() {
        return new long[14];
    }
    
    public static boolean eq64(final long[] array, final long[] array2) {
        for (int i = 6; i >= 0; --i) {
            if (array[i] != array2[i]) {
                return false;
            }
        }
        return true;
    }
    
    public static long[] fromBigInteger64(BigInteger shiftRight) {
        if (shiftRight.signum() < 0 || shiftRight.bitLength() > 448) {
            throw new IllegalArgumentException();
        }
        final long[] create64 = create64();
        for (int i = 0; i < 7; ++i) {
            create64[i] = shiftRight.longValue();
            shiftRight = shiftRight.shiftRight(64);
        }
        return create64;
    }
    
    public static boolean isOne64(final long[] array) {
        if (array[0] != 1L) {
            return false;
        }
        for (int i = 1; i < 7; ++i) {
            if (array[i] != 0L) {
                return false;
            }
        }
        return true;
    }
    
    public static boolean isZero64(final long[] array) {
        for (int i = 0; i < 7; ++i) {
            if (array[i] != 0L) {
                return false;
            }
        }
        return true;
    }
    
    public static void mul(final int[] array, final int[] array2, final int[] array3) {
        Nat224.mul(array, array2, array3);
        Nat224.mul(array, 7, array2, 7, array3, 14);
        final int addToEachOther = Nat224.addToEachOther(array3, 7, array3, 14);
        final int n = addToEachOther + Nat224.addTo(array3, 21, array3, 14, addToEachOther + Nat224.addTo(array3, 0, array3, 7, 0));
        final int[] create = Nat224.create();
        final int[] create2 = Nat224.create();
        final boolean b = Nat224.diff(array, 7, array, 0, create, 0) != Nat224.diff(array2, 7, array2, 0, create2, 0);
        final int[] ext = Nat224.createExt();
        Nat224.mul(create, create2, ext);
        Nat.addWordAt(28, n + (b ? Nat.addTo(14, ext, 0, array3, 7) : Nat.subFrom(14, ext, 0, array3, 7)), array3, 21);
    }
    
    public static void square(final int[] array, final int[] array2) {
        Nat224.square(array, array2);
        Nat224.square(array, 7, array2, 14);
        final int addToEachOther = Nat224.addToEachOther(array2, 7, array2, 14);
        final int n = addToEachOther + Nat224.addTo(array2, 21, array2, 14, addToEachOther + Nat224.addTo(array2, 0, array2, 7, 0));
        final int[] create = Nat224.create();
        Nat224.diff(array, 7, array, 0, create, 0);
        final int[] ext = Nat224.createExt();
        Nat224.square(create, ext);
        Nat.addWordAt(28, n + Nat.subFrom(14, ext, 0, array2, 7), array2, 21);
    }
    
    public static BigInteger toBigInteger64(final long[] array) {
        final byte[] magnitude = new byte[56];
        for (int i = 0; i < 7; ++i) {
            final long n = array[i];
            if (n != 0L) {
                Pack.longToBigEndian(n, magnitude, 6 - i << 3);
            }
        }
        return new BigInteger(1, magnitude);
    }
}