package o;

import com.google.common.base.Ascii;
import com.google.common.primitives.UnsignedBytes;
import com.google.protobuf.InvalidProtocolBufferException;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

/* loaded from: classes2.dex */
public abstract class cKE {
    private static volatile int a = 100;
    int b;
    int c;
    public int d;
    uCO e;
    private boolean i;

    public static long b(long j) {
        return (j >>> 1) ^ (-(1 & j));
    }

    public static int c(int i) {
        return (i >>> 1) ^ (-(i & 1));
    }

    public abstract boolean a() throws IOException;

    public abstract boolean b() throws IOException;

    public abstract boolean b(int i) throws IOException;

    public abstract QwV c() throws IOException;

    public abstract int d();

    public abstract int d(int i) throws InvalidProtocolBufferException;

    public abstract void e() throws InvalidProtocolBufferException;

    public abstract void e(int i);

    public abstract double f() throws IOException;

    public abstract long g() throws IOException;

    public abstract int h() throws IOException;

    public abstract float i() throws IOException;

    public abstract int j() throws IOException;

    public abstract long k() throws IOException;

    public abstract int l() throws IOException;

    public abstract int m() throws IOException;

    abstract long n() throws IOException;

    public abstract long o() throws IOException;

    public abstract long p() throws IOException;

    public abstract int q() throws IOException;

    public abstract String r() throws IOException;

    public abstract int s() throws IOException;

    public abstract String t() throws IOException;

    public abstract long v() throws IOException;

    public abstract int y() throws IOException;

    /* synthetic */ cKE(byte b) {
        this();
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public static cKE a(Iterable<ByteBuffer> iterable) {
        int i = 0;
        int i2 = 0;
        for (ByteBuffer byteBuffer : iterable) {
            i2 += byteBuffer.remaining();
            if (byteBuffer.hasArray()) {
                i |= 1;
            } else {
                i = byteBuffer.isDirect() ? i | 2 : i | 4;
            }
        }
        if (i == 2) {
            return new RVV(iterable, i2);
        }
        return new LWm(new MZr(iterable));
    }

    public static cKE a(byte[] bArr) {
        int length = bArr.length;
        return c(bArr, 0, 0, false);
    }

    public static cKE a(byte[] bArr, int i, int i2) {
        return c(bArr, 0, i2, false);
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public static cKE c(byte[] bArr, int i, int i2, boolean z) {
        HBt hBt = new HBt(bArr, i, i2, z, (byte) 0);
        try {
            hBt.d(i2);
            return hBt;
        } catch (InvalidProtocolBufferException e) {
            throw new IllegalArgumentException(e);
        }
    }

    private cKE() {
        this.c = a;
        this.d = Integer.MAX_VALUE;
        this.i = false;
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes2.dex */
    public static final class HBt extends cKE {
        private final byte[] a;
        private int f;
        private int g;
        private int h;
        private final boolean i;
        private boolean j;
        private int l;
        private int n;

        /* renamed from: o, reason: collision with root package name */
        private int f8607o;

        /* synthetic */ HBt(byte[] bArr, int i, int i2, boolean z, byte b) {
            this(bArr, i, i2, z);
        }

        private HBt(byte[] bArr, int i, int i2, boolean z) {
            super((byte) 0);
            this.f = Integer.MAX_VALUE;
            this.a = bArr;
            this.n = i2 + i;
            this.l = i;
            this.f8607o = i;
            this.i = z;
        }

        @Override // o.cKE
        public final void e() throws InvalidProtocolBufferException {
            if (this.g != 0) {
                throw InvalidProtocolBufferException.c();
            }
        }

        @Override // o.cKE
        public final boolean b(int i) throws IOException {
            int s;
            int c = Nvr.c(i);
            int i2 = 0;
            if (c == 0) {
                if (this.n - this.l >= 10) {
                    while (i2 < 10) {
                        byte[] bArr = this.a;
                        int i3 = this.l;
                        this.l = i3 + 1;
                        if (bArr[i3] < 0) {
                            i2++;
                        }
                    }
                    throw InvalidProtocolBufferException.b();
                }
                while (i2 < 10) {
                    if (x() < 0) {
                        i2++;
                    }
                }
                throw InvalidProtocolBufferException.b();
                return true;
            }
            if (c == 1) {
                a(8);
                return true;
            }
            if (c == 2) {
                a(A());
                return true;
            }
            if (c != 3) {
                if (c == 4) {
                    return false;
                }
                if (c == 5) {
                    a(4);
                    return true;
                }
                throw InvalidProtocolBufferException.e();
            }
            do {
                s = s();
                if (s == 0) {
                    break;
                }
            } while (b(s));
            if (this.g == Nvr.c(Nvr.b(i), 4)) {
                return true;
            }
            throw InvalidProtocolBufferException.c();
        }

        @Override // o.cKE
        public final double f() throws IOException {
            return Double.longBitsToDouble(C());
        }

        @Override // o.cKE
        public final float i() throws IOException {
            return Float.intBitsToFloat(w());
        }

        @Override // o.cKE
        public final long v() throws IOException {
            return z();
        }

        @Override // o.cKE
        public final long k() throws IOException {
            return z();
        }

        @Override // o.cKE
        public final int l() throws IOException {
            return A();
        }

        @Override // o.cKE
        public final long g() throws IOException {
            return C();
        }

        @Override // o.cKE
        public final int j() throws IOException {
            return w();
        }

        @Override // o.cKE
        public final boolean b() throws IOException {
            return z() != 0;
        }

        @Override // o.cKE
        public final String t() throws IOException {
            int A = A();
            if (A > 0) {
                int i = this.n;
                int i2 = this.l;
                if (A <= i - i2) {
                    String str = new String(this.a, i2, A, MTP.b);
                    this.l += A;
                    return str;
                }
            }
            if (A == 0) {
                return "";
            }
            if (A < 0) {
                throw InvalidProtocolBufferException.i();
            }
            throw InvalidProtocolBufferException.g();
        }

        @Override // o.cKE
        public final String r() throws IOException {
            int A = A();
            if (A > 0) {
                int i = this.n;
                int i2 = this.l;
                if (A <= i - i2) {
                    String d = C16752qto.d(this.a, i2, A);
                    this.l += A;
                    return d;
                }
            }
            if (A == 0) {
                return "";
            }
            if (A <= 0) {
                throw InvalidProtocolBufferException.i();
            }
            throw InvalidProtocolBufferException.g();
        }

        @Override // o.cKE
        public final QwV c() throws IOException {
            byte[] bArr;
            int A = A();
            if (A > 0) {
                int i = this.n;
                int i2 = this.l;
                if (A <= i - i2) {
                    QwV c = QwV.c(this.a, i2, A);
                    this.l += A;
                    return c;
                }
            }
            if (A == 0) {
                return QwV.a;
            }
            if (A > 0) {
                int i3 = this.n;
                int i4 = this.l;
                if (A <= i3 - i4) {
                    int i5 = A + i4;
                    this.l = i5;
                    bArr = Arrays.copyOfRange(this.a, i4, i5);
                    return QwV.d(bArr);
                }
            }
            if (A > 0) {
                throw InvalidProtocolBufferException.g();
            }
            if (A == 0) {
                bArr = MTP.e;
                return QwV.d(bArr);
            }
            throw InvalidProtocolBufferException.i();
        }

        @Override // o.cKE
        public final int y() throws IOException {
            return A();
        }

        @Override // o.cKE
        public final int h() throws IOException {
            return A();
        }

        @Override // o.cKE
        public final int m() throws IOException {
            return w();
        }

        @Override // o.cKE
        public final long o() throws IOException {
            return C();
        }

        @Override // o.cKE
        public final int q() throws IOException {
            int A = A();
            return (A >>> 1) ^ (-(A & 1));
        }

        @Override // o.cKE
        public final long p() throws IOException {
            long z = z();
            return (z >>> 1) ^ (-(1 & z));
        }

        private int A() throws IOException {
            int i;
            int i2 = this.l;
            int i3 = this.n;
            if (i3 != i2) {
                byte[] bArr = this.a;
                int i4 = i2 + 1;
                byte b = bArr[i2];
                if (b >= 0) {
                    this.l = i4;
                    return b;
                }
                if (i3 - i4 >= 9) {
                    int i5 = i2 + 2;
                    int i6 = (bArr[i4] << 7) ^ b;
                    if (i6 < 0) {
                        i = i6 ^ (-128);
                    } else {
                        int i7 = i2 + 3;
                        int i8 = (bArr[i5] << 14) ^ i6;
                        if (i8 >= 0) {
                            i = i8 ^ 16256;
                        } else {
                            int i9 = i2 + 4;
                            int i10 = i8 ^ (bArr[i7] << Ascii.NAK);
                            if (i10 < 0) {
                                i = (-2080896) ^ i10;
                            } else {
                                i7 = i2 + 5;
                                byte b2 = bArr[i9];
                                int i11 = (i10 ^ (b2 << 28)) ^ 266354560;
                                if (b2 < 0) {
                                    i9 = i2 + 6;
                                    if (bArr[i7] < 0) {
                                        i7 = i2 + 7;
                                        if (bArr[i9] < 0) {
                                            i9 = i2 + 8;
                                            if (bArr[i7] < 0) {
                                                i7 = i2 + 9;
                                                if (bArr[i9] < 0) {
                                                    if (bArr[i7] >= 0) {
                                                        i5 = i2 + 10;
                                                        i = i11;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    i = i11;
                                }
                                i = i11;
                            }
                            i5 = i9;
                        }
                        i5 = i7;
                    }
                    this.l = i5;
                    return i;
                }
            }
            return (int) n();
        }

        private long z() throws IOException {
            long j;
            long j2;
            long j3;
            int i = this.l;
            int i2 = this.n;
            if (i2 != i) {
                byte[] bArr = this.a;
                int i3 = i + 1;
                byte b = bArr[i];
                if (b >= 0) {
                    this.l = i3;
                    return b;
                }
                if (i2 - i3 >= 9) {
                    int i4 = i + 2;
                    int i5 = (bArr[i3] << 7) ^ b;
                    if (i5 < 0) {
                        j = i5 ^ (-128);
                    } else {
                        int i6 = i + 3;
                        int i7 = (bArr[i4] << 14) ^ i5;
                        if (i7 >= 0) {
                            j = i7 ^ 16256;
                            i4 = i6;
                        } else {
                            int i8 = i + 4;
                            int i9 = i7 ^ (bArr[i6] << Ascii.NAK);
                            if (i9 < 0) {
                                long j4 = (-2080896) ^ i9;
                                i4 = i8;
                                j = j4;
                            } else {
                                long j5 = i9;
                                i4 = i + 5;
                                long j6 = j5 ^ (bArr[i8] << 28);
                                if (j6 >= 0) {
                                    j3 = 266354560;
                                } else {
                                    int i10 = i + 6;
                                    long j7 = j6 ^ (bArr[i4] << 35);
                                    if (j7 < 0) {
                                        j2 = -34093383808L;
                                    } else {
                                        i4 = i + 7;
                                        j6 = j7 ^ (bArr[i10] << 42);
                                        if (j6 >= 0) {
                                            j3 = 4363953127296L;
                                        } else {
                                            i10 = i + 8;
                                            j7 = j6 ^ (bArr[i4] << 49);
                                            if (j7 < 0) {
                                                j2 = -558586000294016L;
                                            } else {
                                                i4 = i + 9;
                                                long j8 = (j7 ^ (bArr[i10] << 56)) ^ 71499008037633920L;
                                                if (j8 < 0) {
                                                    if (bArr[i4] >= 0) {
                                                        i4 = i + 10;
                                                    }
                                                }
                                                j = j8;
                                            }
                                        }
                                    }
                                    j = j7 ^ j2;
                                    i4 = i10;
                                }
                                j = j6 ^ j3;
                            }
                        }
                    }
                    this.l = i4;
                    return j;
                }
            }
            return n();
        }

        @Override // o.cKE
        final long n() throws IOException {
            long j = 0;
            for (int i = 0; i < 64; i += 7) {
                j |= (r3 & Ascii.DEL) << i;
                if ((x() & 128) == 0) {
                    return j;
                }
            }
            throw InvalidProtocolBufferException.b();
        }

        private int w() throws IOException {
            int i = this.l;
            if (this.n - i < 4) {
                throw InvalidProtocolBufferException.g();
            }
            byte[] bArr = this.a;
            this.l = i + 4;
            return ((bArr[i + 3] & UnsignedBytes.MAX_VALUE) << 24) | (bArr[i] & UnsignedBytes.MAX_VALUE) | ((bArr[i + 1] & UnsignedBytes.MAX_VALUE) << 8) | ((bArr[i + 2] & UnsignedBytes.MAX_VALUE) << 16);
        }

        private long C() throws IOException {
            int i = this.l;
            if (this.n - i < 8) {
                throw InvalidProtocolBufferException.g();
            }
            byte[] bArr = this.a;
            this.l = i + 8;
            return ((bArr[i + 7] & 255) << 56) | (bArr[i] & 255) | ((bArr[i + 1] & 255) << 8) | ((bArr[i + 2] & 255) << 16) | ((bArr[i + 3] & 255) << 24) | ((bArr[i + 4] & 255) << 32) | ((bArr[i + 5] & 255) << 40) | ((bArr[i + 6] & 255) << 48);
        }

        @Override // o.cKE
        public final void e(int i) {
            this.f = i;
            u();
        }

        private byte x() throws IOException {
            int i = this.l;
            if (i == this.n) {
                throw InvalidProtocolBufferException.g();
            }
            byte[] bArr = this.a;
            this.l = i + 1;
            return bArr[i];
        }

        private void a(int i) throws IOException {
            if (i >= 0) {
                int i2 = this.n;
                int i3 = this.l;
                if (i <= i2 - i3) {
                    this.l = i3 + i;
                    return;
                }
            }
            if (i < 0) {
                throw InvalidProtocolBufferException.i();
            }
            throw InvalidProtocolBufferException.g();
        }

        @Override // o.cKE
        public final int d(int i) throws InvalidProtocolBufferException {
            if (i < 0) {
                throw InvalidProtocolBufferException.i();
            }
            int i2 = i + (this.l - this.f8607o);
            if (i2 >= 0) {
                int i3 = this.f;
                if (i2 > i3) {
                    throw InvalidProtocolBufferException.g();
                }
                this.f = i2;
                u();
                return i3;
            }
            throw InvalidProtocolBufferException.f();
        }

        @Override // o.cKE
        public final int s() throws IOException {
            if (this.l == this.n) {
                this.g = 0;
                return 0;
            }
            int A = A();
            this.g = A;
            if (Nvr.b(A) != 0) {
                return this.g;
            }
            throw InvalidProtocolBufferException.d();
        }

        @Override // o.cKE
        public final boolean a() throws IOException {
            return this.l == this.n;
        }

        @Override // o.cKE
        public final int d() {
            return this.l - this.f8607o;
        }

        private void u() {
            int i = this.n + this.h;
            this.n = i;
            int i2 = i - this.f8607o;
            int i3 = this.f;
            if (i2 <= i3) {
                this.h = 0;
                return;
            }
            int i4 = i2 - i3;
            this.h = i4;
            this.n = i - i4;
        }
    }

    public static cKE e(InputStream inputStream) {
        if (inputStream == null) {
            byte[] bArr = MTP.e;
            return c(bArr, 0, bArr.length, false);
        }
        return new LWm(inputStream);
    }

    /* loaded from: classes2.dex */
    static final class LWm extends cKE {
        private final byte[] a;
        private final InputStream f;
        private int g;
        private int h;
        private int i;
        private int j;
        private int k;
        private int m;
        private HBt n;

        /* loaded from: classes2.dex */
        interface HBt {
        }

        /* synthetic */ LWm(InputStream inputStream) {
            this(inputStream, 4096);
        }

        private LWm(InputStream inputStream, int i) {
            super((byte) 0);
            this.i = Integer.MAX_VALUE;
            this.n = null;
            MTP.c(inputStream, "input");
            this.f = inputStream;
            this.a = new byte[4096];
            this.j = 0;
            this.k = 0;
            this.m = 0;
        }

        private static int b(InputStream inputStream, byte[] bArr, int i, int i2) throws IOException {
            try {
                return inputStream.read(bArr, i, i2);
            } catch (InvalidProtocolBufferException e) {
                e.e = true;
                throw e;
            }
        }

        private static long d(InputStream inputStream, long j) throws IOException {
            try {
                return inputStream.skip(j);
            } catch (InvalidProtocolBufferException e) {
                e.e = true;
                throw e;
            }
        }

        private static int d(InputStream inputStream) throws IOException {
            try {
                return inputStream.available();
            } catch (InvalidProtocolBufferException e) {
                e.e = true;
                throw e;
            }
        }

        @Override // o.cKE
        public final int s() throws IOException {
            if (this.k == this.j && !h(1)) {
                this.g = 0;
                return 0;
            }
            int D = D();
            this.g = D;
            if (Nvr.b(D) != 0) {
                return this.g;
            }
            throw InvalidProtocolBufferException.d();
        }

        @Override // o.cKE
        public final void e() throws InvalidProtocolBufferException {
            if (this.g != 0) {
                throw InvalidProtocolBufferException.c();
            }
        }

        @Override // o.cKE
        public final boolean b(int i) throws IOException {
            int s;
            int c = Nvr.c(i);
            int i2 = 0;
            if (c == 0) {
                if (this.j - this.k >= 10) {
                    while (i2 < 10) {
                        byte[] bArr = this.a;
                        int i3 = this.k;
                        this.k = i3 + 1;
                        if (bArr[i3] < 0) {
                            i2++;
                        }
                    }
                    throw InvalidProtocolBufferException.b();
                }
                while (i2 < 10) {
                    if (u() < 0) {
                        i2++;
                    }
                }
                throw InvalidProtocolBufferException.b();
                return true;
            }
            if (c == 1) {
                o(8);
                return true;
            }
            if (c == 2) {
                o(D());
                return true;
            }
            if (c != 3) {
                if (c == 4) {
                    return false;
                }
                if (c == 5) {
                    o(4);
                    return true;
                }
                throw InvalidProtocolBufferException.e();
            }
            do {
                s = s();
                if (s == 0) {
                    break;
                }
            } while (b(s));
            if (this.g == Nvr.c(Nvr.b(i), 4)) {
                return true;
            }
            throw InvalidProtocolBufferException.c();
        }

        @Override // o.cKE
        public final double f() throws IOException {
            return Double.longBitsToDouble(z());
        }

        @Override // o.cKE
        public final float i() throws IOException {
            return Float.intBitsToFloat(x());
        }

        @Override // o.cKE
        public final long v() throws IOException {
            return B();
        }

        @Override // o.cKE
        public final long k() throws IOException {
            return B();
        }

        @Override // o.cKE
        public final int l() throws IOException {
            return D();
        }

        @Override // o.cKE
        public final long g() throws IOException {
            return z();
        }

        @Override // o.cKE
        public final int j() throws IOException {
            return x();
        }

        @Override // o.cKE
        public final boolean b() throws IOException {
            return B() != 0;
        }

        @Override // o.cKE
        public final String t() throws IOException {
            int D = D();
            if (D > 0) {
                int i = this.j;
                int i2 = this.k;
                if (D <= i - i2) {
                    String str = new String(this.a, i2, D, MTP.b);
                    this.k += D;
                    return str;
                }
            }
            if (D == 0) {
                return "";
            }
            if (D <= this.j) {
                i(D);
                String str2 = new String(this.a, this.k, D, MTP.b);
                this.k += D;
                return str2;
            }
            return new String(a(D), MTP.b);
        }

        @Override // o.cKE
        public final String r() throws IOException {
            byte[] a;
            int D = D();
            int i = this.k;
            int i2 = this.j;
            if (D <= i2 - i && D > 0) {
                a = this.a;
                this.k = i + D;
            } else {
                if (D == 0) {
                    return "";
                }
                i = 0;
                if (D <= i2) {
                    i(D);
                    a = this.a;
                    this.k = D;
                } else {
                    a = a(D);
                }
            }
            return C16752qto.d(a, i, D);
        }

        @Override // o.cKE
        public final QwV c() throws IOException {
            int D = D();
            int i = this.j;
            int i2 = this.k;
            if (D <= i - i2 && D > 0) {
                QwV c = QwV.c(this.a, i2, D);
                this.k += D;
                return c;
            }
            if (D == 0) {
                return QwV.a;
            }
            byte[] j = j(D);
            if (j != null) {
                return QwV.b(j);
            }
            int i3 = this.k;
            int i4 = this.j;
            int i5 = i4 - i3;
            this.m += i4;
            this.k = 0;
            this.j = 0;
            List<byte[]> f = f(D - i5);
            byte[] bArr = new byte[D];
            System.arraycopy(this.a, i3, bArr, 0, i5);
            for (byte[] bArr2 : f) {
                System.arraycopy(bArr2, 0, bArr, i5, bArr2.length);
                i5 += bArr2.length;
            }
            return QwV.d(bArr);
        }

        @Override // o.cKE
        public final int y() throws IOException {
            return D();
        }

        @Override // o.cKE
        public final int h() throws IOException {
            return D();
        }

        @Override // o.cKE
        public final int m() throws IOException {
            return x();
        }

        @Override // o.cKE
        public final long o() throws IOException {
            return z();
        }

        @Override // o.cKE
        public final int q() throws IOException {
            int D = D();
            return (D >>> 1) ^ (-(D & 1));
        }

        @Override // o.cKE
        public final long p() throws IOException {
            long B = B();
            return (B >>> 1) ^ (-(1 & B));
        }

        private int D() throws IOException {
            int i;
            int i2 = this.k;
            int i3 = this.j;
            if (i3 != i2) {
                byte[] bArr = this.a;
                int i4 = i2 + 1;
                byte b = bArr[i2];
                if (b >= 0) {
                    this.k = i4;
                    return b;
                }
                if (i3 - i4 >= 9) {
                    int i5 = i2 + 2;
                    int i6 = (bArr[i4] << 7) ^ b;
                    if (i6 < 0) {
                        i = i6 ^ (-128);
                    } else {
                        int i7 = i2 + 3;
                        int i8 = (bArr[i5] << 14) ^ i6;
                        if (i8 >= 0) {
                            i = i8 ^ 16256;
                        } else {
                            int i9 = i2 + 4;
                            int i10 = i8 ^ (bArr[i7] << Ascii.NAK);
                            if (i10 < 0) {
                                i = (-2080896) ^ i10;
                            } else {
                                i7 = i2 + 5;
                                byte b2 = bArr[i9];
                                int i11 = (i10 ^ (b2 << 28)) ^ 266354560;
                                if (b2 < 0) {
                                    i9 = i2 + 6;
                                    if (bArr[i7] < 0) {
                                        i7 = i2 + 7;
                                        if (bArr[i9] < 0) {
                                            i9 = i2 + 8;
                                            if (bArr[i7] < 0) {
                                                i7 = i2 + 9;
                                                if (bArr[i9] < 0) {
                                                    if (bArr[i7] >= 0) {
                                                        i5 = i2 + 10;
                                                        i = i11;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    i = i11;
                                }
                                i = i11;
                            }
                            i5 = i9;
                        }
                        i5 = i7;
                    }
                    this.k = i5;
                    return i;
                }
            }
            return (int) n();
        }

        private long B() throws IOException {
            long j;
            long j2;
            long j3;
            int i = this.k;
            int i2 = this.j;
            if (i2 != i) {
                byte[] bArr = this.a;
                int i3 = i + 1;
                byte b = bArr[i];
                if (b >= 0) {
                    this.k = i3;
                    return b;
                }
                if (i2 - i3 >= 9) {
                    int i4 = i + 2;
                    int i5 = (bArr[i3] << 7) ^ b;
                    if (i5 < 0) {
                        j = i5 ^ (-128);
                    } else {
                        int i6 = i + 3;
                        int i7 = (bArr[i4] << 14) ^ i5;
                        if (i7 >= 0) {
                            j = i7 ^ 16256;
                            i4 = i6;
                        } else {
                            int i8 = i + 4;
                            int i9 = i7 ^ (bArr[i6] << Ascii.NAK);
                            if (i9 < 0) {
                                long j4 = (-2080896) ^ i9;
                                i4 = i8;
                                j = j4;
                            } else {
                                long j5 = i9;
                                i4 = i + 5;
                                long j6 = j5 ^ (bArr[i8] << 28);
                                if (j6 >= 0) {
                                    j3 = 266354560;
                                } else {
                                    int i10 = i + 6;
                                    long j7 = j6 ^ (bArr[i4] << 35);
                                    if (j7 < 0) {
                                        j2 = -34093383808L;
                                    } else {
                                        i4 = i + 7;
                                        j6 = j7 ^ (bArr[i10] << 42);
                                        if (j6 >= 0) {
                                            j3 = 4363953127296L;
                                        } else {
                                            i10 = i + 8;
                                            j7 = j6 ^ (bArr[i4] << 49);
                                            if (j7 < 0) {
                                                j2 = -558586000294016L;
                                            } else {
                                                i4 = i + 9;
                                                long j8 = (j7 ^ (bArr[i10] << 56)) ^ 71499008037633920L;
                                                if (j8 < 0) {
                                                    if (bArr[i4] >= 0) {
                                                        i4 = i + 10;
                                                    }
                                                }
                                                j = j8;
                                            }
                                        }
                                    }
                                    j = j7 ^ j2;
                                    i4 = i10;
                                }
                                j = j6 ^ j3;
                            }
                        }
                    }
                    this.k = i4;
                    return j;
                }
            }
            return n();
        }

        @Override // o.cKE
        final long n() throws IOException {
            long j = 0;
            for (int i = 0; i < 64; i += 7) {
                j |= (r3 & Ascii.DEL) << i;
                if ((u() & 128) == 0) {
                    return j;
                }
            }
            throw InvalidProtocolBufferException.b();
        }

        private int x() throws IOException {
            int i = this.k;
            if (this.j - i < 4) {
                i(4);
                i = this.k;
            }
            byte[] bArr = this.a;
            this.k = i + 4;
            return ((bArr[i + 3] & UnsignedBytes.MAX_VALUE) << 24) | (bArr[i] & UnsignedBytes.MAX_VALUE) | ((bArr[i + 1] & UnsignedBytes.MAX_VALUE) << 8) | ((bArr[i + 2] & UnsignedBytes.MAX_VALUE) << 16);
        }

        private long z() throws IOException {
            int i = this.k;
            if (this.j - i < 8) {
                i(8);
                i = this.k;
            }
            byte[] bArr = this.a;
            this.k = i + 8;
            return ((bArr[i + 7] & 255) << 56) | (bArr[i] & 255) | ((bArr[i + 1] & 255) << 8) | ((bArr[i + 2] & 255) << 16) | ((bArr[i + 3] & 255) << 24) | ((bArr[i + 4] & 255) << 32) | ((bArr[i + 5] & 255) << 40) | ((bArr[i + 6] & 255) << 48);
        }

        @Override // o.cKE
        public final int d(int i) throws InvalidProtocolBufferException {
            if (i < 0) {
                throw InvalidProtocolBufferException.i();
            }
            int i2 = i + this.m + this.k;
            int i3 = this.i;
            if (i2 > i3) {
                throw InvalidProtocolBufferException.g();
            }
            this.i = i2;
            w();
            return i3;
        }

        @Override // o.cKE
        public final void e(int i) {
            this.i = i;
            w();
        }

        @Override // o.cKE
        public final boolean a() throws IOException {
            return this.k == this.j && !h(1);
        }

        private void i(int i) throws IOException {
            if (h(i)) {
                return;
            }
            if (i > (this.d - this.m) - this.k) {
                throw InvalidProtocolBufferException.j();
            }
            throw InvalidProtocolBufferException.g();
        }

        private boolean h(int i) throws IOException {
            if (this.k + i <= this.j) {
                StringBuilder sb = new StringBuilder("refillBuffer() called when ");
                sb.append(i);
                sb.append(" bytes were already available in buffer");
                throw new IllegalStateException(sb.toString());
            }
            int i2 = this.d;
            int i3 = this.m;
            int i4 = this.k;
            if (i > (i2 - i3) - i4 || i3 + i4 + i > this.i) {
                return false;
            }
            if (i4 > 0) {
                int i5 = this.j;
                if (i5 > i4) {
                    byte[] bArr = this.a;
                    System.arraycopy(bArr, i4, bArr, 0, i5 - i4);
                }
                this.m += i4;
                this.j -= i4;
                this.k = 0;
            }
            InputStream inputStream = this.f;
            byte[] bArr2 = this.a;
            int i6 = this.j;
            int b = b(inputStream, bArr2, i6, Math.min(bArr2.length - i6, (this.d - this.m) - this.j));
            if (b == 0 || b < -1 || b > this.a.length) {
                StringBuilder sb2 = new StringBuilder();
                sb2.append(this.f.getClass());
                sb2.append("#read(byte[]) returned invalid result: ");
                sb2.append(b);
                sb2.append("\nThe InputStream implementation is buggy.");
                throw new IllegalStateException(sb2.toString());
            }
            if (b <= 0) {
                return false;
            }
            this.j += b;
            w();
            if (this.j >= i) {
                return true;
            }
            return h(i);
        }

        private byte u() throws IOException {
            if (this.k == this.j) {
                i(1);
            }
            byte[] bArr = this.a;
            int i = this.k;
            this.k = i + 1;
            return bArr[i];
        }

        private byte[] a(int i) throws IOException {
            byte[] j = j(i);
            if (j != null) {
                return j;
            }
            int i2 = this.k;
            int i3 = this.j;
            int i4 = i3 - i2;
            this.m += i3;
            this.k = 0;
            this.j = 0;
            List<byte[]> f = f(i - i4);
            byte[] bArr = new byte[i];
            System.arraycopy(this.a, i2, bArr, 0, i4);
            for (byte[] bArr2 : f) {
                System.arraycopy(bArr2, 0, bArr, i4, bArr2.length);
                i4 += bArr2.length;
            }
            return bArr;
        }

        private byte[] j(int i) throws IOException {
            if (i == 0) {
                return MTP.e;
            }
            if (i < 0) {
                throw InvalidProtocolBufferException.i();
            }
            int i2 = this.m + this.k + i;
            if (i2 - this.d > 0) {
                throw InvalidProtocolBufferException.j();
            }
            int i3 = this.i;
            if (i2 > i3) {
                o((i3 - this.m) - this.k);
                throw InvalidProtocolBufferException.g();
            }
            int i4 = this.j - this.k;
            int i5 = i - i4;
            if (i5 >= 4096 && i5 > d(this.f)) {
                return null;
            }
            byte[] bArr = new byte[i];
            System.arraycopy(this.a, this.k, bArr, 0, i4);
            this.m += this.j;
            this.k = 0;
            this.j = 0;
            while (i4 < i) {
                int b = b(this.f, bArr, i4, i - i4);
                if (b == -1) {
                    throw InvalidProtocolBufferException.g();
                }
                this.m += b;
                i4 += b;
            }
            return bArr;
        }

        private List<byte[]> f(int i) throws IOException {
            ArrayList arrayList = new ArrayList();
            while (i > 0) {
                int min = Math.min(i, 4096);
                byte[] bArr = new byte[min];
                int i2 = 0;
                while (i2 < min) {
                    int read = this.f.read(bArr, i2, min - i2);
                    if (read == -1) {
                        throw InvalidProtocolBufferException.g();
                    }
                    this.m += read;
                    i2 += read;
                }
                i -= min;
                arrayList.add(bArr);
            }
            return arrayList;
        }

        private void o(int i) throws IOException {
            int i2 = this.j;
            int i3 = this.k;
            if (i > i2 - i3 || i < 0) {
                g(i);
            } else {
                this.k = i3 + i;
            }
        }

        private void g(int i) throws IOException {
            if (i < 0) {
                throw InvalidProtocolBufferException.i();
            }
            int i2 = this.m;
            int i3 = this.k;
            int i4 = this.i;
            int i5 = i2 + i3;
            if (i5 + i > i4) {
                o((i4 - i2) - i3);
                throw InvalidProtocolBufferException.g();
            }
            this.m = i5;
            int i6 = this.j;
            this.j = 0;
            this.k = 0;
            int i7 = i6 - i3;
            while (i7 < i) {
                try {
                    long j = i - i7;
                    long d = d(this.f, j);
                    if (d >= 0 && d <= j) {
                        if (d == 0) {
                            break;
                        } else {
                            i7 += (int) d;
                        }
                    } else {
                        StringBuilder sb = new StringBuilder();
                        sb.append(this.f.getClass());
                        sb.append("#skip returned invalid result: ");
                        sb.append(d);
                        sb.append("\nThe InputStream implementation is buggy.");
                        throw new IllegalStateException(sb.toString());
                    }
                } finally {
                    this.m += i7;
                    w();
                }
            }
            if (i7 >= i) {
                return;
            }
            int i8 = this.j;
            int i9 = i8 - this.k;
            this.k = i8;
            i(1);
            while (true) {
                int i10 = i - i9;
                int i11 = this.j;
                if (i10 <= i11) {
                    this.k = i10;
                    return;
                } else {
                    i9 += i11;
                    this.k = i11;
                    i(1);
                }
            }
        }

        @Override // o.cKE
        public final int d() {
            return this.m + this.k;
        }

        private void w() {
            int i = this.j + this.h;
            this.j = i;
            int i2 = this.m + i;
            int i3 = this.i;
            if (i2 <= i3) {
                this.h = 0;
                return;
            }
            int i4 = i2 - i3;
            this.h = i4;
            this.j = i - i4;
        }
    }

    /* loaded from: classes2.dex */
    static final class RVV extends cKE {
        private int a;
        private ByteBuffer f;
        private long g;
        private long h;
        private long i;
        private long j;
        private final boolean k;
        private int l;
        private boolean m;
        private final Iterator<ByteBuffer> n;

        /* renamed from: o, reason: collision with root package name */
        private final Iterable<ByteBuffer> f8608o;
        private int p;
        private int r;
        private int s;
        private int t;

        /* synthetic */ RVV(Iterable iterable, int i) {
            this(iterable, i, true);
        }

        private RVV(Iterable<ByteBuffer> iterable, int i, boolean z) {
            super((byte) 0);
            this.l = Integer.MAX_VALUE;
            this.t = i;
            this.f8608o = iterable;
            this.n = iterable.iterator();
            this.k = true;
            this.r = 0;
            this.s = 0;
            if (i == 0) {
                this.f = MTP.d;
                this.h = 0L;
                this.j = 0L;
                this.g = 0L;
                this.i = 0L;
                return;
            }
            x();
        }

        private void x() {
            ByteBuffer next = this.n.next();
            this.f = next;
            this.r += (int) (this.h - this.j);
            long position = next.position();
            this.h = position;
            this.j = position;
            this.g = this.f.limit();
            long d = vqr.d(this.f);
            this.i = d;
            this.h += d;
            this.j += d;
            this.g += d;
        }

        @Override // o.cKE
        public final int s() throws IOException {
            if (a()) {
                this.p = 0;
                return 0;
            }
            int A = A();
            this.p = A;
            if (Nvr.b(A) != 0) {
                return this.p;
            }
            throw InvalidProtocolBufferException.d();
        }

        @Override // o.cKE
        public final void e() throws InvalidProtocolBufferException {
            if (this.p != 0) {
                throw InvalidProtocolBufferException.c();
            }
        }

        @Override // o.cKE
        public final boolean b(int i) throws IOException {
            int s;
            int c = Nvr.c(i);
            if (c == 0) {
                for (int i2 = 0; i2 < 10; i2++) {
                    if (w() >= 0) {
                        return true;
                    }
                }
                throw InvalidProtocolBufferException.b();
            }
            if (c == 1) {
                a(8);
                return true;
            }
            if (c == 2) {
                a(A());
                return true;
            }
            if (c != 3) {
                if (c == 4) {
                    return false;
                }
                if (c == 5) {
                    a(4);
                    return true;
                }
                throw InvalidProtocolBufferException.e();
            }
            do {
                s = s();
                if (s == 0) {
                    break;
                }
            } while (b(s));
            if (this.p == Nvr.c(Nvr.b(i), 4)) {
                return true;
            }
            throw InvalidProtocolBufferException.c();
        }

        @Override // o.cKE
        public final double f() throws IOException {
            return Double.longBitsToDouble(B());
        }

        @Override // o.cKE
        public final float i() throws IOException {
            return Float.intBitsToFloat(z());
        }

        @Override // o.cKE
        public final long v() throws IOException {
            return C();
        }

        @Override // o.cKE
        public final long k() throws IOException {
            return C();
        }

        @Override // o.cKE
        public final int l() throws IOException {
            return A();
        }

        @Override // o.cKE
        public final long g() throws IOException {
            return B();
        }

        @Override // o.cKE
        public final int j() throws IOException {
            return z();
        }

        @Override // o.cKE
        public final boolean b() throws IOException {
            return C() != 0;
        }

        @Override // o.cKE
        public final String t() throws IOException {
            int A = A();
            if (A > 0) {
                long j = A;
                long j2 = this.g;
                long j3 = this.h;
                if (j <= j2 - j3) {
                    byte[] bArr = new byte[A];
                    vqr.e(j3, bArr, 0L, j);
                    String str = new String(bArr, MTP.b);
                    this.h += j;
                    return str;
                }
            }
            if (A > 0 && A <= ((int) (((this.t - this.r) - this.h) + this.j))) {
                byte[] bArr2 = new byte[A];
                e(bArr2, A);
                return new String(bArr2, MTP.b);
            }
            if (A == 0) {
                return "";
            }
            if (A < 0) {
                throw InvalidProtocolBufferException.i();
            }
            throw InvalidProtocolBufferException.g();
        }

        @Override // o.cKE
        public final String r() throws IOException {
            int A = A();
            if (A > 0) {
                long j = A;
                long j2 = this.g;
                long j3 = this.h;
                if (j <= j2 - j3) {
                    String c = C16752qto.c(this.f, (int) (j3 - this.j), A);
                    this.h += j;
                    return c;
                }
            }
            if (A >= 0 && A <= ((int) (((this.t - this.r) - this.h) + this.j))) {
                byte[] bArr = new byte[A];
                e(bArr, A);
                return C16752qto.d(bArr, 0, A);
            }
            if (A == 0) {
                return "";
            }
            if (A <= 0) {
                throw InvalidProtocolBufferException.i();
            }
            throw InvalidProtocolBufferException.g();
        }

        @Override // o.cKE
        public final QwV c() throws IOException {
            int A = A();
            if (A > 0) {
                long j = A;
                long j2 = this.g;
                long j3 = this.h;
                if (j <= j2 - j3) {
                    byte[] bArr = new byte[A];
                    vqr.e(j3, bArr, 0L, j);
                    this.h += j;
                    return QwV.d(bArr);
                }
            }
            if (A > 0 && A <= ((int) (((this.t - this.r) - this.h) + this.j))) {
                byte[] bArr2 = new byte[A];
                e(bArr2, A);
                return QwV.d(bArr2);
            }
            if (A == 0) {
                return QwV.a;
            }
            if (A < 0) {
                throw InvalidProtocolBufferException.i();
            }
            throw InvalidProtocolBufferException.g();
        }

        @Override // o.cKE
        public final int y() throws IOException {
            return A();
        }

        @Override // o.cKE
        public final int h() throws IOException {
            return A();
        }

        @Override // o.cKE
        public final int m() throws IOException {
            return z();
        }

        @Override // o.cKE
        public final long o() throws IOException {
            return B();
        }

        @Override // o.cKE
        public final int q() throws IOException {
            int A = A();
            return (A >>> 1) ^ (-(A & 1));
        }

        @Override // o.cKE
        public final long p() throws IOException {
            long C = C();
            return (C >>> 1) ^ (-(1 & C));
        }

        private int A() throws IOException {
            int i;
            long j = this.h;
            if (this.g != j) {
                byte d = vqr.d(j);
                if (d >= 0) {
                    this.h++;
                    return d;
                }
                if (this.g - this.h >= 10) {
                    long j2 = 2 + j;
                    int d2 = d ^ (vqr.d(1 + j) << 7);
                    if (d2 < 0) {
                        i = d2 ^ (-128);
                    } else {
                        long j3 = 3 + j;
                        int d3 = d2 ^ (vqr.d(j2) << 14);
                        if (d3 >= 0) {
                            i = d3 ^ 16256;
                        } else {
                            j2 = 4 + j;
                            int d4 = d3 ^ (vqr.d(j3) << Ascii.NAK);
                            if (d4 < 0) {
                                i = (-2080896) ^ d4;
                            } else {
                                j3 = 5 + j;
                                byte d5 = vqr.d(j2);
                                int i2 = (d4 ^ (d5 << 28)) ^ 266354560;
                                if (d5 < 0) {
                                    j2 = 6 + j;
                                    if (vqr.d(j3) < 0) {
                                        j3 = 7 + j;
                                        if (vqr.d(j2) < 0) {
                                            j2 = 8 + j;
                                            if (vqr.d(j3) < 0) {
                                                j3 = 9 + j;
                                                if (vqr.d(j2) < 0) {
                                                    if (vqr.d(j3) >= 0) {
                                                        j2 = j + 10;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    i = i2;
                                }
                                i = i2;
                            }
                        }
                        j2 = j3;
                    }
                    this.h = j2;
                    return i;
                }
            }
            return (int) n();
        }

        private long C() throws IOException {
            long j;
            long j2;
            int i;
            long j3 = this.h;
            if (this.g != j3) {
                byte d = vqr.d(j3);
                if (d >= 0) {
                    this.h++;
                    return d;
                }
                if (this.g - this.h >= 10) {
                    long j4 = 2 + j3;
                    int d2 = d ^ (vqr.d(1 + j3) << 7);
                    if (d2 >= 0) {
                        long j5 = 3 + j3;
                        int d3 = d2 ^ (vqr.d(j4) << 14);
                        if (d3 >= 0) {
                            j = d3 ^ 16256;
                            j4 = j5;
                        } else {
                            j4 = 4 + j3;
                            int d4 = d3 ^ (vqr.d(j5) << Ascii.NAK);
                            if (d4 < 0) {
                                i = (-2080896) ^ d4;
                            } else {
                                long j6 = 5 + j3;
                                long d5 = d4 ^ (vqr.d(j4) << 28);
                                if (d5 >= 0) {
                                    j2 = 266354560;
                                } else {
                                    long j7 = 6 + j3;
                                    d5 ^= vqr.d(j6) << 35;
                                    if (d5 < 0) {
                                        j2 = -34093383808L;
                                    } else {
                                        j6 = 7 + j3;
                                        d5 ^= vqr.d(j7) << 42;
                                        if (d5 >= 0) {
                                            j2 = 4363953127296L;
                                        } else {
                                            j7 = 8 + j3;
                                            d5 ^= vqr.d(j6) << 49;
                                            if (d5 < 0) {
                                                j2 = -558586000294016L;
                                            } else {
                                                long j8 = 9 + j3;
                                                long d6 = (d5 ^ (vqr.d(j7) << 56)) ^ 71499008037633920L;
                                                if (d6 >= 0) {
                                                    j = d6;
                                                    j4 = j8;
                                                } else if (vqr.d(j8) >= 0) {
                                                    j4 = j3 + 10;
                                                    j = d6;
                                                }
                                            }
                                        }
                                    }
                                    j4 = j7;
                                    j = j2 ^ d5;
                                }
                                j4 = j6;
                                j = j2 ^ d5;
                            }
                        }
                        this.h = j4;
                        return j;
                    }
                    i = d2 ^ (-128);
                    j = i;
                    this.h = j4;
                    return j;
                }
            }
            return n();
        }

        @Override // o.cKE
        final long n() throws IOException {
            long j = 0;
            for (int i = 0; i < 64; i += 7) {
                j |= (r3 & Ascii.DEL) << i;
                if ((w() & 128) == 0) {
                    return j;
                }
            }
            throw InvalidProtocolBufferException.b();
        }

        @Override // o.cKE
        public final void e(int i) {
            this.l = i;
            u();
        }

        private void e(byte[] bArr, int i) throws IOException {
            if (i < 0 || i > ((int) (((this.t - this.r) - this.h) + this.j))) {
                if (i > 0) {
                    throw InvalidProtocolBufferException.g();
                }
                if (i != 0) {
                    throw InvalidProtocolBufferException.i();
                }
                return;
            }
            int i2 = i;
            while (i2 > 0) {
                if (this.g - this.h == 0) {
                    if (!this.n.hasNext()) {
                        throw InvalidProtocolBufferException.g();
                    }
                    x();
                }
                int min = Math.min(i2, (int) (this.g - this.h));
                long j = min;
                vqr.e(this.h, bArr, i - i2, j);
                i2 -= min;
                this.h += j;
            }
        }

        @Override // o.cKE
        public final int d(int i) throws InvalidProtocolBufferException {
            if (i < 0) {
                throw InvalidProtocolBufferException.i();
            }
            int i2 = i + ((int) (((this.r - this.s) + this.h) - this.j));
            int i3 = this.l;
            if (i2 > i3) {
                throw InvalidProtocolBufferException.g();
            }
            this.l = i2;
            u();
            return i3;
        }

        private byte w() throws IOException {
            if (this.g - this.h == 0) {
                if (!this.n.hasNext()) {
                    throw InvalidProtocolBufferException.g();
                }
                x();
            }
            long j = this.h;
            this.h = 1 + j;
            return vqr.d(j);
        }

        private int z() throws IOException {
            long j = this.g;
            long j2 = this.h;
            if (j - j2 >= 4) {
                this.h = 4 + j2;
                byte d = vqr.d(j2);
                byte d2 = vqr.d(1 + j2);
                byte d3 = vqr.d(2 + j2);
                return (d & UnsignedBytes.MAX_VALUE) | ((d2 & UnsignedBytes.MAX_VALUE) << 8) | ((d3 & UnsignedBytes.MAX_VALUE) << 16) | ((vqr.d(j2 + 3) & UnsignedBytes.MAX_VALUE) << 24);
            }
            return (w() & UnsignedBytes.MAX_VALUE) | ((w() & UnsignedBytes.MAX_VALUE) << 8) | ((w() & UnsignedBytes.MAX_VALUE) << 16) | ((w() & UnsignedBytes.MAX_VALUE) << 24);
        }

        private long B() throws IOException {
            long j;
            long w;
            byte w2;
            long j2 = this.g;
            long j3 = this.h;
            if (j2 - j3 >= 8) {
                this.h = 8 + j3;
                w = ((vqr.d(j3 + 5) & 255) << 40) | (vqr.d(j3) & 255) | ((vqr.d(1 + j3) & 255) << 8) | ((vqr.d(j3 + 2) & 255) << 16) | ((vqr.d(j3 + 3) & 255) << 24) | ((vqr.d(j3 + 4) & 255) << 32) | ((vqr.d(j3 + 6) & 255) << 48);
                w2 = vqr.d(j3 + 7);
                j = 255;
            } else {
                j = 255;
                w = (w() & 255) | ((w() & 255) << 8) | ((w() & 255) << 16) | ((w() & 255) << 24) | ((w() & 255) << 32) | ((w() & 255) << 40) | ((w() & 255) << 48);
                w2 = w();
            }
            return w | ((w2 & j) << 56);
        }

        private void a(int i) throws IOException {
            if (i < 0 || i > ((this.t - this.r) - this.h) + this.j) {
                if (i < 0) {
                    throw InvalidProtocolBufferException.i();
                }
                throw InvalidProtocolBufferException.g();
            }
            while (i > 0) {
                if (this.g - this.h == 0) {
                    if (!this.n.hasNext()) {
                        throw InvalidProtocolBufferException.g();
                    }
                    x();
                }
                int min = Math.min(i, (int) (this.g - this.h));
                i -= min;
                this.h += min;
            }
        }

        @Override // o.cKE
        public final boolean a() throws IOException {
            return (((long) this.r) + this.h) - this.j == ((long) this.t);
        }

        @Override // o.cKE
        public final int d() {
            return (int) (((this.r - this.s) + this.h) - this.j);
        }

        private void u() {
            int i = this.t + this.a;
            this.t = i;
            int i2 = i - this.s;
            int i3 = this.l;
            if (i2 <= i3) {
                this.a = 0;
                return;
            }
            int i4 = i2 - i3;
            this.a = i4;
            this.t = i - i4;
        }
    }
}