package Y3;

import java.nio.ByteBuffer;
import java.security.GeneralSecurityException;
import java.util.Arrays;

/* JADX INFO: loaded from: classes3.dex */
public abstract class j {

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public static final i f8818a = new i(new C4.f(new long[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, new long[]{1, 0, 0, 0, 0, 0, 0, 0, 0, 0}, new long[]{1, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 16), new long[]{1, 0, 0, 0, 0, 0, 0, 0, 0, 0});

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public static final byte[] f8819b = {-19, -45, -11, 92, 26, 99, 18, 88, -42, -100, -9, -94, -34, -7, -34, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16};

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    public static final int[] f8820c = {0, 3, 6, 9, 12, 16, 19, 22, 25, 28};

    /* JADX INFO: renamed from: d, reason: collision with root package name */
    public static final int[] f8821d = {0, 2, 3, 5, 6, 0, 1, 3, 4, 6};

    /* JADX INFO: renamed from: e, reason: collision with root package name */
    public static final int[] f8822e = {67108863, 33554431};

    /* JADX INFO: renamed from: f, reason: collision with root package name */
    public static final int[] f8823f = {26, 25};

    public static boolean a(long[] jArr) {
        long[] jArr2 = new long[jArr.length + 1];
        System.arraycopy(jArr, 0, jArr2, 0, jArr.length);
        l(jArr2);
        byte[] bArrD = d(jArr2);
        for (int i6 = 0; i6 < 32; i6++) {
            if (bArrD[i6] != 0) {
                return true;
            }
        }
        return false;
    }

    public static void b(i iVar, i iVar2, g gVar) {
        long[] jArr = new long[10];
        C4.f fVar = iVar.f8816a;
        long[] jArr2 = (long[]) fVar.f741b;
        C4.f fVar2 = iVar2.f8816a;
        q(jArr2, (long[]) fVar2.f742c, (long[]) fVar2.f741b);
        p((long[]) fVar.f742c, (long[]) fVar2.f742c, (long[]) fVar2.f741b);
        long[] jArr3 = gVar.f8813b;
        long[] jArr4 = (long[]) fVar.f742c;
        j(jArr4, jArr4, jArr3);
        long[] jArr5 = gVar.f8812a;
        long[] jArr6 = (long[]) fVar.f743d;
        long[] jArr7 = (long[]) fVar.f741b;
        j(jArr6, jArr7, jArr5);
        long[] jArr8 = gVar.f8814c;
        long[] jArr9 = iVar.f8817b;
        j(jArr9, iVar2.f8817b, jArr8);
        gVar.a(jArr7, (long[]) fVar2.f743d);
        q(jArr, jArr7, jArr7);
        p(jArr7, jArr6, jArr4);
        q(jArr4, jArr6, jArr4);
        q(jArr6, jArr, jArr9);
        p(jArr9, jArr, jArr9);
    }

    public static byte[] c(byte[]... bArr) throws GeneralSecurityException {
        int length = 0;
        for (byte[] bArr2 : bArr) {
            if (length > Integer.MAX_VALUE - bArr2.length) {
                throw new GeneralSecurityException("exceeded size limit");
            }
            length += bArr2.length;
        }
        byte[] bArr3 = new byte[length];
        int length2 = 0;
        for (byte[] bArr4 : bArr) {
            System.arraycopy(bArr4, 0, bArr3, length2, bArr4.length);
            length2 += bArr4.length;
        }
        return bArr3;
    }

    public static byte[] d(long[] jArr) {
        int[] iArr;
        int i6;
        int[] iArr2;
        long[] jArrCopyOf = Arrays.copyOf(jArr, 10);
        int i7 = 0;
        int i8 = 0;
        while (true) {
            iArr = f8823f;
            if (i8 >= 2) {
                break;
            }
            int i9 = 0;
            while (i9 < 9) {
                long j4 = jArrCopyOf[i9];
                int i10 = iArr[i9 & 1];
                int i11 = -((int) (((j4 >> 31) & j4) >> i10));
                jArrCopyOf[i9] = j4 + ((long) (i11 << i10));
                i9++;
                jArrCopyOf[i9] = jArrCopyOf[i9] - ((long) i11);
            }
            long j6 = jArrCopyOf[9];
            int i12 = -((int) (((j6 >> 31) & j6) >> 25));
            jArrCopyOf[9] = j6 + ((long) (i12 << 25));
            jArrCopyOf[0] = jArrCopyOf[0] - ((long) (i12 * 19));
            i8++;
        }
        long j7 = jArrCopyOf[0];
        int i13 = -((int) (((j7 >> 31) & j7) >> 26));
        jArrCopyOf[0] = j7 + ((long) (i13 << 26));
        jArrCopyOf[1] = jArrCopyOf[1] - ((long) i13);
        int i14 = 0;
        while (true) {
            iArr2 = f8822e;
            if (i14 >= 2) {
                break;
            }
            int i15 = i7;
            while (i15 < 9) {
                long j8 = jArrCopyOf[i15];
                int i16 = i15 & 1;
                int i17 = i7;
                int i18 = (int) (j8 >> iArr[i16]);
                jArrCopyOf[i15] = j8 & ((long) iArr2[i16]);
                i15++;
                jArrCopyOf[i15] = jArrCopyOf[i15] + ((long) i18);
                i7 = i17;
                i14 = i14;
            }
            i14++;
        }
        int i19 = i7;
        long j9 = jArrCopyOf[9];
        jArrCopyOf[9] = j9 & 33554431;
        long j10 = jArrCopyOf[i19] + ((long) (((int) (j9 >> 25)) * 19));
        jArrCopyOf[i19] = j10;
        int i20 = ~((((int) j10) - 67108845) >> 31);
        for (int i21 = 1; i21 < 10; i21++) {
            int i22 = ~(((int) jArrCopyOf[i21]) ^ iArr2[i21 & 1]);
            int i23 = i22 & (i22 << 16);
            int i24 = i23 & (i23 << 8);
            int i25 = i24 & (i24 << 4);
            int i26 = i25 & (i25 << 2);
            i20 &= (i26 & (i26 << 1)) >> 31;
        }
        jArrCopyOf[i19] = jArrCopyOf[i19] - ((long) (67108845 & i20));
        long j11 = 33554431 & i20;
        jArrCopyOf[1] = jArrCopyOf[1] - j11;
        for (i6 = 2; i6 < 10; i6 += 2) {
            jArrCopyOf[i6] = jArrCopyOf[i6] - ((long) (67108863 & i20));
            int i27 = i6 + 1;
            jArrCopyOf[i27] = jArrCopyOf[i27] - j11;
        }
        for (int i28 = i19; i28 < 10; i28++) {
            jArrCopyOf[i28] = jArrCopyOf[i28] << f8821d[i28];
        }
        byte[] bArr = new byte[32];
        for (int i29 = i19; i29 < 10; i29++) {
            int i30 = f8820c[i29];
            long j12 = bArr[i30];
            long j13 = jArrCopyOf[i29];
            bArr[i30] = (byte) (j12 | (j13 & 255));
            bArr[i30 + 1] = (byte) (((long) bArr[r5]) | ((j13 >> 8) & 255));
            bArr[i30 + 2] = (byte) (((long) bArr[r5]) | ((j13 >> 16) & 255));
            bArr[i30 + 3] = (byte) (((long) bArr[r4]) | ((j13 >> 24) & 255));
        }
        return bArr;
    }

    public static byte[] e(String str) {
        if (str.length() % 2 != 0) {
            throw new IllegalArgumentException("Expected a string of even length");
        }
        int length = str.length() / 2;
        byte[] bArr = new byte[length];
        for (int i6 = 0; i6 < length; i6++) {
            int i7 = i6 * 2;
            int iDigit = Character.digit(str.charAt(i7), 16);
            int iDigit2 = Character.digit(str.charAt(i7 + 1), 16);
            if (iDigit == -1 || iDigit2 == -1) {
                throw new IllegalArgumentException("input is not hexadecimal");
            }
            bArr[i6] = (byte) ((iDigit * 16) + iDigit2);
        }
        return bArr;
    }

    public static String f(byte[] bArr) {
        StringBuilder sb = new StringBuilder(bArr.length * 2);
        for (byte b5 : bArr) {
            int i6 = b5 & 255;
            sb.append("0123456789abcdef".charAt(i6 / 16));
            sb.append("0123456789abcdef".charAt(i6 % 16));
        }
        return sb.toString();
    }

    public static long[] g(byte[] bArr) {
        long[] jArr = new long[10];
        for (int i6 = 0; i6 < 10; i6++) {
            int i7 = f8820c[i6];
            jArr[i6] = ((((((long) (bArr[i7] & 255)) | (((long) (bArr[i7 + 1] & 255)) << 8)) | (((long) (bArr[i7 + 2] & 255)) << 16)) | (((long) (bArr[i7 + 3] & 255)) << 24)) >> f8821d[i6]) & ((long) f8822e[i6 & 1]);
        }
        return jArr;
    }

    public static long h(byte[] bArr, int i6) {
        return (((long) (bArr[i6 + 2] & 255)) << 16) | (((long) bArr[i6]) & 255) | (((long) (bArr[i6 + 1] & 255)) << 8);
    }

    public static long i(byte[] bArr, int i6) {
        return (((long) (bArr[i6 + 3] & 255)) << 24) | h(bArr, i6);
    }

    public static void j(long[] jArr, long[] jArr2, long[] jArr3) {
        long j4 = jArr2[0];
        long j6 = jArr3[0];
        long j7 = jArr3[1];
        long j8 = jArr2[1];
        long j9 = jArr3[2];
        long j10 = jArr2[2];
        long j11 = jArr3[3];
        long j12 = jArr2[3];
        long j13 = jArr3[4];
        long j14 = jArr2[4];
        long j15 = (j14 * j6) + (j4 * j13) + (((j12 * j7) + (j8 * j11)) * 2) + (j10 * j9);
        long j16 = jArr3[5];
        long j17 = jArr2[5];
        long j18 = (j17 * j6) + (j4 * j16) + (j14 * j7) + (j8 * j13) + (j12 * j9) + (j10 * j11);
        long jD = (j14 * j9) + (j10 * j13) + Z0.o.d(j17, j7, (j8 * j16) + (j12 * j11), 2L);
        long j19 = jArr3[6];
        long j20 = jArr2[6];
        long j21 = (j20 * j6) + (j4 * j19) + jD;
        long j22 = jArr3[7];
        long j23 = jArr2[7];
        long j24 = (j23 * j6) + (j4 * j22) + (j20 * j7) + (j8 * j19) + (j17 * j9) + (j10 * j16) + (j14 * j11) + (j12 * j13);
        long j25 = (j20 * j9) + (j10 * j19) + (((j23 * j7) + (j8 * j22) + (j17 * j11) + (j12 * j16)) * 2) + (j14 * j13);
        long j26 = jArr3[8];
        long j27 = jArr2[8];
        long j28 = jArr3[9];
        long j29 = jArr2[9];
        long j30 = (((j29 * j22) + (j23 * j28)) * 2) + (j27 * j26);
        k(new long[]{j4 * j6, (j8 * j6) + (j4 * j7), (j10 * j6) + (j4 * j9) + (j8 * 2 * j7), (j12 * j6) + (j4 * j11) + (j10 * j7) + (j8 * j9), j15, j18, j21, j24, (j27 * j6) + (j4 * j26) + j25, (j6 * j29) + (j4 * j28) + (j27 * j7) + (j8 * j26) + (j23 * j9) + (j10 * j22) + (j20 * j11) + (j12 * j19) + (j17 * j13) + (j14 * j16), (j27 * j9) + (j10 * j26) + (j20 * j13) + (j14 * j19) + Z0.o.d(j29, j7, (j8 * j28) + (j23 * j11) + (j12 * j22) + (j17 * j16), 2L), (j29 * j9) + (j10 * j28) + (j27 * j11) + (j12 * j26) + (j23 * j13) + (j14 * j22) + (j20 * j16) + (j17 * j19), (j27 * j13) + (j14 * j26) + (((j29 * j11) + (j12 * j28) + (j23 * j16) + (j17 * j22)) * 2) + (j20 * j19), (j29 * j13) + (j14 * j28) + (j27 * j16) + (j17 * j26) + (j23 * j19) + (j20 * j22), (j27 * j19) + (j20 * j26) + Z0.o.d(j29, j16, (j17 * j28) + (j23 * j22), 2L), (j29 * j19) + (j20 * j28) + (j27 * j22) + (j23 * j26), j30, (j29 * j26) + (j27 * j28), 2 * j29 * j28}, jArr);
    }

    public static void k(long[] jArr, long[] jArr2) {
        if (jArr.length != 19) {
            long[] jArr3 = new long[19];
            System.arraycopy(jArr, 0, jArr3, 0, jArr.length);
            jArr = jArr3;
        }
        long j4 = jArr[8];
        long j6 = jArr[18];
        long j7 = j4 + (j6 << 4);
        jArr[8] = j7;
        long j8 = j7 + (j6 << 1);
        jArr[8] = j8;
        jArr[8] = j8 + j6;
        long j9 = jArr[7];
        long j10 = jArr[17];
        long j11 = j9 + (j10 << 4);
        jArr[7] = j11;
        long j12 = j11 + (j10 << 1);
        jArr[7] = j12;
        jArr[7] = j12 + j10;
        long j13 = jArr[6];
        long j14 = jArr[16];
        long j15 = j13 + (j14 << 4);
        jArr[6] = j15;
        long j16 = j15 + (j14 << 1);
        jArr[6] = j16;
        jArr[6] = j16 + j14;
        long j17 = jArr[5];
        long j18 = jArr[15];
        long j19 = j17 + (j18 << 4);
        jArr[5] = j19;
        long j20 = j19 + (j18 << 1);
        jArr[5] = j20;
        jArr[5] = j20 + j18;
        long j21 = jArr[4];
        long j22 = jArr[14];
        long j23 = j21 + (j22 << 4);
        jArr[4] = j23;
        long j24 = j23 + (j22 << 1);
        jArr[4] = j24;
        jArr[4] = j24 + j22;
        long j25 = jArr[3];
        long j26 = jArr[13];
        long j27 = j25 + (j26 << 4);
        jArr[3] = j27;
        long j28 = j27 + (j26 << 1);
        jArr[3] = j28;
        jArr[3] = j28 + j26;
        long j29 = jArr[2];
        long j30 = jArr[12];
        long j31 = j29 + (j30 << 4);
        jArr[2] = j31;
        long j32 = j31 + (j30 << 1);
        jArr[2] = j32;
        jArr[2] = j32 + j30;
        long j33 = jArr[1];
        long j34 = jArr[11];
        long j35 = j33 + (j34 << 4);
        jArr[1] = j35;
        long j36 = j35 + (j34 << 1);
        jArr[1] = j36;
        jArr[1] = j36 + j34;
        long j37 = jArr[0];
        long j38 = jArr[10];
        long j39 = j37 + (j38 << 4);
        jArr[0] = j39;
        long j40 = j39 + (j38 << 1);
        jArr[0] = j40;
        jArr[0] = j40 + j38;
        l(jArr);
        System.arraycopy(jArr, 0, jArr2, 0, 10);
    }

    public static void l(long[] jArr) {
        jArr[10] = 0;
        int i6 = 0;
        while (i6 < 10) {
            long j4 = jArr[i6];
            long j6 = j4 / 67108864;
            jArr[i6] = j4 - (j6 << 26);
            int i7 = i6 + 1;
            long j7 = jArr[i7] + j6;
            jArr[i7] = j7;
            long j8 = j7 / 33554432;
            jArr[i7] = j7 - (j8 << 25);
            i6 += 2;
            jArr[i6] = jArr[i6] + j8;
        }
        long j9 = jArr[0];
        long j10 = jArr[10];
        long j11 = j9 + (j10 << 4);
        jArr[0] = j11;
        long j12 = j11 + (j10 << 1);
        jArr[0] = j12;
        long j13 = j12 + j10;
        jArr[0] = j13;
        jArr[10] = 0;
        long j14 = j13 / 67108864;
        jArr[0] = j13 - (j14 << 26);
        jArr[1] = jArr[1] + j14;
    }

    public static byte[] m(byte[] bArr) {
        int i6;
        byte[] bArr2 = new byte[256];
        for (int i7 = 0; i7 < 256; i7++) {
            bArr2[i7] = (byte) (1 & ((bArr[i7 >> 3] & 255) >> (i7 & 7)));
        }
        for (int i8 = 0; i8 < 256; i8++) {
            if (bArr2[i8] != 0) {
                for (int i9 = 1; i9 <= 6 && (i6 = i8 + i9) < 256; i9++) {
                    byte b5 = bArr2[i6];
                    if (b5 != 0) {
                        byte b6 = bArr2[i8];
                        if ((b5 << i9) + b6 <= 15) {
                            bArr2[i8] = (byte) (b6 + (b5 << i9));
                            bArr2[i6] = 0;
                        } else if (b6 - (b5 << i9) >= -15) {
                            bArr2[i8] = (byte) (b6 - (b5 << i9));
                            while (true) {
                                if (i6 >= 256) {
                                    break;
                                }
                                if (bArr2[i6] == 0) {
                                    bArr2[i6] = 1;
                                    break;
                                }
                                bArr2[i6] = 0;
                                i6++;
                            }
                        }
                    }
                }
            }
        }
        return bArr2;
    }

    public static void n(long[] jArr, long[] jArr2) {
        long j4 = jArr2[0];
        long j6 = j4 * 2;
        long j7 = jArr2[1];
        long j8 = jArr2[2];
        long jD = Z0.o.d(j4, j8, j7 * j7, 2L);
        long j9 = j7 * j8;
        long j10 = jArr2[3];
        long jD2 = Z0.o.d(j4, j10, j9, 2L);
        long j11 = jArr2[4];
        long j12 = (j6 * j11) + (j7 * 4 * j10) + (j8 * j8);
        long j13 = (j7 * j11) + (j8 * j10);
        long j14 = jArr2[5];
        long jD3 = Z0.o.d(j4, j14, j13, 2L);
        long j15 = jArr2[6];
        long j16 = ((j7 * 2 * j14) + (j4 * j15) + (j8 * j11) + (j10 * j10)) * 2;
        long j17 = (j8 * j14) + (j10 * j11) + (j7 * j15);
        long j18 = jArr2[7];
        long jD4 = Z0.o.d(j4, j18, j17, 2L);
        long j19 = jArr2[8];
        long j20 = (((((j10 * j14) + (j7 * j18)) * 2) + (j4 * j19) + (j8 * j15)) * 2) + (j11 * j11);
        long j21 = (j7 * j19) + (j8 * j18) + (j10 * j15) + (j11 * j14);
        long j22 = jArr2[9];
        k(new long[]{j4 * j4, j6 * j7, jD, jD2, j12, jD3, j16, jD4, j20, Z0.o.d(j4, j22, j21, 2L), ((((j7 * j22) + (j10 * j18)) * 2) + (j8 * j19) + (j11 * j15) + (j14 * j14)) * 2, Z0.o.d(j8, j22, (j10 * j19) + (j11 * j18) + (j14 * j15), 2L), (((((j10 * j22) + (j14 * j18)) * 2) + (j11 * j19)) * 2) + (j15 * j15), Z0.o.d(j11, j22, (j14 * j19) + (j15 * j18), 2L), ((j14 * 2 * j22) + (j15 * j19) + (j18 * j18)) * 2, Z0.o.d(j15, j22, j18 * j19, 2L), (4 * j18 * j22) + (j19 * j19), j19 * 2 * j22, j22 * 2 * j22}, jArr);
    }

    public static void o(i iVar, i iVar2, g gVar) {
        long[] jArr = new long[10];
        C4.f fVar = iVar.f8816a;
        long[] jArr2 = (long[]) fVar.f741b;
        C4.f fVar2 = iVar2.f8816a;
        q(jArr2, (long[]) fVar2.f742c, (long[]) fVar2.f741b);
        p((long[]) fVar.f742c, (long[]) fVar2.f742c, (long[]) fVar2.f741b);
        long[] jArr3 = gVar.f8812a;
        long[] jArr4 = (long[]) fVar.f742c;
        j(jArr4, jArr4, jArr3);
        long[] jArr5 = gVar.f8813b;
        long[] jArr6 = (long[]) fVar.f743d;
        long[] jArr7 = (long[]) fVar.f741b;
        j(jArr6, jArr7, jArr5);
        long[] jArr8 = gVar.f8814c;
        long[] jArr9 = iVar.f8817b;
        j(jArr9, iVar2.f8817b, jArr8);
        gVar.a(jArr7, (long[]) fVar2.f743d);
        q(jArr, jArr7, jArr7);
        p(jArr7, jArr6, jArr4);
        q(jArr4, jArr6, jArr4);
        p(jArr6, jArr, jArr9);
        q(jArr9, jArr, jArr9);
    }

    public static void p(long[] jArr, long[] jArr2, long[] jArr3) {
        for (int i6 = 0; i6 < 10; i6++) {
            jArr[i6] = jArr2[i6] - jArr3[i6];
        }
    }

    public static void q(long[] jArr, long[] jArr2, long[] jArr3) {
        for (int i6 = 0; i6 < 10; i6++) {
            jArr[i6] = jArr2[i6] + jArr3[i6];
        }
    }

    public static final void r(ByteBuffer byteBuffer, ByteBuffer byteBuffer2, ByteBuffer byteBuffer3, int i6) {
        if (i6 < 0 || byteBuffer2.remaining() < i6 || byteBuffer3.remaining() < i6 || byteBuffer.remaining() < i6) {
            throw new IllegalArgumentException("That combination of buffers, offsets and length to xor result in out-of-bond accesses.");
        }
        for (int i7 = 0; i7 < i6; i7++) {
            byteBuffer.put((byte) (byteBuffer2.get() ^ byteBuffer3.get()));
        }
    }

    public static final byte[] s(byte[] bArr, int i6, int i7, byte[] bArr2, int i8) {
        if (i8 < 0 || bArr.length - i8 < i6 || bArr2.length - i8 < i7) {
            throw new IllegalArgumentException("That combination of buffers, offsets and length to xor result in out-of-bond accesses.");
        }
        byte[] bArr3 = new byte[i8];
        for (int i9 = 0; i9 < i8; i9++) {
            bArr3[i9] = (byte) (bArr[i9 + i6] ^ bArr2[i9 + i7]);
        }
        return bArr3;
    }

    public static final byte[] t(byte[] bArr, byte[] bArr2) {
        if (bArr.length == bArr2.length) {
            return s(bArr, 0, 0, bArr2, bArr.length);
        }
        throw new IllegalArgumentException("The lengths of x and y should match.");
    }
}