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

package org.bouncycastle.pqc.crypto.rainbow;

import java.security.SecureRandom;
import org.bouncycastle.crypto.Digest;
import org.bouncycastle.util.Arrays;

class RainbowUtil
{
    public static short[] convertArray(final byte[] array) {
        final short[] array2 = new short[array.length];
        for (int i = 0; i < array.length; ++i) {
            array2[i] = (short)(array[i] & 0xFF);
        }
        return array2;
    }
    
    public static byte[] convertArray(final short[] array) {
        final byte[] array2 = new byte[array.length];
        for (int i = 0; i < array.length; ++i) {
            array2[i] = (byte)array[i];
        }
        return array2;
    }
    
    public static boolean equals(final short[] array, final short[] array2) {
        if (array.length != array2.length) {
            return false;
        }
        boolean b = true;
        for (int i = array.length - 1; i >= 0; --i) {
            b &= (array[i] == array2[i]);
        }
        return b;
    }
    
    public static boolean equals(final short[][] array, final short[][] array2) {
        if (array.length != array2.length) {
            return false;
        }
        boolean b = true;
        for (int i = array.length - 1; i >= 0; --i) {
            b &= equals(array[i], array2[i]);
        }
        return b;
    }
    
    public static boolean equals(final short[][][] array, final short[][][] array2) {
        if (array.length != array2.length) {
            return false;
        }
        boolean b = true;
        for (int i = array.length - 1; i >= 0; --i) {
            b &= equals(array[i], array2[i]);
        }
        return b;
    }
    
    public static short[][] cloneArray(final short[][] array) {
        final short[][] array2 = new short[array.length][];
        for (int i = 0; i < array.length; ++i) {
            array2[i] = Arrays.clone(array[i]);
        }
        return array2;
    }
    
    public static short[][][] cloneArray(final short[][][] array) {
        final short[][][] array2 = new short[array.length][array[0].length][];
        for (int i = 0; i < array.length; ++i) {
            for (int j = 0; j < array[0].length; ++j) {
                array2[i][j] = Arrays.clone(array[i][j]);
            }
        }
        return array2;
    }
    
    public static byte[] hash(final Digest digest, final byte[] array, final byte[] array2, final byte[] array3) {
        final int digestSize = digest.getDigestSize();
        digest.update(array, 0, array.length);
        digest.update(array2, 0, array2.length);
        if (array3.length == digestSize) {
            digest.doFinal(array3, 0);
            return array3;
        }
        final byte[] array4 = new byte[digestSize];
        digest.doFinal(array4, 0);
        if (array3.length < digestSize) {
            System.arraycopy(array4, 0, array3, 0, array3.length);
            return array3;
        }
        System.arraycopy(array4, 0, array3, 0, array4.length);
        int i;
        int n;
        for (i = array3.length - digestSize, n = digestSize; i >= array4.length; i -= array4.length, n += array4.length) {
            digest.update(array4, 0, array4.length);
            digest.doFinal(array4, 0);
            System.arraycopy(array4, 0, array3, n, array4.length);
        }
        if (i > 0) {
            digest.update(array4, 0, array4.length);
            digest.doFinal(array4, 0);
            System.arraycopy(array4, 0, array3, n, i);
        }
        return array3;
    }
    
    public static byte[] hash(final Digest digest, final byte[] array, final int n) {
        final int digestSize = digest.getDigestSize();
        digest.update(array, 0, array.length);
        byte[] array2 = new byte[digestSize];
        digest.doFinal(array2, 0);
        if (n == digestSize) {
            return array2;
        }
        if (n < digestSize) {
            return Arrays.copyOf(array2, n);
        }
        byte[] array3 = Arrays.copyOf(array2, digestSize);
        int i;
        for (i = n - digestSize; i >= digestSize; i -= digestSize) {
            digest.update(array2, 0, digestSize);
            array2 = new byte[digestSize];
            digest.doFinal(array2, 0);
            array3 = Arrays.concatenate(array3, array2);
        }
        if (i > 0) {
            digest.update(array2, 0, digestSize);
            final byte[] array4 = new byte[digestSize];
            digest.doFinal(array4, 0);
            final int length = array3.length;
            array3 = Arrays.copyOf(array3, length + i);
            System.arraycopy(array4, 0, array3, length, i);
        }
        return array3;
    }
    
    public static short[][] generate_random_2d(final SecureRandom secureRandom, final int n, final int n2) {
        final byte[] bytes = new byte[n * n2];
        secureRandom.nextBytes(bytes);
        final short[][] array = new short[n][n2];
        for (int i = 0; i < n2; ++i) {
            for (int j = 0; j < n; ++j) {
                array[j][i] = (short)(bytes[i * n + j] & 0xFF);
            }
        }
        return array;
    }
    
    public static short[][][] generate_random(final SecureRandom secureRandom, final int n, final int n2, final int n3, final boolean b) {
        int n4;
        if (b) {
            n4 = n * (n2 * (n2 + 1) / 2);
        }
        else {
            n4 = n * n2 * n3;
        }
        final byte[] bytes = new byte[n4];
        secureRandom.nextBytes(bytes);
        int n5 = 0;
        final short[][][] array = new short[n][n2][n3];
        for (int i = 0; i < n2; ++i) {
            for (int j = 0; j < n3; ++j) {
                for (int k = 0; k < n; ++k) {
                    if (!b || i <= j) {
                        array[k][i][j] = (short)(bytes[n5++] & 0xFF);
                    }
                }
            }
        }
        return array;
    }
    
    public static byte[] getEncoded(final short[][] array) {
        final int length = array.length;
        final int length2 = array[0].length;
        final byte[] array2 = new byte[length * length2];
        for (int i = 0; i < length2; ++i) {
            for (int j = 0; j < length; ++j) {
                array2[i * length + j] = (byte)array[j][i];
            }
        }
        return array2;
    }
    
    public static byte[] getEncoded(final short[][][] array, final boolean b) {
        final int length = array.length;
        final int length2 = array[0].length;
        final int length3 = array[0][0].length;
        int n;
        if (b) {
            n = length * (length2 * (length2 + 1) / 2);
        }
        else {
            n = length * length2 * length3;
        }
        final byte[] array2 = new byte[n];
        int n2 = 0;
        for (int i = 0; i < length2; ++i) {
            for (int j = 0; j < length3; ++j) {
                for (int k = 0; k < length; ++k) {
                    if (!b || i <= j) {
                        array2[n2] = (byte)array[k][i][j];
                        ++n2;
                    }
                }
            }
        }
        return array2;
    }
    
    public static int loadEncoded(final short[][] array, final byte[] array2, final int n) {
        final int length = array.length;
        final int length2 = array[0].length;
        for (int i = 0; i < length2; ++i) {
            for (int j = 0; j < length; ++j) {
                array[j][i] = (short)(array2[n + i * length + j] & 0xFF);
            }
        }
        return length * length2;
    }
    
    public static int loadEncoded(final short[][][] array, final byte[] array2, final int n, final boolean b) {
        final int length = array.length;
        final int length2 = array[0].length;
        final int length3 = array[0][0].length;
        int n2 = 0;
        for (int i = 0; i < length2; ++i) {
            for (int j = 0; j < length3; ++j) {
                for (int k = 0; k < length; ++k) {
                    if (!b || i <= j) {
                        array[k][i][j] = (short)(array2[n + n2++] & 0xFF);
                    }
                }
            }
        }
        return n2;
    }
}