package com.google.crypto.tink.shaded.protobuf;

import a.AbstractC0386a;
import java.nio.charset.Charset;
import java.util.Arrays;
import n4.u0;

/* JADX INFO: loaded from: classes.dex */
public final class o0 extends android.support.v4.media.session.a {

    /* JADX INFO: renamed from: f, reason: collision with root package name */
    public final /* synthetic */ int f10531f;

    public /* synthetic */ o0(int i) {
        this.f10531f = i;
    }

    public static int y(long j8, byte[] bArr, int i, int i5) {
        if (i5 == 0) {
            android.support.v4.media.session.a aVar = q0.f10539a;
            if (i > -12) {
                return -1;
            }
            return i;
        }
        if (i5 == 1) {
            return q0.c(i, n0.g(j8, bArr));
        }
        if (i5 == 2) {
            return q0.d(i, n0.g(j8, bArr), n0.g(j8 + 1, bArr));
        }
        throw new AssertionError();
    }

    /* JADX WARN: Removed duplicated region for block: B:20:0x0053  */
    @Override // android.support.v4.media.session.a
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final String f(byte[] bArr, int i, int i5) throws B {
        int i8 = i;
        switch (this.f10531f) {
            case u0.f15495q /* 0 */:
                if ((i8 | i5 | ((bArr.length - i8) - i5)) < 0) {
                    throw new ArrayIndexOutOfBoundsException(String.format("buffer length=%d, index=%d, size=%d", Integer.valueOf(bArr.length), Integer.valueOf(i8), Integer.valueOf(i5)));
                }
                int i9 = i8 + i5;
                char[] cArr = new char[i5];
                int i10 = 0;
                while (i8 < i9) {
                    byte b8 = bArr[i8];
                    if (b8 < 0) {
                        while (i8 < i9) {
                            int i11 = i8 + 1;
                            byte b9 = bArr[i8];
                            if (b9 >= 0) {
                                int i12 = i10 + 1;
                                cArr[i10] = (char) b9;
                                while (i11 < i9) {
                                    byte b10 = bArr[i11];
                                    if (b10 >= 0) {
                                        i11++;
                                        cArr[i12] = (char) b10;
                                        i12++;
                                    } else {
                                        i10 = i12;
                                        i8 = i11;
                                    }
                                }
                                i10 = i12;
                                i8 = i11;
                            } else if (b9 < -32) {
                                if (i11 >= i9) {
                                    throw B.b();
                                }
                                i8 += 2;
                                byte b11 = bArr[i11];
                                int i13 = i10 + 1;
                                if (b9 < -62 || AbstractC0386a.t(b11)) {
                                    throw B.b();
                                }
                                cArr[i10] = (char) ((b11 & 63) | ((b9 & 31) << 6));
                                i10 = i13;
                            } else if (b9 < -16) {
                                if (i11 >= i9 - 1) {
                                    throw B.b();
                                }
                                int i14 = i8 + 2;
                                byte b12 = bArr[i11];
                                i8 += 3;
                                byte b13 = bArr[i14];
                                int i15 = i10 + 1;
                                if (AbstractC0386a.t(b12) || ((b9 == -32 && b12 < -96) || ((b9 == -19 && b12 >= -96) || AbstractC0386a.t(b13)))) {
                                    throw B.b();
                                }
                                cArr[i10] = (char) (((b12 & 63) << 6) | ((b9 & 15) << 12) | (b13 & 63));
                                i10 = i15;
                            } else {
                                if (i11 >= i9 - 2) {
                                    throw B.b();
                                }
                                byte b14 = bArr[i11];
                                int i16 = i8 + 3;
                                byte b15 = bArr[i8 + 2];
                                i8 += 4;
                                byte b16 = bArr[i16];
                                int i17 = i10 + 1;
                                if (AbstractC0386a.t(b14) || (((b14 + 112) + (b9 << 28)) >> 30) != 0 || AbstractC0386a.t(b15) || AbstractC0386a.t(b16)) {
                                    throw B.b();
                                }
                                int i18 = ((b14 & 63) << 12) | ((b9 & 7) << 18) | ((b15 & 63) << 6) | (b16 & 63);
                                cArr[i10] = (char) ((i18 >>> 10) + 55232);
                                cArr[i17] = (char) ((i18 & 1023) + 56320);
                                i10 += 2;
                            }
                        }
                        return new String(cArr, 0, i10);
                    }
                    i8++;
                    cArr[i10] = (char) b8;
                    i10++;
                }
                while (i8 < i9) {
                }
                return new String(cArr, 0, i10);
            default:
                Charset charset = AbstractC0759z.f10544a;
                String str = new String(bArr, i8, i5, charset);
                if (str.contains("�") && !Arrays.equals(str.getBytes(charset), Arrays.copyOfRange(bArr, i8, i5 + i8))) {
                    throw B.b();
                }
                return str;
        }
    }

    @Override // android.support.v4.media.session.a
    public final int h(String str, byte[] bArr, int i, int i5) {
        int i8;
        int i9;
        char cCharAt;
        long j8;
        long j9;
        long j10;
        int i10;
        char cCharAt2;
        switch (this.f10531f) {
            case u0.f15495q /* 0 */:
                int length = str.length();
                int i11 = i5 + i;
                int i12 = 0;
                while (i12 < length && (i9 = i12 + i) < i11 && (cCharAt = str.charAt(i12)) < 128) {
                    bArr[i9] = (byte) cCharAt;
                    i12++;
                }
                if (i12 == length) {
                    return i + length;
                }
                int i13 = i + i12;
                while (i12 < length) {
                    char cCharAt3 = str.charAt(i12);
                    if (cCharAt3 < 128 && i13 < i11) {
                        bArr[i13] = (byte) cCharAt3;
                        i13++;
                    } else if (cCharAt3 < 2048 && i13 <= i11 - 2) {
                        int i14 = i13 + 1;
                        bArr[i13] = (byte) ((cCharAt3 >>> 6) | 960);
                        i13 += 2;
                        bArr[i14] = (byte) ((cCharAt3 & '?') | 128);
                    } else {
                        if ((cCharAt3 >= 55296 && 57343 >= cCharAt3) || i13 > i11 - 3) {
                            if (i13 > i11 - 4) {
                                if (55296 <= cCharAt3 && cCharAt3 <= 57343 && ((i8 = i12 + 1) == str.length() || !Character.isSurrogatePair(cCharAt3, str.charAt(i8)))) {
                                    throw new p0(i12, length);
                                }
                                throw new ArrayIndexOutOfBoundsException("Failed writing " + cCharAt3 + " at index " + i13);
                            }
                            int i15 = i12 + 1;
                            if (i15 != str.length()) {
                                char cCharAt4 = str.charAt(i15);
                                if (Character.isSurrogatePair(cCharAt3, cCharAt4)) {
                                    int codePoint = Character.toCodePoint(cCharAt3, cCharAt4);
                                    bArr[i13] = (byte) ((codePoint >>> 18) | 240);
                                    bArr[i13 + 1] = (byte) (((codePoint >>> 12) & 63) | 128);
                                    int i16 = i13 + 3;
                                    bArr[i13 + 2] = (byte) (((codePoint >>> 6) & 63) | 128);
                                    i13 += 4;
                                    bArr[i16] = (byte) ((codePoint & 63) | 128);
                                    i12 = i15;
                                } else {
                                    i12 = i15;
                                }
                            }
                            throw new p0(i12 - 1, length);
                        }
                        bArr[i13] = (byte) ((cCharAt3 >>> '\f') | 480);
                        int i17 = i13 + 2;
                        bArr[i13 + 1] = (byte) (((cCharAt3 >>> 6) & 63) | 128);
                        i13 += 3;
                        bArr[i17] = (byte) ((cCharAt3 & '?') | 128);
                    }
                    i12++;
                }
                return i13;
            default:
                long j11 = i;
                long j12 = ((long) i5) + j11;
                int length2 = str.length();
                if (length2 > i5 || bArr.length - i5 < i) {
                    throw new ArrayIndexOutOfBoundsException("Failed writing " + str.charAt(length2 - 1) + " at index " + (i + i5));
                }
                int i18 = 0;
                while (true) {
                    j8 = 1;
                    if (i18 < length2 && (cCharAt2 = str.charAt(i18)) < 128) {
                        n0.k(bArr, j11, (byte) cCharAt2);
                        i18++;
                        j11 = 1 + j11;
                    }
                }
                if (i18 != length2) {
                    while (i18 < length2) {
                        char cCharAt5 = str.charAt(i18);
                        if (cCharAt5 < 128 && j11 < j12) {
                            n0.k(bArr, j11, (byte) cCharAt5);
                            j10 = j12;
                            j9 = j8;
                            j11 += j8;
                        } else if (cCharAt5 >= 2048 || j11 > j12 - 2) {
                            j9 = j8;
                            if ((cCharAt5 >= 55296 && 57343 >= cCharAt5) || j11 > j12 - 3) {
                                j10 = j12;
                                if (j11 > j10 - 4) {
                                    if (55296 <= cCharAt5 && cCharAt5 <= 57343 && ((i10 = i18 + 1) == length2 || !Character.isSurrogatePair(cCharAt5, str.charAt(i10)))) {
                                        throw new p0(i18, length2);
                                    }
                                    throw new ArrayIndexOutOfBoundsException("Failed writing " + cCharAt5 + " at index " + j11);
                                }
                                int i19 = i18 + 1;
                                if (i19 != length2) {
                                    char cCharAt6 = str.charAt(i19);
                                    if (Character.isSurrogatePair(cCharAt5, cCharAt6)) {
                                        int codePoint2 = Character.toCodePoint(cCharAt5, cCharAt6);
                                        n0.k(bArr, j11, (byte) ((codePoint2 >>> 18) | 240));
                                        n0.k(bArr, j11 + j9, (byte) (((codePoint2 >>> 12) & 63) | 128));
                                        long j13 = j11 + 3;
                                        n0.k(bArr, j11 + 2, (byte) (((codePoint2 >>> 6) & 63) | 128));
                                        j11 += 4;
                                        n0.k(bArr, j13, (byte) ((codePoint2 & 63) | 128));
                                        i18 = i19;
                                    } else {
                                        i18 = i19;
                                    }
                                }
                                throw new p0(i18 - 1, length2);
                            }
                            n0.k(bArr, j11, (byte) ((cCharAt5 >>> '\f') | 480));
                            j10 = j12;
                            long j14 = j11 + 2;
                            n0.k(bArr, j11 + j9, (byte) (((cCharAt5 >>> 6) & 63) | 128));
                            j11 += 3;
                            n0.k(bArr, j14, (byte) ((cCharAt5 & '?') | 128));
                        } else {
                            j9 = j8;
                            long j15 = j11 + j9;
                            n0.k(bArr, j11, (byte) ((cCharAt5 >>> 6) | 960));
                            j11 += 2;
                            n0.k(bArr, j15, (byte) ((cCharAt5 & '?') | 128));
                            j10 = j12;
                        }
                        i18++;
                        j8 = j9;
                        j12 = j10;
                    }
                }
                return (int) j11;
        }
    }

    /* JADX WARN: Code restructure failed: missing block: B:74:0x010c, code lost:
    
        return r21;
     */
    /* JADX WARN: Removed duplicated region for block: B:126:0x0096 A[SYNTHETIC] */
    /* JADX WARN: Removed duplicated region for block: B:149:0x0094 A[SYNTHETIC] */
    /* JADX WARN: Removed duplicated region for block: B:32:0x0085  */
    /* JADX WARN: Removed duplicated region for block: B:38:0x009a  */
    @Override // android.support.v4.media.session.a
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final int r(byte[] bArr, int i, int i5) {
        int i8;
        int i9;
        int i10;
        long j8;
        byte b8;
        long j9;
        byte bG;
        int i11 = i;
        switch (this.f10531f) {
            case u0.f15495q /* 0 */:
                while (i11 < i5 && bArr[i11] >= 0) {
                    i11++;
                }
                if (i11 < i5) {
                    while (i11 < i5) {
                        int i12 = i11 + 1;
                        byte b9 = bArr[i11];
                        if (b9 < 0) {
                            if (b9 < -32) {
                                if (i12 >= i5) {
                                    return b9;
                                }
                                if (b9 >= -62) {
                                    i11 += 2;
                                    if (bArr[i12] > -65) {
                                    }
                                }
                                return -1;
                            }
                            if (b9 < -16) {
                                if (i12 >= i5 - 1) {
                                    return q0.a(bArr, i12, i5);
                                }
                                int i13 = i11 + 2;
                                byte b10 = bArr[i12];
                                if (b10 <= -65 && ((b9 != -32 || b10 >= -96) && (b9 != -19 || b10 < -96))) {
                                    i11 += 3;
                                    if (bArr[i13] > -65) {
                                    }
                                }
                            } else {
                                if (i12 >= i5 - 2) {
                                    return q0.a(bArr, i12, i5);
                                }
                                int i14 = i11 + 2;
                                byte b11 = bArr[i12];
                                if (b11 <= -65 && (((b11 + 112) + (b9 << 28)) >> 30) == 0) {
                                    int i15 = i11 + 3;
                                    if (bArr[i14] <= -65) {
                                        i11 += 4;
                                        if (bArr[i15] > -65) {
                                        }
                                    }
                                }
                            }
                            return -1;
                        }
                        i11 = i12;
                    }
                }
                return 0;
            default:
                if (((bArr.length - i5) | i11 | i5) < 0) {
                    throw new ArrayIndexOutOfBoundsException(String.format("Array length=%d, index=%d, limit=%d", Integer.valueOf(bArr.length), Integer.valueOf(i11), Integer.valueOf(i5)));
                }
                long j10 = i11;
                int i16 = (int) (((long) i5) - j10);
                if (i16 >= 16) {
                    int i17 = 8 - (((int) j10) & 7);
                    long j11 = j10;
                    i8 = 0;
                    while (i8 < i17) {
                        long j12 = j11 + 1;
                        if (n0.g(j11, bArr) >= 0) {
                            i8++;
                            j11 = j12;
                        }
                    }
                    while (true) {
                        int i18 = i8 + 8;
                        if (i18 <= i16) {
                            i9 = -1;
                            if ((n0.f10526c.h(n0.f10529f + j11, bArr) & (-9187201950435737472L)) == 0) {
                                j11 += 8;
                                i8 = i18;
                            }
                        } else {
                            i9 = -1;
                        }
                    }
                    while (true) {
                        if (i8 < i16) {
                            long j13 = j11 + 1;
                            if (n0.g(j11, bArr) >= 0) {
                                i8++;
                                j11 = j13;
                            }
                        } else {
                            i8 = i16;
                        }
                    }
                    i10 = i16 - i8;
                    j8 = j10 + ((long) i8);
                    while (true) {
                        b8 = 0;
                        while (true) {
                            if (i10 <= 0) {
                                j9 = j8 + 1;
                                bG = n0.g(j8, bArr);
                                if (bG >= 0) {
                                    i10--;
                                    j8 = j9;
                                    b8 = bG;
                                } else {
                                    j8 = j9;
                                    b8 = bG;
                                }
                            }
                        }
                        if (i10 != 0) {
                            return 0;
                        }
                        int i19 = i10 - 1;
                        if (b8 < -32) {
                            if (i19 == 0) {
                                return b8;
                            }
                            i10 -= 2;
                            if (b8 >= -62) {
                                long j14 = j8 + 1;
                                if (n0.g(j8, bArr) <= -65) {
                                    j8 = j14;
                                }
                            }
                            break;
                        } else if (b8 < -16) {
                            if (i19 < 2) {
                                return y(j8, bArr, b8, i19);
                            }
                            i10 -= 3;
                            long j15 = j8 + 1;
                            byte bG2 = n0.g(j8, bArr);
                            if (bG2 > -65 || ((b8 == -32 && bG2 < -96) || (b8 == -19 && bG2 >= -96))) {
                                break;
                            } else {
                                j8 += 2;
                                if (n0.g(j15, bArr) > -65) {
                                    break;
                                }
                            }
                        } else {
                            if (i19 < 3) {
                                return y(j8, bArr, b8, i19);
                            }
                            i10 -= 4;
                            long j16 = j8 + 1;
                            byte bG3 = n0.g(j8, bArr);
                            if (bG3 > -65 || (((bG3 + 112) + (b8 << 28)) >> 30) != 0) {
                                break;
                            } else {
                                long j17 = j8 + 2;
                                if (n0.g(j16, bArr) > -65) {
                                    break;
                                } else {
                                    j8 += 3;
                                    if (n0.g(j17, bArr) > -65) {
                                        break;
                                    }
                                }
                            }
                        }
                    }
                } else {
                    i8 = 0;
                }
                i9 = -1;
                i10 = i16 - i8;
                j8 = j10 + ((long) i8);
                while (true) {
                    b8 = 0;
                    while (true) {
                        if (i10 <= 0) {
                        }
                        i10--;
                        j8 = j9;
                        b8 = bG;
                    }
                    if (i10 != 0) {
                    }
                }
                break;
        }
    }
}