package com.google.android.gms.internal.p002firebaseauthapi;

import Z0.o;
import java.util.Arrays;

/* JADX INFO: loaded from: classes3.dex */
public final class zzmw {
    private static final int[] zza = {0, 3, 6, 9, 12, 16, 19, 22, 25, 28};
    private static final int[] zzb = {0, 2, 3, 5, 6, 0, 1, 3, 4, 6};
    private static final int[] zzc = {67108863, 33554431};
    private static final int[] zzd = {26, 25};

    public static void zza(long[] jArr, long[] jArr2) {
        long[] jArr3 = new long[10];
        long[] jArr4 = new long[10];
        long[] jArr5 = new long[10];
        long[] jArr6 = new long[10];
        long[] jArr7 = new long[10];
        long[] jArr8 = new long[10];
        long[] jArr9 = new long[10];
        long[] jArr10 = new long[10];
        long[] jArr11 = new long[10];
        long[] jArr12 = new long[10];
        zzb(jArr3, jArr2);
        zzb(jArr12, jArr3);
        zzb(jArr11, jArr12);
        zza(jArr4, jArr11, jArr2);
        zza(jArr5, jArr4, jArr3);
        zzb(jArr11, jArr5);
        zza(jArr6, jArr11, jArr4);
        zzb(jArr11, jArr6);
        zzb(jArr12, jArr11);
        zzb(jArr11, jArr12);
        zzb(jArr12, jArr11);
        zzb(jArr11, jArr12);
        zza(jArr7, jArr11, jArr6);
        zzb(jArr11, jArr7);
        zzb(jArr12, jArr11);
        for (int i6 = 2; i6 < 10; i6 += 2) {
            zzb(jArr11, jArr12);
            zzb(jArr12, jArr11);
        }
        zza(jArr8, jArr12, jArr7);
        zzb(jArr11, jArr8);
        zzb(jArr12, jArr11);
        for (int i7 = 2; i7 < 20; i7 += 2) {
            zzb(jArr11, jArr12);
            zzb(jArr12, jArr11);
        }
        zza(jArr11, jArr12, jArr8);
        zzb(jArr12, jArr11);
        zzb(jArr11, jArr12);
        for (int i8 = 2; i8 < 10; i8 += 2) {
            zzb(jArr12, jArr11);
            zzb(jArr11, jArr12);
        }
        zza(jArr9, jArr11, jArr7);
        zzb(jArr11, jArr9);
        zzb(jArr12, jArr11);
        for (int i9 = 2; i9 < 50; i9 += 2) {
            zzb(jArr11, jArr12);
            zzb(jArr12, jArr11);
        }
        zza(jArr10, jArr12, jArr9);
        zzb(jArr12, jArr10);
        zzb(jArr11, jArr12);
        for (int i10 = 2; i10 < 100; i10 += 2) {
            zzb(jArr12, jArr11);
            zzb(jArr11, jArr12);
        }
        zza(jArr12, jArr11, jArr10);
        zzb(jArr11, jArr12);
        zzb(jArr12, jArr11);
        for (int i11 = 2; i11 < 50; i11 += 2) {
            zzb(jArr11, jArr12);
            zzb(jArr12, jArr11);
        }
        zza(jArr11, jArr12, jArr9);
        zzb(jArr12, jArr11);
        zzb(jArr11, jArr12);
        zzb(jArr12, jArr11);
        zzb(jArr11, jArr12);
        zzb(jArr12, jArr11);
        zza(jArr, jArr12, jArr5);
    }

    public static void zzb(long[] jArr, long[] jArr2, long[] jArr3) {
        jArr[0] = jArr2[0] * jArr3[0];
        long j4 = jArr2[0];
        long j6 = jArr3[1] * j4;
        long j7 = jArr2[1];
        long j8 = jArr3[0];
        jArr[1] = (j7 * j8) + j6;
        long j9 = jArr2[1];
        long j10 = jArr3[1];
        jArr[2] = (jArr2[2] * j8) + (jArr3[2] * j4) + (j9 * 2 * j10);
        long j11 = jArr3[2];
        long j12 = jArr2[2];
        jArr[3] = (jArr2[3] * j8) + (jArr3[3] * j4) + (j12 * j10) + (j9 * j11);
        long j13 = jArr3[3];
        long j14 = jArr2[3];
        jArr[4] = (jArr2[4] * j8) + (jArr3[4] * j4) + (((j14 * j10) + (j9 * j13)) * 2) + (j12 * j11);
        long j15 = jArr3[4];
        long j16 = jArr2[4];
        jArr[5] = (jArr2[5] * j8) + (jArr3[5] * j4) + (j16 * j10) + (j9 * j15) + (j14 * j11) + (j12 * j13);
        long j17 = jArr3[5];
        long j18 = jArr2[5];
        jArr[6] = (jArr2[6] * j8) + (jArr3[6] * j4) + (j16 * j11) + (j12 * j15) + o.d(j18, j10, (j9 * j17) + (j14 * j13), 2L);
        long j19 = jArr3[6];
        long j20 = jArr2[6];
        jArr[7] = (jArr2[7] * j8) + (jArr3[7] * j4) + (j20 * j10) + (j9 * j19) + (j18 * j11) + (j12 * j17) + (j16 * j13) + (j14 * j15);
        long j21 = jArr3[7];
        long j22 = (j9 * j21) + (j18 * j13) + (j14 * j17);
        long j23 = jArr2[7];
        long j24 = (((j23 * j10) + j22) * 2) + (j16 * j15);
        jArr[8] = (jArr2[8] * j8) + (jArr3[8] * j4) + (j20 * j11) + (j12 * j19) + j24;
        long j25 = jArr3[8];
        long j26 = jArr2[8];
        jArr[9] = (jArr2[9] * j8) + (j4 * jArr3[9]) + (j26 * j10) + (j9 * j25) + (j23 * j11) + (j12 * j21) + (j20 * j13) + (j14 * j19) + (j18 * j15) + (j16 * j17);
        long j27 = j23 * j13;
        long j28 = j27 + (j14 * j21) + (j18 * j17);
        long j29 = jArr3[9];
        long j30 = jArr2[9];
        jArr[10] = (j26 * j11) + (j12 * j25) + (j20 * j15) + (j16 * j19) + o.d(j30, j10, (j9 * j29) + j28, 2L);
        long j31 = j12 * j29;
        jArr[11] = (j30 * j11) + j31 + (j26 * j13) + (j14 * j25) + (j23 * j15) + (j16 * j21) + (j20 * j17) + (j18 * j19);
        long j32 = j14 * j29;
        jArr[12] = (j26 * j15) + (j16 * j25) + (((j30 * j13) + j32 + (j23 * j17) + (j18 * j21)) * 2) + (j20 * j19);
        long j33 = j16 * j29;
        jArr[13] = (j30 * j15) + j33 + (j26 * j17) + (j18 * j25) + (j23 * j19) + (j20 * j21);
        jArr[14] = (j26 * j19) + (j20 * j25) + o.d(j30, j17, (j18 * j29) + (j23 * j21), 2L);
        long j34 = j20 * j29;
        jArr[15] = (j30 * j19) + j34 + (j26 * j21) + (j23 * j25);
        jArr[16] = (((j30 * j21) + (j23 * j29)) * 2) + (j26 * j25);
        jArr[17] = (j30 * j25) + (j26 * j29);
        jArr[18] = j30 * 2 * j29;
    }

    public static void zzc(long[] jArr, long[] jArr2) {
        zzc(jArr, jArr2, jArr);
    }

    public static void zzd(long[] jArr, long[] jArr2) {
        zzd(jArr, jArr, jArr2);
    }

    private static void zze(long[] jArr, long[] jArr2) {
        if (jArr.length != 19) {
            long[] jArr3 = new long[19];
            System.arraycopy(jArr, 0, jArr3, 0, jArr.length);
            jArr = jArr3;
        }
        zzb(jArr);
        zza(jArr);
        System.arraycopy(jArr, 0, jArr2, 0, 10);
    }

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

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

    public static byte[] zzc(long[] jArr) {
        int i6;
        long[] jArrCopyOf = Arrays.copyOf(jArr, 10);
        int i7 = 0;
        int i8 = 0;
        while (true) {
            if (i8 >= 2) {
                break;
            }
            int i9 = 0;
            while (i9 < 9) {
                long j4 = jArrCopyOf[i9];
                int i10 = zzd[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 (i14 < 2) {
            int i15 = i7;
            while (i15 < 9) {
                long j8 = jArrCopyOf[i15];
                int i16 = i15 & 1;
                int i17 = i7;
                int i18 = (int) (j8 >> zzd[i16]);
                jArrCopyOf[i15] = j8 & ((long) zzc[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 = (((long) ((int) (j9 >> 25))) * 19) + jArrCopyOf[i19];
        jArrCopyOf[i19] = j10;
        int i20 = ~((((int) j10) - 67108845) >> 31);
        for (int i21 = 1; i21 < 10; i21++) {
            int i22 = ~(((int) jArrCopyOf[i21]) ^ zzc[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] << zzb[i28];
        }
        byte[] bArr = new byte[32];
        for (int i29 = i19; i29 < 10; i29++) {
            int i30 = zza[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 void zzb(long[] jArr) {
        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;
    }

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

    public static void zza(long[] jArr, long[] jArr2, long[] jArr3) {
        long[] jArr4 = new long[19];
        zzb(jArr4, jArr2, jArr3);
        zze(jArr4, jArr);
    }

    public static void zza(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 void zza(long[] jArr, long[] jArr2, long j4) {
        for (int i6 = 0; i6 < 10; i6++) {
            jArr[i6] = jArr2[i6] * j4;
        }
    }

    public static long[] zza(byte[] bArr) {
        long[] jArr = new long[10];
        for (int i6 = 0; i6 < 10; i6++) {
            int i7 = zza[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)) >> zzb[i6]) & ((long) zzc[i6 & 1]);
        }
        return jArr;
    }
}