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

import androidx.media3.exoplayer.analytics.AnalyticsListener;
import okio.Utf8;
import tv.danmaku.ijk.media.player.IjkMediaMeta;

/* JADX INFO: loaded from: classes2.dex */
public abstract class tc2 {

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

    static {
        if (System.getenv("PROTOBUF_DISABLE_UNSAFE_UTF8_PROCESSOR_FOR_TESTING") == null) {
            if (sc2.f16409e && sc2.f16408d) {
                int i10 = fa2.f11138a;
            }
        }
        f16857a = new en1((dn1) null);
    }

    /* JADX WARN: Multi-variable type inference failed */
    /* JADX WARN: Removed duplicated region for block: B:51:0x007b A[ORIG_RETURN, RETURN] */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public static boolean a(int i10, int i11, byte[] bArr) {
        f16857a.getClass();
        while (i10 < i11 && bArr[i10] >= 0) {
            i10++;
        }
        if (i10 < i11) {
            while (i10 < i11) {
                int i12 = i10 + 1;
                int iE = bArr[i10];
                if (iE >= 0) {
                    i10 = i12;
                } else if (iE < -32) {
                    if (i12 < i11) {
                        if (iE >= -62) {
                            i10 += 2;
                            if (bArr[i12] > -65) {
                            }
                        }
                        return false;
                    }
                    if (iE != 0) {
                        return false;
                    }
                } else if (iE < -16) {
                    if (i12 < i11 - 1) {
                        int i13 = i10 + 2;
                        char c6 = bArr[i12];
                        if (c6 <= -65 && ((iE != -32 || c6 >= -96) && (iE != -19 || c6 < -96))) {
                            i10 += 3;
                            if (bArr[i13] > -65) {
                            }
                        }
                        return false;
                    }
                    iE = e(i12, i11, bArr);
                    if (iE != 0) {
                    }
                } else {
                    if (i12 < i11 - 2) {
                        int i14 = i10 + 2;
                        int i15 = bArr[i12];
                        if (i15 <= -65) {
                            if ((((i15 + 112) + (iE << 28)) >> 30) == 0) {
                                int i16 = i10 + 3;
                                if (bArr[i14] <= -65) {
                                    i10 += 4;
                                    if (bArr[i16] > -65) {
                                    }
                                }
                            }
                        }
                        return false;
                    }
                    iE = e(i12, i11, bArr);
                    if (iE != 0) {
                    }
                }
            }
        }
        return true;
    }

    public static int b(String str) {
        int length = str.length();
        int i10 = 0;
        int i11 = 0;
        while (i11 < length && str.charAt(i11) < 128) {
            i11++;
        }
        int i12 = length;
        while (true) {
            if (i11 >= length) {
                break;
            }
            char cCharAt = str.charAt(i11);
            if (cCharAt < 2048) {
                i12 += (127 - cCharAt) >>> 31;
                i11++;
            } else {
                try {
                    int length2 = str.length();
                    while (i11 < length2) {
                        char cCharAt2 = str.charAt(i11);
                        if (cCharAt2 < 2048) {
                            i10 += (127 - cCharAt2) >>> 31;
                        } else {
                            i10 += 2;
                            if (cCharAt2 >= 55296 && cCharAt2 <= 57343) {
                                if (Character.codePointAt(str, i11) < 65536) {
                                    StringBuilder sb = new StringBuilder(String.valueOf(i11).length() + 32 + String.valueOf(length2).length());
                                    sb.append("Unpaired surrogate at index ");
                                    sb.append(i11);
                                    sb.append(" of ");
                                    sb.append(length2);
                                    throw new zzieq(sb.toString());
                                }
                                i11++;
                            }
                        }
                        i11++;
                    }
                    i12 += i10;
                } catch (zzieq unused) {
                    return str.getBytes(kb2.f13211a).length;
                }
            }
        }
        if (i12 >= length) {
            return i12;
        }
        long j10 = ((long) i12) + IjkMediaMeta.AV_CH_WIDE_RIGHT;
        StringBuilder sb2 = new StringBuilder(String.valueOf(j10).length() + 34);
        sb2.append("UTF-8 length does not fit in int: ");
        sb2.append(j10);
        throw new IllegalArgumentException(sb2.toString());
    }

    public static int c(String str, byte[] bArr, int i10, int i11) {
        int i12;
        int i13;
        int i14;
        char cCharAt;
        int length = str.length();
        int i15 = 0;
        while (true) {
            i12 = i10 + i11;
            if (i15 >= length || (i14 = i15 + i10) >= i12 || (cCharAt = str.charAt(i15)) >= 128) {
                break;
            }
            bArr[i14] = (byte) cCharAt;
            i15++;
        }
        if (i15 != length) {
            int i16 = i10 + i15;
            while (i15 < length) {
                char cCharAt2 = str.charAt(i15);
                if (cCharAt2 < 128 && i16 < i12) {
                    bArr[i16] = (byte) cCharAt2;
                    i16++;
                } else if (cCharAt2 < 2048 && i16 <= i12 - 2) {
                    bArr[i16] = (byte) ((cCharAt2 >>> 6) | 960);
                    bArr[i16 + 1] = (byte) ((cCharAt2 & '?') | 128);
                    i16 += 2;
                } else if ((cCharAt2 < 55296 || cCharAt2 > 57343) && i16 <= i12 - 3) {
                    bArr[i16] = (byte) ((cCharAt2 >>> '\f') | 480);
                    bArr[i16 + 1] = (byte) (((cCharAt2 >>> 6) & 63) | 128);
                    bArr[i16 + 2] = (byte) ((cCharAt2 & '?') | 128);
                    i16 += 3;
                } else if (i16 <= i12 - 4) {
                    i15++;
                    if (i15 != str.length()) {
                        char cCharAt3 = str.charAt(i15);
                        if (Character.isSurrogatePair(cCharAt2, cCharAt3)) {
                            int i17 = i16 + 3;
                            int codePoint = Character.toCodePoint(cCharAt2, cCharAt3);
                            bArr[i16] = (byte) ((codePoint >>> 18) | 240);
                            bArr[i16 + 1] = (byte) (((codePoint >>> 12) & 63) | 128);
                            bArr[i16 + 2] = (byte) (((codePoint >>> 6) & 63) | 128);
                            i16 += 4;
                            bArr[i17] = (byte) ((codePoint & 63) | 128);
                        }
                    }
                    byte[] bytes = str.getBytes(kb2.f13211a);
                    length = bytes.length;
                    if (length - i10 > i11) {
                        throw new ArrayIndexOutOfBoundsException("Not enough space in output buffer to encode UTF-8 string");
                    }
                    System.arraycopy(bytes, 0, bArr, i10, length);
                } else {
                    if (cCharAt2 < 55296 || cCharAt2 > 57343 || ((i13 = i15 + 1) != str.length() && Character.isSurrogatePair(cCharAt2, str.charAt(i13)))) {
                        throw new ArrayIndexOutOfBoundsException("Not enough space in output buffer to encode UTF-8 string");
                    }
                    byte[] bytes2 = str.getBytes(kb2.f13211a);
                    length = bytes2.length;
                    if (length - i10 > i11) {
                        throw new ArrayIndexOutOfBoundsException("Not enough space in output buffer to encode UTF-8 string");
                    }
                    System.arraycopy(bytes2, 0, bArr, i10, length);
                }
                i15++;
            }
            return i16;
        }
        return i10 + length;
    }

    public static String d(int i10, int i11, byte[] bArr) {
        int length = bArr.length;
        if ((((length - i10) - i11) | i10 | i11) < 0) {
            throw new ArrayIndexOutOfBoundsException(String.format("buffer length=%d, index=%d, size=%d", Integer.valueOf(length), Integer.valueOf(i10), Integer.valueOf(i11)));
        }
        int i12 = i10 + i11;
        char[] cArr = new char[i11];
        int i13 = 0;
        while (i10 < i12) {
            byte b10 = bArr[i10];
            if (b10 < 0) {
                break;
            }
            i10++;
            cArr[i13] = (char) b10;
            i13++;
        }
        while (i10 < i12) {
            int i14 = i10 + 1;
            byte b11 = bArr[i10];
            if (b11 >= 0) {
                cArr[i13] = (char) b11;
                i13++;
                i10 = i14;
                while (i10 < i12) {
                    byte b12 = bArr[i10];
                    if (b12 >= 0) {
                        i10++;
                        cArr[i13] = (char) b12;
                        i13++;
                    }
                }
            } else {
                if (b11 >= -32) {
                    if (b11 < -16) {
                        if (i14 >= i12 - 1) {
                            throw new zzicg("Protocol message had invalid UTF-8.");
                        }
                        int i15 = i13 + 1;
                        int i16 = i10 + 2;
                        byte b13 = bArr[i14];
                        i10 += 3;
                        byte b14 = bArr[i16];
                        if (!vj1.o(b13)) {
                            if (b11 == -32) {
                                if (b13 >= -96) {
                                    b11 = -32;
                                }
                            }
                            if (b11 == -19) {
                                if (b13 < -96) {
                                    b11 = -19;
                                }
                            }
                            if (!vj1.o(b14)) {
                                cArr[i13] = (char) (((b13 & Utf8.REPLACEMENT_BYTE) << 6) | ((b11 & 15) << 12) | (b14 & Utf8.REPLACEMENT_BYTE));
                                i13 = i15;
                            }
                        }
                        throw new zzicg("Protocol message had invalid UTF-8.");
                    }
                    if (i14 >= i12 - 2) {
                        throw new zzicg("Protocol message had invalid UTF-8.");
                    }
                    byte b15 = bArr[i14];
                    int i17 = i10 + 3;
                    byte b16 = bArr[i10 + 2];
                    i10 += 4;
                    byte b17 = bArr[i17];
                    if (!vj1.o(b15)) {
                        if ((((b15 + 112) + (b11 << 28)) >> 30) == 0 && !vj1.o(b16) && !vj1.o(b17)) {
                            int i18 = ((b15 & Utf8.REPLACEMENT_BYTE) << 12) | ((b11 & 7) << 18) | ((b16 & Utf8.REPLACEMENT_BYTE) << 6) | (b17 & Utf8.REPLACEMENT_BYTE);
                            cArr[i13] = (char) ((i18 >>> 10) + Utf8.HIGH_SURROGATE_HEADER);
                            cArr[i13 + 1] = (char) ((i18 & AnalyticsListener.EVENT_DRM_KEYS_LOADED) + Utf8.LOG_SURROGATE_HEADER);
                            i13 += 2;
                        }
                    }
                    throw new zzicg("Protocol message had invalid UTF-8.");
                }
                if (i14 >= i12) {
                    throw new zzicg("Protocol message had invalid UTF-8.");
                }
                int i19 = i13 + 1;
                i10 += 2;
                byte b18 = bArr[i14];
                if (b11 < -62 || vj1.o(b18)) {
                    throw new zzicg("Protocol message had invalid UTF-8.");
                }
                cArr[i13] = (char) ((b18 & Utf8.REPLACEMENT_BYTE) | ((b11 & 31) << 6));
                i13 = i19;
            }
        }
        return new String(cArr, 0, i13);
    }

    public static /* synthetic */ int e(int i10, int i11, byte[] bArr) {
        int i12 = i11 - i10;
        byte b10 = bArr[i10 - 1];
        if (i12 == 0) {
            if (b10 <= -12) {
                return b10;
            }
            return -1;
        }
        if (i12 == 1) {
            byte b11 = bArr[i10];
            if (b10 > -12 || b11 > -65) {
                return -1;
            }
            return (b11 << 8) ^ b10;
        }
        if (i12 != 2) {
            throw new AssertionError();
        }
        byte b12 = bArr[i10];
        byte b13 = bArr[i10 + 1];
        if (b10 > -12 || b12 > -65 || b13 > -65) {
            return -1;
        }
        return (b13 << 16) ^ ((b12 << 8) ^ b10);
    }
}