package defpackage;

import java.io.ByteArrayInputStream;
import java.io.DataInput;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteOrder;

/* JADX INFO: renamed from: ᵕʧ, reason: contains not printable characters */
/* JADX INFO: loaded from: classes3.dex */
public class C2295 extends InputStream implements DataInput {

    /* JADX INFO: renamed from: ᵯᵷʽ, reason: contains not printable characters */
    public static final ByteOrder f9007 = ByteOrder.LITTLE_ENDIAN;

    /* JADX INFO: renamed from: ᵶˇᵱ, reason: contains not printable characters */
    public static final ByteOrder f9008 = ByteOrder.BIG_ENDIAN;

    /* JADX INFO: renamed from: ˌᴵ, reason: contains not printable characters */
    public final DataInputStream f9009;

    /* JADX INFO: renamed from: ᵔᵖᵹᵫ, reason: contains not printable characters */
    public int f9010;

    /* JADX INFO: renamed from: ᵜᵪʾ, reason: contains not printable characters */
    public ByteOrder f9011;

    /* JADX INFO: renamed from: ᵨᵼⁱ, reason: contains not printable characters */
    public byte[] f9012;

    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
    public C2295(InputStream inputStream) {
        this(inputStream, 0);
        ByteOrder byteOrder = ByteOrder.BIG_ENDIAN;
    }

    public C2295(InputStream inputStream, int i) {
        ByteOrder byteOrder = ByteOrder.BIG_ENDIAN;
        this.f9011 = byteOrder;
        DataInputStream dataInputStream = new DataInputStream(inputStream);
        this.f9009 = dataInputStream;
        dataInputStream.mark(0);
        this.f9010 = 0;
        this.f9011 = byteOrder;
    }

    public C2295(byte[] bArr) {
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bArr);
        ByteOrder byteOrder = ByteOrder.BIG_ENDIAN;
        this(byteArrayInputStream, 0);
    }

    @Override // java.io.InputStream
    public final int available() {
        return this.f9009.available();
    }

    @Override // java.io.InputStream
    public final void mark(int i) {
        throw new UnsupportedOperationException("Mark is currently unsupported");
    }

    @Override // java.io.InputStream
    public final int read() {
        this.f9010++;
        return this.f9009.read();
    }

    @Override // java.io.InputStream
    public final int read(byte[] bArr, int i, int i2) throws IOException {
        int i3 = this.f9009.read(bArr, i, i2);
        this.f9010 += i3;
        return i3;
    }

    @Override // java.io.DataInput
    public final boolean readBoolean() {
        this.f9010++;
        return this.f9009.readBoolean();
    }

    @Override // java.io.DataInput
    public final byte readByte() throws IOException {
        this.f9010++;
        int i = this.f9009.read();
        if (i >= 0) {
            return (byte) i;
        }
        throw new EOFException();
    }

    @Override // java.io.DataInput
    public final char readChar() {
        this.f9010 += 2;
        return this.f9009.readChar();
    }

    @Override // java.io.DataInput
    public final double readDouble() {
        return Double.longBitsToDouble(readLong());
    }

    @Override // java.io.DataInput
    public final float readFloat() {
        return Float.intBitsToFloat(readInt());
    }

    @Override // java.io.DataInput
    public final void readFully(byte[] bArr) throws IOException {
        this.f9010 += bArr.length;
        this.f9009.readFully(bArr);
    }

    @Override // java.io.DataInput
    public final void readFully(byte[] bArr, int i, int i2) throws IOException {
        this.f9010 += i2;
        this.f9009.readFully(bArr, i, i2);
    }

    @Override // java.io.DataInput
    public final int readInt() throws IOException {
        this.f9010 += 4;
        DataInputStream dataInputStream = this.f9009;
        int i = dataInputStream.read();
        int i2 = dataInputStream.read();
        int i3 = dataInputStream.read();
        int i4 = dataInputStream.read();
        if ((i | i2 | i3 | i4) < 0) {
            throw new EOFException();
        }
        ByteOrder byteOrder = this.f9011;
        if (byteOrder == f9007) {
            return (i4 << 24) + (i3 << 16) + (i2 << 8) + i;
        }
        if (byteOrder == f9008) {
            return (i << 24) + (i2 << 16) + (i3 << 8) + i4;
        }
        ᵷᵝˎ.ᵶᵥᵝ(this.f9011, "Invalid byte order: ");
        return 0;
    }

    @Override // java.io.DataInput
    public final String readLine() {
        return null;
    }

    @Override // java.io.DataInput
    public final long readLong() throws IOException {
        this.f9010 += 8;
        DataInputStream dataInputStream = this.f9009;
        int i = dataInputStream.read();
        int i2 = dataInputStream.read();
        int i3 = dataInputStream.read();
        int i4 = dataInputStream.read();
        int i5 = dataInputStream.read();
        int i6 = dataInputStream.read();
        int i7 = dataInputStream.read();
        int i8 = dataInputStream.read();
        if ((i | i2 | i3 | i4 | i5 | i6 | i7 | i8) < 0) {
            throw new EOFException();
        }
        ByteOrder byteOrder = this.f9011;
        if (byteOrder == f9007) {
            return (((long) i8) << 56) + (((long) i7) << 48) + (((long) i6) << 40) + (((long) i5) << 32) + (((long) i4) << 24) + (((long) i3) << 16) + (((long) i2) << 8) + ((long) i);
        }
        if (byteOrder == f9008) {
            return (((long) i) << 56) + (((long) i2) << 48) + (((long) i3) << 40) + (((long) i4) << 32) + (((long) i5) << 24) + (((long) i6) << 16) + (((long) i7) << 8) + ((long) i8);
        }
        ᵷᵝˎ.ᵶᵥᵝ(this.f9011, "Invalid byte order: ");
        return 0L;
    }

    @Override // java.io.DataInput
    public final short readShort() throws IOException {
        this.f9010 += 2;
        DataInputStream dataInputStream = this.f9009;
        int i = dataInputStream.read();
        int i2 = dataInputStream.read();
        if ((i | i2) < 0) {
            throw new EOFException();
        }
        ByteOrder byteOrder = this.f9011;
        if (byteOrder == f9007) {
            return (short) ((i2 << 8) + i);
        }
        if (byteOrder == f9008) {
            return (short) ((i << 8) + i2);
        }
        ᵷᵝˎ.ᵶᵥᵝ(this.f9011, "Invalid byte order: ");
        return (short) 0;
    }

    @Override // java.io.DataInput
    public final String readUTF() {
        this.f9010 += 2;
        return this.f9009.readUTF();
    }

    @Override // java.io.DataInput
    public final int readUnsignedByte() {
        this.f9010++;
        return this.f9009.readUnsignedByte();
    }

    @Override // java.io.DataInput
    public final int readUnsignedShort() throws IOException {
        this.f9010 += 2;
        DataInputStream dataInputStream = this.f9009;
        int i = dataInputStream.read();
        int i2 = dataInputStream.read();
        if ((i | i2) < 0) {
            throw new EOFException();
        }
        ByteOrder byteOrder = this.f9011;
        if (byteOrder == f9007) {
            return (i2 << 8) + i;
        }
        if (byteOrder == f9008) {
            return (i << 8) + i2;
        }
        ᵷᵝˎ.ᵶᵥᵝ(this.f9011, "Invalid byte order: ");
        return 0;
    }

    @Override // java.io.InputStream
    public final void reset() {
        throw new UnsupportedOperationException("Reset is currently unsupported");
    }

    @Override // java.io.DataInput
    public final int skipBytes(int i) {
        throw new UnsupportedOperationException("skipBytes is currently unsupported");
    }

    /* JADX INFO: renamed from: ᵲᵶᵳˈ, reason: contains not printable characters */
    public final void m5920(int i) throws IOException {
        int i2 = 0;
        while (i2 < i) {
            int i3 = i - i2;
            DataInputStream dataInputStream = this.f9009;
            int iSkip = (int) dataInputStream.skip(i3);
            if (iSkip <= 0) {
                if (this.f9012 == null) {
                    this.f9012 = new byte[8192];
                }
                iSkip = dataInputStream.read(this.f9012, 0, Math.min(8192, i3));
                if (iSkip == -1) {
                    throw new EOFException(AbstractC0793.m2876(i, "Reached EOF while skipping ", " bytes."));
                }
            }
            i2 += iSkip;
        }
        this.f9010 += i2;
    }
}