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

package org.bouncycastle.pqc.crypto.saber;

class Utils
{
    private final int SABER_N;
    private final int SABER_L;
    private final int SABER_ET;
    private final int SABER_POLYBYTES;
    private final int SABER_EP;
    private final int SABER_KEYBYTES;
    private final boolean usingEffectiveMasking;
    
    public Utils(final SABEREngine saberEngine) {
        this.SABER_N = saberEngine.getSABER_N();
        this.SABER_L = saberEngine.getSABER_L();
        this.SABER_ET = saberEngine.getSABER_ET();
        this.SABER_POLYBYTES = saberEngine.getSABER_POLYBYTES();
        this.SABER_EP = saberEngine.getSABER_EP();
        this.SABER_KEYBYTES = saberEngine.getSABER_KEYBYTES();
        this.usingEffectiveMasking = saberEngine.usingEffectiveMasking;
    }
    
    public void POLT2BS(final byte[] array, final int n, final short[] array2) {
        if (this.SABER_ET == 3) {
            for (int i = 0; i < this.SABER_N / 8; i = (short)(i + 1)) {
                final short n2 = (short)(3 * i);
                final short n3 = (short)(8 * i);
                array[n + n2 + 0] = (byte)((array2[n3 + 0] & 0x7) | (array2[n3 + 1] & 0x7) << 3 | (array2[n3 + 2] & 0x3) << 6);
                array[n + n2 + 1] = (byte)((array2[n3 + 2] >> 2 & 0x1) | (array2[n3 + 3] & 0x7) << 1 | (array2[n3 + 4] & 0x7) << 4 | (array2[n3 + 5] & 0x1) << 7);
                array[n + n2 + 2] = (byte)((array2[n3 + 5] >> 1 & 0x3) | (array2[n3 + 6] & 0x7) << 2 | (array2[n3 + 7] & 0x7) << 5);
            }
        }
        else if (this.SABER_ET == 4) {
            for (int j = 0; j < this.SABER_N / 2; j = (short)(j + 1)) {
                final int n4 = j;
                final short n5 = (short)(2 * j);
                array[n + n4] = (byte)((array2[n5] & 0xF) | (array2[n5 + 1] & 0xF) << 4);
            }
        }
        else if (this.SABER_ET == 6) {
            for (int k = 0; k < this.SABER_N / 4; k = (short)(k + 1)) {
                final short n6 = (short)(3 * k);
                final short n7 = (short)(4 * k);
                array[n + n6 + 0] = (byte)((array2[n7 + 0] & 0x3F) | (array2[n7 + 1] & 0x3) << 6);
                array[n + n6 + 1] = (byte)((array2[n7 + 1] >> 2 & 0xF) | (array2[n7 + 2] & 0xF) << 4);
                array[n + n6 + 2] = (byte)((array2[n7 + 2] >> 4 & 0x3) | (array2[n7 + 3] & 0x3F) << 2);
            }
        }
    }
    
    public void BS2POLT(final byte[] array, final int n, final short[] array2) {
        if (this.SABER_ET == 3) {
            for (int i = 0; i < this.SABER_N / 8; i = (short)(i + 1)) {
                final short n2 = (short)(3 * i);
                final short n3 = (short)(8 * i);
                array2[n3 + 0] = (short)(array[n + n2 + 0] & 0x7);
                array2[n3 + 1] = (short)(array[n + n2 + 0] >> 3 & 0x7);
                array2[n3 + 2] = (short)((array[n + n2 + 0] >> 6 & 0x3) | (array[n + n2 + 1] & 0x1) << 2);
                array2[n3 + 3] = (short)(array[n + n2 + 1] >> 1 & 0x7);
                array2[n3 + 4] = (short)(array[n + n2 + 1] >> 4 & 0x7);
                array2[n3 + 5] = (short)((array[n + n2 + 1] >> 7 & 0x1) | (array[n + n2 + 2] & 0x3) << 1);
                array2[n3 + 6] = (short)(array[n + n2 + 2] >> 2 & 0x7);
                array2[n3 + 7] = (short)(array[n + n2 + 2] >> 5 & 0x7);
            }
        }
        else if (this.SABER_ET == 4) {
            for (int j = 0; j < this.SABER_N / 2; j = (short)(j + 1)) {
                final int n4 = j;
                final short n5 = (short)(2 * j);
                array2[n5] = (short)(array[n + n4] & 0xF);
                array2[n5 + 1] = (short)(array[n + n4] >> 4 & 0xF);
            }
        }
        else if (this.SABER_ET == 6) {
            for (int k = 0; k < this.SABER_N / 4; k = (short)(k + 1)) {
                final short n6 = (short)(3 * k);
                final short n7 = (short)(4 * k);
                array2[n7 + 0] = (short)(array[n + n6 + 0] & 0x3F);
                array2[n7 + 1] = (short)((array[n + n6 + 0] >> 6 & 0x3) | (array[n + n6 + 1] & 0xF) << 2);
                array2[n7 + 2] = (short)((array[n + n6 + 1] & 0xFF) >> 4 | (array[n + n6 + 2] & 0x3) << 4);
                array2[n7 + 3] = (short)((array[n + n6 + 2] & 0xFF) >> 2);
            }
        }
    }
    
    private void POLq2BS(final byte[] array, final int n, final short[] array2) {
        if (!this.usingEffectiveMasking) {
            for (int i = 0; i < this.SABER_N / 8; i = (short)(i + 1)) {
                final short n2 = (short)(13 * i);
                final short n3 = (short)(8 * i);
                array[n + n2 + 0] = (byte)(array2[n3 + 0] & 0xFF);
                array[n + n2 + 1] = (byte)((array2[n3 + 0] >> 8 & 0x1F) | (array2[n3 + 1] & 0x7) << 5);
                array[n + n2 + 2] = (byte)(array2[n3 + 1] >> 3 & 0xFF);
                array[n + n2 + 3] = (byte)((array2[n3 + 1] >> 11 & 0x3) | (array2[n3 + 2] & 0x3F) << 2);
                array[n + n2 + 4] = (byte)((array2[n3 + 2] >> 6 & 0x7F) | (array2[n3 + 3] & 0x1) << 7);
                array[n + n2 + 5] = (byte)(array2[n3 + 3] >> 1 & 0xFF);
                array[n + n2 + 6] = (byte)((array2[n3 + 3] >> 9 & 0xF) | (array2[n3 + 4] & 0xF) << 4);
                array[n + n2 + 7] = (byte)(array2[n3 + 4] >> 4 & 0xFF);
                array[n + n2 + 8] = (byte)((array2[n3 + 4] >> 12 & 0x1) | (array2[n3 + 5] & 0x7F) << 1);
                array[n + n2 + 9] = (byte)((array2[n3 + 5] >> 7 & 0x3F) | (array2[n3 + 6] & 0x3) << 6);
                array[n + n2 + 10] = (byte)(array2[n3 + 6] >> 2 & 0xFF);
                array[n + n2 + 11] = (byte)((array2[n3 + 6] >> 10 & 0x7) | (array2[n3 + 7] & 0x1F) << 3);
                array[n + n2 + 12] = (byte)(array2[n3 + 7] >> 5 & 0xFF);
            }
        }
        else {
            for (int j = 0; j < this.SABER_N / 2; j = (short)(j + 1)) {
                final short n4 = (short)(3 * j);
                final short n5 = (short)(2 * j);
                array[n + n4 + 0] = (byte)(array2[n5 + 0] & 0xFF);
                array[n + n4 + 1] = (byte)((array2[n5 + 0] >> 8 & 0xF) | (array2[n5 + 1] & 0xF) << 4);
                array[n + n4 + 2] = (byte)(array2[n5 + 1] >> 4 & 0xFF);
            }
        }
    }
    
    private void BS2POLq(final byte[] array, final int n, final short[] array2) {
        if (!this.usingEffectiveMasking) {
            for (int i = 0; i < this.SABER_N / 8; i = (short)(i + 1)) {
                final short n2 = (short)(13 * i);
                final short n3 = (short)(8 * i);
                array2[n3 + 0] = (short)((array[n + n2 + 0] & 0xFF) | (array[n + n2 + 1] & 0x1F) << 8);
                array2[n3 + 1] = (short)((array[n + n2 + 1] >> 5 & 0x7) | (array[n + n2 + 2] & 0xFF) << 3 | (array[n + n2 + 3] & 0x3) << 11);
                array2[n3 + 2] = (short)((array[n + n2 + 3] >> 2 & 0x3F) | (array[n + n2 + 4] & 0x7F) << 6);
                array2[n3 + 3] = (short)((array[n + n2 + 4] >> 7 & 0x1) | (array[n + n2 + 5] & 0xFF) << 1 | (array[n + n2 + 6] & 0xF) << 9);
                array2[n3 + 4] = (short)((array[n + n2 + 6] >> 4 & 0xF) | (array[n + n2 + 7] & 0xFF) << 4 | (array[n + n2 + 8] & 0x1) << 12);
                array2[n3 + 5] = (short)((array[n + n2 + 8] >> 1 & 0x7F) | (array[n + n2 + 9] & 0x3F) << 7);
                array2[n3 + 6] = (short)((array[n + n2 + 9] >> 6 & 0x3) | (array[n + n2 + 10] & 0xFF) << 2 | (array[n + n2 + 11] & 0x7) << 10);
                array2[n3 + 7] = (short)((array[n + n2 + 11] >> 3 & 0x1F) | (array[n + n2 + 12] & 0xFF) << 5);
            }
        }
        else {
            for (int j = 0; j < this.SABER_N / 2; j = (short)(j + 1)) {
                final short n4 = (short)(3 * j);
                final short n5 = (short)(2 * j);
                array2[n5 + 0] = (short)((array[n + n4 + 0] & 0xFF) | (array[n + n4 + 1] & 0xF) << 8);
                array2[n5 + 1] = (short)((array[n + n4 + 1] >> 4 & 0xF) | (array[n + n4 + 2] & 0xFF) << 4);
            }
        }
    }
    
    private void POLp2BS(final byte[] array, final int n, final short[] array2) {
        for (int i = 0; i < this.SABER_N / 4; i = (short)(i + 1)) {
            final short n2 = (short)(5 * i);
            final short n3 = (short)(4 * i);
            array[n + n2 + 0] = (byte)(array2[n3 + 0] & 0xFF);
            array[n + n2 + 1] = (byte)((array2[n3 + 0] >> 8 & 0x3) | (array2[n3 + 1] & 0x3F) << 2);
            array[n + n2 + 2] = (byte)((array2[n3 + 1] >> 6 & 0xF) | (array2[n3 + 2] & 0xF) << 4);
            array[n + n2 + 3] = (byte)((array2[n3 + 2] >> 4 & 0x3F) | (array2[n3 + 3] & 0x3) << 6);
            array[n + n2 + 4] = (byte)(array2[n3 + 3] >> 2 & 0xFF);
        }
    }
    
    public void BS2POLp(final byte[] array, final int n, final short[] array2) {
        for (int i = 0; i < this.SABER_N / 4; i = (short)(i + 1)) {
            final short n2 = (short)(5 * i);
            final short n3 = (short)(4 * i);
            array2[n3 + 0] = (short)((array[n + n2 + 0] & 0xFF) | (array[n + n2 + 1] & 0x3) << 8);
            array2[n3 + 1] = (short)((array[n + n2 + 1] >> 2 & 0x3F) | (array[n + n2 + 2] & 0xF) << 6);
            array2[n3 + 2] = (short)((array[n + n2 + 2] >> 4 & 0xF) | (array[n + n2 + 3] & 0x3F) << 4);
            array2[n3 + 3] = (short)((array[n + n2 + 3] >> 6 & 0x3) | (array[n + n2 + 4] & 0xFF) << 2);
        }
    }
    
    public void POLVECq2BS(final byte[] array, final short[][] array2) {
        for (int i = 0; i < this.SABER_L; i = (byte)(i + 1)) {
            this.POLq2BS(array, i * this.SABER_POLYBYTES, array2[i]);
        }
    }
    
    public void BS2POLVECq(final byte[] array, final int n, final short[][] array2) {
        for (int i = 0; i < this.SABER_L; i = (byte)(i + 1)) {
            this.BS2POLq(array, n + i * this.SABER_POLYBYTES, array2[i]);
        }
    }
    
    public void POLVECp2BS(final byte[] array, final short[][] array2) {
        for (int i = 0; i < this.SABER_L; i = (byte)(i + 1)) {
            this.POLp2BS(array, i * (this.SABER_EP * this.SABER_N / 8), array2[i]);
        }
    }
    
    public void BS2POLVECp(final byte[] array, final short[][] array2) {
        for (int i = 0; i < this.SABER_L; i = (byte)(i + 1)) {
            this.BS2POLp(array, i * (this.SABER_EP * this.SABER_N / 8), array2[i]);
        }
    }
    
    public void BS2POLmsg(final byte[] array, final short[] array2) {
        for (int i = 0; i < this.SABER_KEYBYTES; i = (byte)(i + 1)) {
            for (int j = 0; j < 8; j = (byte)(j + 1)) {
                array2[i * 8 + j] = (short)(array[i] >> j & 0x1);
            }
        }
    }
    
    public void POLmsg2BS(final byte[] array, final short[] array2) {
        for (int i = 0; i < this.SABER_KEYBYTES; i = (byte)(i + 1)) {
            for (int j = 0; j < 8; j = (byte)(j + 1)) {
                array[i] |= (byte)((array2[i * 8 + j] & 0x1) << j);
            }
        }
    }
}