package T0;

import n4.u0;
import x0.AbstractC1709a;

/* JADX INFO: loaded from: classes.dex */
public final class H {

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

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public int f6359b;

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    public int f6360c;

    /* JADX INFO: renamed from: d, reason: collision with root package name */
    public byte[] f6361d;

    /* JADX INFO: renamed from: e, reason: collision with root package name */
    public int f6362e;

    public H() {
        this.f6358a = 2;
        this.f6361d = x0.v.f18555c;
    }

    public void a() {
        int i;
        int i5;
        switch (this.f6358a) {
            case 2:
                int i8 = this.f6359b;
                AbstractC1709a.j(i8 >= 0 && (i8 < (i = this.f6362e) || (i8 == i && this.f6360c == 0)));
                break;
            default:
                int i9 = this.f6360c;
                AbstractC1709a.j(i9 >= 0 && (i9 < (i5 = this.f6359b) || (i9 == i5 && this.f6362e == 0)));
                break;
        }
    }

    public int b() {
        return ((this.f6362e - this.f6359b) * 8) - this.f6360c;
    }

    public void c() {
        if (this.f6360c == 0) {
            return;
        }
        this.f6360c = 0;
        this.f6359b++;
        a();
    }

    public boolean d(int i) {
        int i5 = this.f6360c;
        int i8 = i / 8;
        int i9 = i5 + i8;
        int i10 = (this.f6362e + i) - (i8 * 8);
        if (i10 > 7) {
            i9++;
            i10 -= 8;
        }
        while (true) {
            i5++;
            if (i5 > i9 || i9 >= this.f6359b) {
                break;
            }
            if (r(i5)) {
                i9++;
                i5 += 2;
            }
        }
        int i11 = this.f6359b;
        if (i9 >= i11) {
            return i9 == i11 && i10 == 0;
        }
        return true;
    }

    public boolean e() {
        int i = this.f6360c;
        int i5 = this.f6362e;
        int i8 = 0;
        while (this.f6360c < this.f6359b && !h()) {
            i8++;
        }
        boolean z8 = this.f6360c == this.f6359b;
        this.f6360c = i;
        this.f6362e = i5;
        return !z8 && d((i8 * 2) + 1);
    }

    public int f() {
        AbstractC1709a.j(this.f6360c == 0);
        return this.f6359b;
    }

    public int g() {
        return (this.f6359b * 8) + this.f6360c;
    }

    public boolean h() {
        switch (this.f6358a) {
            case u0.f15495q /* 0 */:
                boolean z8 = (((this.f6361d[this.f6360c] & 255) >> this.f6362e) & 1) == 1;
                t(1);
                return z8;
            case 1:
            default:
                boolean z9 = (this.f6361d[this.f6360c] & (128 >> this.f6362e)) != 0;
                s();
                return z9;
            case 2:
                boolean z10 = (this.f6361d[this.f6359b] & (128 >> this.f6360c)) != 0;
                s();
                return z10;
        }
    }

    public int i(int i) {
        switch (this.f6358a) {
            case u0.f15495q /* 0 */:
                int i5 = this.f6360c;
                int iMin = Math.min(i, 8 - this.f6362e);
                int i8 = i5 + 1;
                byte[] bArr = this.f6361d;
                int i9 = ((bArr[i5] & 255) >> this.f6362e) & (255 >> (8 - iMin));
                while (iMin < i) {
                    i9 |= (bArr[i8] & 255) << iMin;
                    iMin += 8;
                    i8++;
                }
                int i10 = i9 & ((-1) >>> (32 - i));
                t(i);
                return i10;
            case 1:
            default:
                this.f6362e += i;
                int i11 = 0;
                while (true) {
                    int i12 = this.f6362e;
                    if (i12 <= 8) {
                        byte[] bArr2 = this.f6361d;
                        int i13 = this.f6360c;
                        int i14 = ((-1) >>> (32 - i)) & (i11 | ((bArr2[i13] & 255) >> (8 - i12)));
                        if (i12 == 8) {
                            this.f6362e = 0;
                            this.f6360c = i13 + (r(i13 + 1) ? 2 : 1);
                        }
                        a();
                        return i14;
                    }
                    int i15 = i12 - 8;
                    this.f6362e = i15;
                    byte[] bArr3 = this.f6361d;
                    int i16 = this.f6360c;
                    i11 |= (bArr3[i16] & 255) << i15;
                    if (!r(i16 + 1)) {
                        i = 1;
                    }
                    this.f6360c = i16 + i;
                }
                break;
            case 2:
                if (i == 0) {
                    return 0;
                }
                this.f6360c += i;
                int i17 = 0;
                while (true) {
                    int i18 = this.f6360c;
                    if (i18 <= 8) {
                        byte[] bArr4 = this.f6361d;
                        int i19 = this.f6359b;
                        int i20 = ((-1) >>> (32 - i)) & (i17 | ((bArr4[i19] & 255) >> (8 - i18)));
                        if (i18 == 8) {
                            this.f6360c = 0;
                            this.f6359b = i19 + 1;
                        }
                        a();
                        return i20;
                    }
                    int i21 = i18 - 8;
                    this.f6360c = i21;
                    byte[] bArr5 = this.f6361d;
                    int i22 = this.f6359b;
                    this.f6359b = i22 + 1;
                    i17 |= (bArr5[i22] & 255) << i21;
                }
                break;
        }
    }

    public void j(int i, byte[] bArr) {
        int i5 = i >> 3;
        for (int i8 = 0; i8 < i5; i8++) {
            byte[] bArr2 = this.f6361d;
            int i9 = this.f6359b;
            int i10 = i9 + 1;
            this.f6359b = i10;
            byte b8 = bArr2[i9];
            int i11 = this.f6360c;
            byte b9 = (byte) (b8 << i11);
            bArr[i8] = b9;
            bArr[i8] = (byte) (((255 & bArr2[i10]) >> (8 - i11)) | b9);
        }
        int i12 = i & 7;
        if (i12 == 0) {
            return;
        }
        byte b10 = (byte) (bArr[i5] & (255 >> i12));
        bArr[i5] = b10;
        int i13 = this.f6360c;
        if (i13 + i12 > 8) {
            byte[] bArr3 = this.f6361d;
            int i14 = this.f6359b;
            this.f6359b = i14 + 1;
            bArr[i5] = (byte) (b10 | ((bArr3[i14] & 255) << i13));
            this.f6360c = i13 - 8;
        }
        int i15 = this.f6360c + i12;
        this.f6360c = i15;
        byte[] bArr4 = this.f6361d;
        int i16 = this.f6359b;
        bArr[i5] = (byte) (((byte) (((255 & bArr4[i16]) >> (8 - i15)) << (8 - i12))) | bArr[i5]);
        if (i15 == 8) {
            this.f6360c = 0;
            this.f6359b = i16 + 1;
        }
        a();
    }

    public long k(int i) {
        if (i <= 32) {
            int i5 = i(i);
            int i8 = x0.v.f18553a;
            return 4294967295L & ((long) i5);
        }
        int i9 = i(i - 32);
        int i10 = i(32);
        int i11 = x0.v.f18553a;
        return (4294967295L & ((long) i10)) | ((((long) i9) & 4294967295L) << 32);
    }

    public void l(int i, byte[] bArr) {
        AbstractC1709a.j(this.f6360c == 0);
        System.arraycopy(this.f6361d, this.f6359b, bArr, 0, i);
        this.f6359b += i;
        a();
    }

    public int m() {
        int i = 0;
        while (!h()) {
            i++;
        }
        return ((1 << i) - 1) + (i > 0 ? i(i) : 0);
    }

    public int n() {
        int iM = m();
        return ((iM + 1) / 2) * (iM % 2 == 0 ? -1 : 1);
    }

    public void o(int i, byte[] bArr) {
        this.f6361d = bArr;
        this.f6359b = 0;
        this.f6360c = 0;
        this.f6362e = i;
    }

    public void p(x0.o oVar) {
        o(oVar.f18541c, oVar.f18539a);
        q(oVar.f18540b * 8);
    }

    public void q(int i) {
        int i5 = i / 8;
        this.f6359b = i5;
        this.f6360c = i - (i5 * 8);
        a();
    }

    public boolean r(int i) {
        if (2 > i || i >= this.f6359b) {
            return false;
        }
        byte[] bArr = this.f6361d;
        return bArr[i] == 3 && bArr[i + (-2)] == 0 && bArr[i - 1] == 0;
    }

    public void s() {
        switch (this.f6358a) {
            case 2:
                int i = this.f6360c + 1;
                this.f6360c = i;
                if (i == 8) {
                    this.f6360c = 0;
                    this.f6359b++;
                }
                a();
                break;
            default:
                int i5 = this.f6362e + 1;
                this.f6362e = i5;
                if (i5 == 8) {
                    this.f6362e = 0;
                    int i8 = this.f6360c;
                    this.f6360c = i8 + (r(i8 + 1) ? 2 : 1);
                }
                a();
                break;
        }
    }

    public void t(int i) {
        int i5;
        switch (this.f6358a) {
            case u0.f15495q /* 0 */:
                int i8 = i / 8;
                int i9 = this.f6360c + i8;
                this.f6360c = i9;
                int i10 = (i - (i8 * 8)) + this.f6362e;
                this.f6362e = i10;
                boolean z8 = true;
                if (i10 > 7) {
                    this.f6360c = i9 + 1;
                    this.f6362e = i10 - 8;
                }
                int i11 = this.f6360c;
                if (i11 < 0 || (i11 >= (i5 = this.f6359b) && (i11 != i5 || this.f6362e != 0))) {
                    z8 = false;
                }
                AbstractC1709a.j(z8);
                break;
            case 1:
            default:
                int i12 = this.f6360c;
                int i13 = i / 8;
                int i14 = i12 + i13;
                this.f6360c = i14;
                int i15 = (i - (i13 * 8)) + this.f6362e;
                this.f6362e = i15;
                if (i15 > 7) {
                    this.f6360c = i14 + 1;
                    this.f6362e = i15 - 8;
                }
                while (true) {
                    i12++;
                    if (i12 > this.f6360c) {
                        a();
                        break;
                    } else if (r(i12)) {
                        this.f6360c++;
                        i12 += 2;
                    }
                }
                break;
            case 2:
                int i16 = i / 8;
                int i17 = this.f6359b + i16;
                this.f6359b = i17;
                int i18 = (i - (i16 * 8)) + this.f6360c;
                this.f6360c = i18;
                if (i18 > 7) {
                    this.f6359b = i17 + 1;
                    this.f6360c = i18 - 8;
                }
                a();
                break;
        }
    }

    public void u(int i) {
        AbstractC1709a.j(this.f6360c == 0);
        this.f6359b += i;
        a();
    }

    public H(byte[] bArr) {
        this.f6358a = 0;
        this.f6361d = bArr;
        this.f6359b = bArr.length;
    }

    public H(byte[] bArr, int i, int i5) {
        this.f6358a = 3;
        this.f6361d = bArr;
        this.f6360c = i;
        this.f6359b = i5;
        this.f6362e = 0;
        a();
    }

    public H(int i, byte[] bArr) {
        this.f6358a = 2;
        this.f6361d = bArr;
        this.f6362e = i;
    }

    public H(int i, int i5) {
        this.f6358a = 1;
        this.f6359b = i;
        this.f6360c = i5;
        this.f6361d = new byte[(i5 * 2) - 1];
        this.f6362e = 0;
    }
}