package G3;

import e4.C;
import java.io.IOException;
import java.math.RoundingMode;
import java.util.Objects;

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

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    public static final c f2061c = new c("base64()", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public final a f2062a;

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public final Character f2063b;

    static {
        new c("base64Url()", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_");
        new e("base32()", "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567");
        new e("base32Hex()", "0123456789ABCDEFGHIJKLMNOPQRSTUV");
        new b(new a("base16()", "0123456789ABCDEF".toCharArray()));
    }

    /* JADX WARN: Removed duplicated region for block: B:9:0x001a  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public e(a aVar, Character ch) {
        boolean z6;
        aVar.getClass();
        this.f2062a = aVar;
        if (ch != null) {
            char cCharValue = ch.charValue();
            byte[] bArr = aVar.f2058g;
            z6 = cCharValue >= bArr.length || bArr[cCharValue] == -1;
        }
        A4.g.j(ch, "Padding character %s was already in alphabet", z6);
        this.f2063b = ch;
    }

    public final byte[] a(String str) {
        try {
            CharSequence charSequenceF = f(str);
            int length = (int) (((((long) this.f2062a.f2055d) * ((long) charSequenceF.length())) + 7) / 8);
            byte[] bArr = new byte[length];
            int iB = b(bArr, charSequenceF);
            if (iB == length) {
                return bArr;
            }
            byte[] bArr2 = new byte[iB];
            System.arraycopy(bArr, 0, bArr2, 0, iB);
            return bArr2;
        } catch (d e6) {
            throw new IllegalArgumentException(e6);
        }
    }

    public int b(byte[] bArr, CharSequence charSequence) throws d {
        int i6;
        int i7;
        CharSequence charSequenceF = f(charSequence);
        int length = charSequenceF.length();
        a aVar = this.f2062a;
        if (!aVar.f2059h[length % aVar.f2056e]) {
            throw new d("Invalid input length " + charSequenceF.length());
        }
        int i8 = 0;
        int i9 = 0;
        while (i8 < charSequenceF.length()) {
            long jA = 0;
            int i10 = 0;
            int i11 = 0;
            while (true) {
                i6 = aVar.f2055d;
                i7 = aVar.f2056e;
                if (i10 >= i7) {
                    break;
                }
                jA <<= i6;
                if (i8 + i10 < charSequenceF.length()) {
                    jA |= (long) aVar.a(charSequenceF.charAt(i11 + i8));
                    i11++;
                }
                i10++;
            }
            int i12 = aVar.f2057f;
            int i13 = (i12 * 8) - (i11 * i6);
            int i14 = (i12 - 1) * 8;
            while (i14 >= i13) {
                bArr[i9] = (byte) ((jA >>> i14) & 255);
                i14 -= 8;
                i9++;
            }
            i8 += i7;
        }
        return i9;
    }

    public final String c(byte[] bArr) {
        int length = bArr.length;
        A4.g.q(0, length, bArr.length);
        a aVar = this.f2062a;
        int i6 = aVar.f2056e;
        RoundingMode roundingMode = RoundingMode.CEILING;
        StringBuilder sb = new StringBuilder(C.v(length, aVar.f2057f) * i6);
        try {
            e(sb, bArr, length);
            return sb.toString();
        } catch (IOException e6) {
            throw new AssertionError(e6);
        }
    }

    public final void d(StringBuilder sb, byte[] bArr, int i6, int i7) {
        A4.g.q(i6, i6 + i7, bArr.length);
        a aVar = this.f2062a;
        int i8 = 0;
        A4.g.k(i7 <= aVar.f2057f);
        long j4 = 0;
        for (int i9 = 0; i9 < i7; i9++) {
            j4 = (j4 | ((long) (bArr[i6 + i9] & 255))) << 8;
        }
        int i10 = aVar.f2055d;
        int i11 = ((i7 + 1) * 8) - i10;
        while (i8 < i7 * 8) {
            sb.append(aVar.f2053b[((int) (j4 >>> (i11 - i8))) & aVar.f2054c]);
            i8 += i10;
        }
        Character ch = this.f2063b;
        if (ch != null) {
            while (i8 < aVar.f2057f * 8) {
                sb.append(ch.charValue());
                i8 += i10;
            }
        }
    }

    public void e(StringBuilder sb, byte[] bArr, int i6) {
        int i7 = 0;
        A4.g.q(0, i6, bArr.length);
        while (i7 < i6) {
            a aVar = this.f2062a;
            d(sb, bArr, i7, Math.min(aVar.f2057f, i6 - i7));
            i7 += aVar.f2057f;
        }
    }

    public final boolean equals(Object obj) {
        if (obj instanceof e) {
            e eVar = (e) obj;
            if (this.f2062a.equals(eVar.f2062a) && Objects.equals(this.f2063b, eVar.f2063b)) {
                return true;
            }
        }
        return false;
    }

    public final CharSequence f(CharSequence charSequence) {
        Character ch = this.f2063b;
        if (ch == null) {
            return charSequence;
        }
        char cCharValue = ch.charValue();
        int length = charSequence.length() - 1;
        while (length >= 0 && charSequence.charAt(length) == cCharValue) {
            length--;
        }
        return charSequence.subSequence(0, length + 1);
    }

    public final int hashCode() {
        return this.f2062a.hashCode() ^ Objects.hashCode(this.f2063b);
    }

    public final String toString() {
        StringBuilder sb = new StringBuilder("BaseEncoding.");
        a aVar = this.f2062a;
        sb.append(aVar);
        if (8 % aVar.f2055d != 0) {
            Character ch = this.f2063b;
            if (ch == null) {
                sb.append(".omitPadding()");
            } else {
                sb.append(".withPadChar('");
                sb.append(ch);
                sb.append("')");
            }
        }
        return sb.toString();
    }

    public e(String str, String str2) {
        this(new a(str, str2.toCharArray()), (Character) '=');
    }
}