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

package org.bouncycastle.pqc.crypto.snova;

import org.bouncycastle.util.GF16;

class MapGroup1
{
    public final byte[][][][] p11;
    public final byte[][][][] p12;
    public final byte[][][][] p21;
    public final byte[][][] aAlpha;
    public final byte[][][] bAlpha;
    public final byte[][][] qAlpha1;
    public final byte[][][] qAlpha2;
    
    public MapGroup1(final SnovaParameters snovaParameters) {
        final int m = snovaParameters.getM();
        final int v = snovaParameters.getV();
        final int o = snovaParameters.getO();
        final int alpha = snovaParameters.getAlpha();
        final int lsq = snovaParameters.getLsq();
        this.p11 = new byte[m][v][v][lsq];
        this.p12 = new byte[m][v][o][lsq];
        this.p21 = new byte[m][o][v][lsq];
        this.aAlpha = new byte[m][alpha][lsq];
        this.bAlpha = new byte[m][alpha][lsq];
        this.qAlpha1 = new byte[m][alpha][lsq];
        this.qAlpha2 = new byte[m][alpha][lsq];
    }
    
    void decode(final byte[] array, final int n, final boolean b) {
        final int decodeP = decodeP(array, 0, this.p11, n);
        final int n2 = decodeP + decodeP(array, decodeP, this.p12, n - decodeP);
        final int n3 = n2 + decodeP(array, n2, this.p21, n - n2);
        if (b) {
            final int n4 = n3 + decodeAlpha(array, n3, this.aAlpha, n - n3);
            final int n5 = n4 + decodeAlpha(array, n4, this.bAlpha, n - n4);
            final int n6 = n5 + decodeAlpha(array, n5, this.qAlpha1, n - n5);
            decodeAlpha(array, n6, this.qAlpha2, n - n6);
        }
    }
    
    static int decodeP(final byte[] array, final int n, final byte[][][][] array2, final int n2) {
        int n3 = 0;
        for (int i = 0; i < array2.length; ++i) {
            n3 += decodeAlpha(array, n + n3, array2[i], n2);
        }
        return n3;
    }
    
    private static int decodeAlpha(final byte[] array, final int n, final byte[][][] array2, final int n2) {
        int n3 = 0;
        for (int i = 0; i < array2.length; ++i) {
            n3 += decodeArray(array, n + n3, array2[i], n2 - n3);
        }
        return n3;
    }
    
    static int decodeArray(final byte[] array, final int n, final byte[][] array2, int n2) {
        int n3 = 0;
        for (int i = 0; i < array2.length; ++i) {
            final int min = Math.min(array2[i].length, n2 << 1);
            GF16.decode(array, n + n3, array2[i], 0, min);
            final int n4 = min + 1 >> 1;
            n3 += n4;
            n2 -= n4;
        }
        return n3;
    }
    
    void fill(final byte[] array, final boolean b) {
        final int fillP = fillP(array, 0, this.p11, array.length);
        final int n = fillP + fillP(array, fillP, this.p12, array.length - fillP);
        final int n2 = n + fillP(array, n, this.p21, array.length - n);
        if (b) {
            final int n3 = n2 + fillAlpha(array, n2, this.aAlpha, array.length - n2);
            final int n4 = n3 + fillAlpha(array, n3, this.bAlpha, array.length - n3);
            final int n5 = n4 + fillAlpha(array, n4, this.qAlpha1, array.length - n4);
            fillAlpha(array, n5, this.qAlpha2, array.length - n5);
        }
    }
    
    static int fillP(final byte[] array, final int n, final byte[][][][] array2, final int n2) {
        int n3 = 0;
        for (int i = 0; i < array2.length; ++i) {
            n3 += fillAlpha(array, n + n3, array2[i], n2 - n3);
        }
        return n3;
    }
    
    static int fillAlpha(final byte[] array, final int n, final byte[][][] array2, final int n2) {
        int n3 = 0;
        for (int i = 0; i < array2.length; ++i) {
            for (int j = 0; j < array2[i].length; ++j) {
                final int min = Math.min(array2[i][j].length, n2 - n3);
                System.arraycopy(array, n + n3, array2[i][j], 0, min);
                n3 += min;
            }
        }
        return n3;
    }
}