package io.netty.buffer;

import io.netty.util.ByteProcessor;
import io.netty.util.CharsetUtil;
import io.netty.util.IllegalReferenceCountException;
import io.netty.util.ResourceLeakDetector;
import io.netty.util.ResourceLeakDetectorFactory;
import io.netty.util.internal.MathUtil;
import io.netty.util.internal.PlatformDependent;
import io.netty.util.internal.StringUtil;
import io.netty.util.internal.SystemPropertyUtil;
import io.netty.util.internal.logging.InternalLogger;
import io.netty.util.internal.logging.InternalLoggerFactory;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.FileChannel;
import java.nio.channels.GatheringByteChannel;
import java.nio.channels.ScatteringByteChannel;
import java.nio.charset.Charset;

/* JADX INFO: loaded from: classes.dex */
public abstract class AbstractByteBuf extends ByteBuf {
    static final ResourceLeakDetector<ByteBuf> leakDetector;
    private int markedReaderIndex;
    private int markedWriterIndex;
    private int maxCapacity;
    int readerIndex;
    int writerIndex;
    private static final InternalLogger logger = InternalLoggerFactory.getInstance((Class<?>) AbstractByteBuf.class);
    private static final String PROP_MODE = "io.netty.buffer.bytebuf.checkAccessible";
    private static final boolean checkAccessible = SystemPropertyUtil.getBoolean(PROP_MODE, true);

    static {
        if (logger.isDebugEnabled()) {
            logger.debug("-D{}: {}", PROP_MODE, Boolean.valueOf(checkAccessible));
        }
        leakDetector = ResourceLeakDetectorFactory.instance().newResourceLeakDetector(ByteBuf.class);
    }

    protected AbstractByteBuf(int i2) {
        if (i2 >= 0) {
            this.maxCapacity = i2;
            return;
        }
        throw new IllegalArgumentException("maxCapacity: " + i2 + " (expected: >= 0)");
    }

    private void checkReadableBytes0(int i2) {
        ensureAccessible();
        if (this.readerIndex > this.writerIndex - i2) {
            throw new IndexOutOfBoundsException(String.format("readerIndex(%d) + length(%d) exceeds writerIndex(%d): %s", Integer.valueOf(this.readerIndex), Integer.valueOf(i2), Integer.valueOf(this.writerIndex), this));
        }
    }

    private void ensureWritable0(int i2) {
        if (i2 <= writableBytes()) {
            return;
        }
        if (i2 > this.maxCapacity - this.writerIndex) {
            throw new IndexOutOfBoundsException(String.format("writerIndex(%d) + minWritableBytes(%d) exceeds maxCapacity(%d): %s", Integer.valueOf(this.writerIndex), Integer.valueOf(i2), Integer.valueOf(this.maxCapacity), this));
        }
        capacity(alloc().calculateNewCapacity(this.writerIndex + i2, this.maxCapacity));
    }

    private int forEachByteAsc0(int i2, int i3, ByteProcessor byteProcessor) throws Throwable {
        if (byteProcessor == null) {
            throw new NullPointerException("processor");
        }
        if (i3 == 0) {
            return -1;
        }
        int i4 = i3 + i2;
        while (byteProcessor.process(_getByte(i2))) {
            try {
                i2++;
            } catch (Exception e2) {
                PlatformDependent.throwException(e2);
            }
            if (i2 >= i4) {
                return -1;
            }
        }
        return i2;
    }

    private int forEachByteDesc0(int i2, int i3, ByteProcessor byteProcessor) throws Throwable {
        if (byteProcessor == null) {
            throw new NullPointerException("processor");
        }
        if (i3 == 0) {
            return -1;
        }
        int i4 = (i3 + i2) - 1;
        while (byteProcessor.process(_getByte(i4))) {
            try {
                i4--;
            } catch (Exception e2) {
                PlatformDependent.throwException(e2);
            }
            if (i4 < i2) {
                return -1;
            }
        }
        return i4;
    }

    protected abstract byte _getByte(int i2);

    protected abstract int _getInt(int i2);

    protected abstract int _getIntLE(int i2);

    protected abstract long _getLong(int i2);

    protected abstract long _getLongLE(int i2);

    protected abstract short _getShort(int i2);

    protected abstract short _getShortLE(int i2);

    protected abstract int _getUnsignedMedium(int i2);

    protected abstract int _getUnsignedMediumLE(int i2);

    protected abstract void _setByte(int i2, int i3);

    protected abstract void _setInt(int i2, int i3);

    protected abstract void _setIntLE(int i2, int i3);

    protected abstract void _setLong(int i2, long j2);

    protected abstract void _setLongLE(int i2, long j2);

    protected abstract void _setMedium(int i2, int i3);

    protected abstract void _setMediumLE(int i2, int i3);

    protected abstract void _setShort(int i2, int i3);

    protected abstract void _setShortLE(int i2, int i3);

    protected final void adjustMarkers(int i2) {
        int i3 = this.markedReaderIndex;
        if (i3 > i2) {
            this.markedReaderIndex = i3 - i2;
            this.markedWriterIndex -= i2;
            return;
        }
        this.markedReaderIndex = 0;
        int i4 = this.markedWriterIndex;
        if (i4 <= i2) {
            this.markedWriterIndex = 0;
        } else {
            this.markedWriterIndex = i4 - i2;
        }
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf asReadOnly() {
        return isReadOnly() ? this : Unpooled.unmodifiableBuffer(this);
    }

    @Override // io.netty.buffer.ByteBuf
    public int bytesBefore(byte b2) {
        return bytesBefore(readerIndex(), readableBytes(), b2);
    }

    protected final void checkDstIndex(int i2, int i3, int i4, int i5) {
        checkIndex(i2, i3);
        if (MathUtil.isOutOfBounds(i4, i3, i5)) {
            throw new IndexOutOfBoundsException(String.format("dstIndex: %d, length: %d (expected: range(0, %d))", Integer.valueOf(i4), Integer.valueOf(i3), Integer.valueOf(i5)));
        }
    }

    protected final void checkIndex(int i2) {
        checkIndex(i2, 1);
    }

    final void checkIndex0(int i2, int i3) {
        if (MathUtil.isOutOfBounds(i2, i3, capacity())) {
            throw new IndexOutOfBoundsException(String.format("index: %d, length: %d (expected: range(0, %d))", Integer.valueOf(i2), Integer.valueOf(i3), Integer.valueOf(capacity())));
        }
    }

    protected final void checkReadableBytes(int i2) {
        if (i2 >= 0) {
            checkReadableBytes0(i2);
            return;
        }
        throw new IllegalArgumentException("minimumReadableBytes: " + i2 + " (expected: >= 0)");
    }

    protected final void checkSrcIndex(int i2, int i3, int i4, int i5) {
        checkIndex(i2, i3);
        if (MathUtil.isOutOfBounds(i4, i3, i5)) {
            throw new IndexOutOfBoundsException(String.format("srcIndex: %d, length: %d (expected: range(0, %d))", Integer.valueOf(i4), Integer.valueOf(i3), Integer.valueOf(i5)));
        }
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf clear() {
        this.writerIndex = 0;
        this.readerIndex = 0;
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf copy() {
        return copy(this.readerIndex, readableBytes());
    }

    final void discardMarks() {
        this.markedWriterIndex = 0;
        this.markedReaderIndex = 0;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf discardReadBytes() {
        ensureAccessible();
        int i2 = this.readerIndex;
        if (i2 == 0) {
            return this;
        }
        int i3 = this.writerIndex;
        if (i2 != i3) {
            setBytes(0, this, i2, i3 - i2);
            int i4 = this.writerIndex;
            int i5 = this.readerIndex;
            this.writerIndex = i4 - i5;
            adjustMarkers(i5);
            this.readerIndex = 0;
        } else {
            adjustMarkers(i2);
            this.readerIndex = 0;
            this.writerIndex = 0;
        }
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf discardSomeReadBytes() {
        ensureAccessible();
        int i2 = this.readerIndex;
        if (i2 == 0) {
            return this;
        }
        if (i2 == this.writerIndex) {
            adjustMarkers(i2);
            this.readerIndex = 0;
            this.writerIndex = 0;
            return this;
        }
        if (i2 >= (capacity() >>> 1)) {
            int i3 = this.readerIndex;
            setBytes(0, this, i3, this.writerIndex - i3);
            int i4 = this.writerIndex;
            int i5 = this.readerIndex;
            this.writerIndex = i4 - i5;
            adjustMarkers(i5);
            this.readerIndex = 0;
        }
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf duplicate() {
        return new DuplicatedAbstractByteBuf(this);
    }

    protected final void ensureAccessible() {
        if (checkAccessible && refCnt() == 0) {
            throw new IllegalReferenceCountException(0);
        }
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf ensureWritable(int i2) {
        if (i2 < 0) {
            throw new IllegalArgumentException(String.format("minWritableBytes: %d (expected: >= 0)", Integer.valueOf(i2)));
        }
        ensureWritable0(i2);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj instanceof ByteBuf) {
            return ByteBufUtil.equals(this, (ByteBuf) obj);
        }
        return false;
    }

    @Override // io.netty.buffer.ByteBuf
    public int forEachByte(ByteProcessor byteProcessor) {
        int i2 = this.readerIndex;
        int i3 = this.writerIndex - i2;
        ensureAccessible();
        return forEachByteAsc0(i2, i3, byteProcessor);
    }

    @Override // io.netty.buffer.ByteBuf
    public int forEachByteDesc(ByteProcessor byteProcessor) {
        int i2 = this.readerIndex;
        int i3 = this.writerIndex - i2;
        ensureAccessible();
        return forEachByteDesc0(i2, i3, byteProcessor);
    }

    @Override // io.netty.buffer.ByteBuf
    public boolean getBoolean(int i2) {
        return getByte(i2) != 0;
    }

    @Override // io.netty.buffer.ByteBuf
    public byte getByte(int i2) {
        checkIndex(i2);
        return _getByte(i2);
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf getBytes(int i2, byte[] bArr) {
        getBytes(i2, bArr, 0, bArr.length);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public char getChar(int i2) {
        return (char) getShort(i2);
    }

    @Override // io.netty.buffer.ByteBuf
    public CharSequence getCharSequence(int i2, int i3, Charset charset) {
        return toString(i2, i3, charset);
    }

    @Override // io.netty.buffer.ByteBuf
    public double getDouble(int i2) {
        return Double.longBitsToDouble(getLong(i2));
    }

    @Override // io.netty.buffer.ByteBuf
    public float getFloat(int i2) {
        return Float.intBitsToFloat(getInt(i2));
    }

    @Override // io.netty.buffer.ByteBuf
    public int getInt(int i2) {
        checkIndex(i2, 4);
        return _getInt(i2);
    }

    @Override // io.netty.buffer.ByteBuf
    public int getIntLE(int i2) {
        checkIndex(i2, 4);
        return _getIntLE(i2);
    }

    @Override // io.netty.buffer.ByteBuf
    public long getLong(int i2) {
        checkIndex(i2, 8);
        return _getLong(i2);
    }

    @Override // io.netty.buffer.ByteBuf
    public long getLongLE(int i2) {
        checkIndex(i2, 8);
        return _getLongLE(i2);
    }

    @Override // io.netty.buffer.ByteBuf
    public int getMedium(int i2) {
        int unsignedMedium = getUnsignedMedium(i2);
        return (8388608 & unsignedMedium) != 0 ? unsignedMedium | (-16777216) : unsignedMedium;
    }

    @Override // io.netty.buffer.ByteBuf
    public int getMediumLE(int i2) {
        int unsignedMediumLE = getUnsignedMediumLE(i2);
        return (8388608 & unsignedMediumLE) != 0 ? unsignedMediumLE | (-16777216) : unsignedMediumLE;
    }

    @Override // io.netty.buffer.ByteBuf
    public short getShort(int i2) {
        checkIndex(i2, 2);
        return _getShort(i2);
    }

    @Override // io.netty.buffer.ByteBuf
    public short getShortLE(int i2) {
        checkIndex(i2, 2);
        return _getShortLE(i2);
    }

    @Override // io.netty.buffer.ByteBuf
    public short getUnsignedByte(int i2) {
        return (short) (getByte(i2) & 255);
    }

    @Override // io.netty.buffer.ByteBuf
    public long getUnsignedInt(int i2) {
        return ((long) getInt(i2)) & 4294967295L;
    }

    @Override // io.netty.buffer.ByteBuf
    public long getUnsignedIntLE(int i2) {
        return ((long) getIntLE(i2)) & 4294967295L;
    }

    @Override // io.netty.buffer.ByteBuf
    public int getUnsignedMedium(int i2) {
        checkIndex(i2, 3);
        return _getUnsignedMedium(i2);
    }

    @Override // io.netty.buffer.ByteBuf
    public int getUnsignedMediumLE(int i2) {
        checkIndex(i2, 3);
        return _getUnsignedMediumLE(i2);
    }

    @Override // io.netty.buffer.ByteBuf
    public int getUnsignedShort(int i2) {
        return getShort(i2) & 65535;
    }

    @Override // io.netty.buffer.ByteBuf
    public int getUnsignedShortLE(int i2) {
        return getShortLE(i2) & 65535;
    }

    @Override // io.netty.buffer.ByteBuf
    public int hashCode() {
        return ByteBufUtil.hashCode(this);
    }

    @Override // io.netty.buffer.ByteBuf
    public int indexOf(int i2, int i3, byte b2) {
        return ByteBufUtil.indexOf(this, i2, i3, b2);
    }

    @Override // io.netty.buffer.ByteBuf
    public boolean isReadOnly() {
        return false;
    }

    @Override // io.netty.buffer.ByteBuf
    public boolean isReadable() {
        return this.writerIndex > this.readerIndex;
    }

    @Override // io.netty.buffer.ByteBuf
    public boolean isWritable() {
        return capacity() > this.writerIndex;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf markReaderIndex() {
        this.markedReaderIndex = this.readerIndex;
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf markWriterIndex() {
        this.markedWriterIndex = this.writerIndex;
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public int maxCapacity() {
        return this.maxCapacity;
    }

    @Override // io.netty.buffer.ByteBuf
    public int maxWritableBytes() {
        return maxCapacity() - this.writerIndex;
    }

    protected SwappedByteBuf newSwappedByteBuf() {
        return new SwappedByteBuf(this);
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuffer nioBuffer() {
        return nioBuffer(this.readerIndex, readableBytes());
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuffer[] nioBuffers() {
        return nioBuffers(this.readerIndex, readableBytes());
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf order(ByteOrder byteOrder) {
        if (byteOrder != null) {
            return byteOrder == order() ? this : newSwappedByteBuf();
        }
        throw new NullPointerException("endianness");
    }

    @Override // io.netty.buffer.ByteBuf
    public boolean readBoolean() {
        return readByte() != 0;
    }

    @Override // io.netty.buffer.ByteBuf
    public byte readByte() {
        checkReadableBytes0(1);
        int i2 = this.readerIndex;
        byte b_getByte = _getByte(i2);
        this.readerIndex = i2 + 1;
        return b_getByte;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf readBytes(int i2) {
        checkReadableBytes(i2);
        if (i2 == 0) {
            return Unpooled.EMPTY_BUFFER;
        }
        ByteBuf byteBufBuffer = alloc().buffer(i2, this.maxCapacity);
        byteBufBuffer.writeBytes(this, this.readerIndex, i2);
        this.readerIndex += i2;
        return byteBufBuffer;
    }

    @Override // io.netty.buffer.ByteBuf
    public char readChar() {
        return (char) readShort();
    }

    @Override // io.netty.buffer.ByteBuf
    public CharSequence readCharSequence(int i2, Charset charset) {
        CharSequence charSequence = getCharSequence(this.readerIndex, i2, charset);
        this.readerIndex += i2;
        return charSequence;
    }

    @Override // io.netty.buffer.ByteBuf
    public double readDouble() {
        return Double.longBitsToDouble(readLong());
    }

    @Override // io.netty.buffer.ByteBuf
    public float readFloat() {
        return Float.intBitsToFloat(readInt());
    }

    @Override // io.netty.buffer.ByteBuf
    public int readInt() {
        checkReadableBytes0(4);
        int i_getInt = _getInt(this.readerIndex);
        this.readerIndex += 4;
        return i_getInt;
    }

    @Override // io.netty.buffer.ByteBuf
    public int readIntLE() {
        checkReadableBytes0(4);
        int i_getIntLE = _getIntLE(this.readerIndex);
        this.readerIndex += 4;
        return i_getIntLE;
    }

    @Override // io.netty.buffer.ByteBuf
    public long readLong() {
        checkReadableBytes0(8);
        long j_getLong = _getLong(this.readerIndex);
        this.readerIndex += 8;
        return j_getLong;
    }

    @Override // io.netty.buffer.ByteBuf
    public long readLongLE() {
        checkReadableBytes0(8);
        long j_getLongLE = _getLongLE(this.readerIndex);
        this.readerIndex += 8;
        return j_getLongLE;
    }

    @Override // io.netty.buffer.ByteBuf
    public int readMedium() {
        int unsignedMedium = readUnsignedMedium();
        return (8388608 & unsignedMedium) != 0 ? unsignedMedium | (-16777216) : unsignedMedium;
    }

    @Override // io.netty.buffer.ByteBuf
    public int readMediumLE() {
        int unsignedMediumLE = readUnsignedMediumLE();
        return (8388608 & unsignedMediumLE) != 0 ? unsignedMediumLE | (-16777216) : unsignedMediumLE;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf readRetainedSlice(int i2) {
        ByteBuf byteBufRetainedSlice = retainedSlice(this.readerIndex, i2);
        this.readerIndex += i2;
        return byteBufRetainedSlice;
    }

    @Override // io.netty.buffer.ByteBuf
    public short readShort() {
        checkReadableBytes0(2);
        short s_getShort = _getShort(this.readerIndex);
        this.readerIndex += 2;
        return s_getShort;
    }

    @Override // io.netty.buffer.ByteBuf
    public short readShortLE() {
        checkReadableBytes0(2);
        short s_getShortLE = _getShortLE(this.readerIndex);
        this.readerIndex += 2;
        return s_getShortLE;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf readSlice(int i2) {
        ByteBuf byteBufSlice = slice(this.readerIndex, i2);
        this.readerIndex += i2;
        return byteBufSlice;
    }

    @Override // io.netty.buffer.ByteBuf
    public short readUnsignedByte() {
        return (short) (readByte() & 255);
    }

    @Override // io.netty.buffer.ByteBuf
    public long readUnsignedInt() {
        return ((long) readInt()) & 4294967295L;
    }

    @Override // io.netty.buffer.ByteBuf
    public long readUnsignedIntLE() {
        return ((long) readIntLE()) & 4294967295L;
    }

    @Override // io.netty.buffer.ByteBuf
    public int readUnsignedMedium() {
        checkReadableBytes0(3);
        int i_getUnsignedMedium = _getUnsignedMedium(this.readerIndex);
        this.readerIndex += 3;
        return i_getUnsignedMedium;
    }

    @Override // io.netty.buffer.ByteBuf
    public int readUnsignedMediumLE() {
        checkReadableBytes0(3);
        int i_getUnsignedMediumLE = _getUnsignedMediumLE(this.readerIndex);
        this.readerIndex += 3;
        return i_getUnsignedMediumLE;
    }

    @Override // io.netty.buffer.ByteBuf
    public int readUnsignedShort() {
        return readShort() & 65535;
    }

    @Override // io.netty.buffer.ByteBuf
    public int readUnsignedShortLE() {
        return readShortLE() & 65535;
    }

    @Override // io.netty.buffer.ByteBuf
    public int readableBytes() {
        return this.writerIndex - this.readerIndex;
    }

    @Override // io.netty.buffer.ByteBuf
    public int readerIndex() {
        return this.readerIndex;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf resetReaderIndex() {
        readerIndex(this.markedReaderIndex);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf resetWriterIndex() {
        this.writerIndex = this.markedWriterIndex;
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf retainedDuplicate() {
        return duplicate().retain();
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf retainedSlice() {
        return slice().retain();
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf setBoolean(int i2, boolean z) {
        setByte(i2, z ? 1 : 0);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf setByte(int i2, int i3) {
        checkIndex(i2);
        _setByte(i2, i3);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf setBytes(int i2, byte[] bArr) {
        setBytes(i2, bArr, 0, bArr.length);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf setChar(int i2, int i3) {
        setShort(i2, i3);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public int setCharSequence(int i2, CharSequence charSequence, Charset charset) {
        if (charset.equals(CharsetUtil.UTF_8)) {
            ensureWritable(ByteBufUtil.utf8MaxBytes(charSequence));
            return ByteBufUtil.writeUtf8(this, i2, charSequence, charSequence.length());
        }
        if (charset.equals(CharsetUtil.US_ASCII)) {
            int length = charSequence.length();
            ensureWritable(length);
            return ByteBufUtil.writeAscii(this, i2, charSequence, length);
        }
        byte[] bytes = charSequence.toString().getBytes(charset);
        ensureWritable(bytes.length);
        setBytes(i2, bytes);
        return bytes.length;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf setDouble(int i2, double d2) {
        setLong(i2, Double.doubleToRawLongBits(d2));
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf setFloat(int i2, float f2) {
        setInt(i2, Float.floatToRawIntBits(f2));
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf setIndex(int i2, int i3) {
        if (i2 < 0 || i2 > i3 || i3 > capacity()) {
            throw new IndexOutOfBoundsException(String.format("readerIndex: %d, writerIndex: %d (expected: 0 <= readerIndex <= writerIndex <= capacity(%d))", Integer.valueOf(i2), Integer.valueOf(i3), Integer.valueOf(capacity())));
        }
        setIndex0(i2, i3);
        return this;
    }

    final void setIndex0(int i2, int i3) {
        this.readerIndex = i2;
        this.writerIndex = i3;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf setInt(int i2, int i3) {
        checkIndex(i2, 4);
        _setInt(i2, i3);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf setIntLE(int i2, int i3) {
        checkIndex(i2, 4);
        _setIntLE(i2, i3);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf setLong(int i2, long j2) {
        checkIndex(i2, 8);
        _setLong(i2, j2);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf setLongLE(int i2, long j2) {
        checkIndex(i2, 8);
        _setLongLE(i2, j2);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf setMedium(int i2, int i3) {
        checkIndex(i2, 3);
        _setMedium(i2, i3);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf setMediumLE(int i2, int i3) {
        checkIndex(i2, 3);
        _setMediumLE(i2, i3);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf setShort(int i2, int i3) {
        checkIndex(i2, 2);
        _setShort(i2, i3);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf setShortLE(int i2, int i3) {
        checkIndex(i2, 2);
        _setShortLE(i2, i3);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf setZero(int i2, int i3) {
        if (i3 == 0) {
            return this;
        }
        checkIndex(i2, i3);
        int i4 = i3 & 7;
        for (int i5 = i3 >>> 3; i5 > 0; i5--) {
            _setLong(i2, 0L);
            i2 += 8;
        }
        if (i4 == 4) {
            _setInt(i2, 0);
        } else if (i4 < 4) {
            while (i4 > 0) {
                _setByte(i2, 0);
                i2++;
                i4--;
            }
        } else {
            _setInt(i2, 0);
            int i6 = i2 + 4;
            for (int i7 = i4 - 4; i7 > 0; i7--) {
                _setByte(i6, 0);
                i6++;
            }
        }
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf skipBytes(int i2) {
        checkReadableBytes(i2);
        this.readerIndex += i2;
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf slice() {
        return slice(this.readerIndex, readableBytes());
    }

    @Override // io.netty.buffer.ByteBuf
    public String toString(Charset charset) {
        return toString(this.readerIndex, readableBytes(), charset);
    }

    @Override // io.netty.buffer.ByteBuf
    public int writableBytes() {
        return capacity() - this.writerIndex;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf writeBoolean(boolean z) {
        writeByte(z ? 1 : 0);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf writeByte(int i2) {
        ensureAccessible();
        ensureWritable0(1);
        int i3 = this.writerIndex;
        this.writerIndex = i3 + 1;
        _setByte(i3, i2);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf writeBytes(byte[] bArr, int i2, int i3) {
        ensureAccessible();
        ensureWritable(i3);
        setBytes(this.writerIndex, bArr, i2, i3);
        this.writerIndex += i3;
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf writeChar(int i2) {
        writeShort(i2);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public int writeCharSequence(CharSequence charSequence, Charset charset) {
        int charSequence2 = setCharSequence(this.writerIndex, charSequence, charset);
        this.writerIndex += charSequence2;
        return charSequence2;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf writeDouble(double d2) {
        writeLong(Double.doubleToRawLongBits(d2));
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf writeFloat(float f2) {
        writeInt(Float.floatToRawIntBits(f2));
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf writeInt(int i2) {
        ensureAccessible();
        ensureWritable0(4);
        _setInt(this.writerIndex, i2);
        this.writerIndex += 4;
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf writeIntLE(int i2) {
        ensureAccessible();
        ensureWritable0(4);
        _setIntLE(this.writerIndex, i2);
        this.writerIndex += 4;
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf writeLong(long j2) {
        ensureAccessible();
        ensureWritable0(8);
        _setLong(this.writerIndex, j2);
        this.writerIndex += 8;
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf writeLongLE(long j2) {
        ensureAccessible();
        ensureWritable0(8);
        _setLongLE(this.writerIndex, j2);
        this.writerIndex += 8;
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf writeMedium(int i2) {
        ensureAccessible();
        ensureWritable0(3);
        _setMedium(this.writerIndex, i2);
        this.writerIndex += 3;
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf writeMediumLE(int i2) {
        ensureAccessible();
        ensureWritable0(3);
        _setMediumLE(this.writerIndex, i2);
        this.writerIndex += 3;
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf writeShort(int i2) {
        ensureAccessible();
        ensureWritable0(2);
        _setShort(this.writerIndex, i2);
        this.writerIndex += 2;
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf writeShortLE(int i2) {
        ensureAccessible();
        ensureWritable0(2);
        _setShortLE(this.writerIndex, i2);
        this.writerIndex += 2;
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf writeZero(int i2) {
        if (i2 == 0) {
            return this;
        }
        ensureWritable(i2);
        int i3 = this.writerIndex;
        checkIndex(i3, i2);
        int i4 = i2 & 7;
        for (int i5 = i2 >>> 3; i5 > 0; i5--) {
            _setLong(i3, 0L);
            i3 += 8;
        }
        if (i4 == 4) {
            _setInt(i3, 0);
            i3 += 4;
        } else if (i4 < 4) {
            while (i4 > 0) {
                _setByte(i3, 0);
                i3++;
                i4--;
            }
        } else {
            _setInt(i3, 0);
            i3 += 4;
            for (int i6 = i4 - 4; i6 > 0; i6--) {
                _setByte(i3, 0);
                i3++;
            }
        }
        this.writerIndex = i3;
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public int writerIndex() {
        return this.writerIndex;
    }

    @Override // io.netty.buffer.ByteBuf
    public int bytesBefore(int i2, byte b2) {
        checkReadableBytes(i2);
        return bytesBefore(readerIndex(), i2, b2);
    }

    protected final void checkIndex(int i2, int i3) {
        ensureAccessible();
        checkIndex0(i2, i3);
    }

    @Override // io.netty.buffer.ByteBuf, java.lang.Comparable
    public int compareTo(ByteBuf byteBuf) {
        return ByteBufUtil.compare(this, byteBuf);
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf getBytes(int i2, ByteBuf byteBuf) {
        getBytes(i2, byteBuf, byteBuf.writableBytes());
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public boolean isReadable(int i2) {
        return this.writerIndex - this.readerIndex >= i2;
    }

    @Override // io.netty.buffer.ByteBuf
    public boolean isWritable(int i2) {
        return capacity() - this.writerIndex >= i2;
    }

    protected final void maxCapacity(int i2) {
        this.maxCapacity = i2;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf readerIndex(int i2) {
        if (i2 < 0 || i2 > this.writerIndex) {
            throw new IndexOutOfBoundsException(String.format("readerIndex: %d (expected: 0 <= readerIndex <= writerIndex(%d))", Integer.valueOf(i2), Integer.valueOf(this.writerIndex)));
        }
        this.readerIndex = i2;
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf retainedSlice(int i2, int i3) {
        return slice(i2, i3).retain();
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf setBytes(int i2, ByteBuf byteBuf) {
        setBytes(i2, byteBuf, byteBuf.readableBytes());
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf slice(int i2, int i3) {
        return new SlicedAbstractByteBuf(this, i2, i3);
    }

    @Override // io.netty.buffer.ByteBuf
    public String toString(int i2, int i3, Charset charset) {
        return ByteBufUtil.decodeString(this, i2, i3, charset);
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf writerIndex(int i2) {
        if (i2 < this.readerIndex || i2 > capacity()) {
            throw new IndexOutOfBoundsException(String.format("writerIndex: %d (expected: readerIndex(%d) <= writerIndex <= capacity(%d))", Integer.valueOf(i2), Integer.valueOf(this.readerIndex), Integer.valueOf(capacity())));
        }
        this.writerIndex = i2;
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public int ensureWritable(int i2, boolean z) {
        if (i2 >= 0) {
            if (i2 <= writableBytes()) {
                return 0;
            }
            if (i2 > this.maxCapacity - this.writerIndex && z) {
                if (capacity() == maxCapacity()) {
                    return 1;
                }
                capacity(maxCapacity());
                return 3;
            }
            capacity(alloc().calculateNewCapacity(this.writerIndex + i2, this.maxCapacity));
            return 2;
        }
        throw new IllegalArgumentException(String.format("minWritableBytes: %d (expected: >= 0)", Integer.valueOf(i2)));
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf getBytes(int i2, ByteBuf byteBuf, int i3) {
        getBytes(i2, byteBuf, byteBuf.writerIndex(), i3);
        byteBuf.writerIndex(byteBuf.writerIndex() + i3);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf setBytes(int i2, ByteBuf byteBuf, int i3) {
        checkIndex(i2, i3);
        if (byteBuf != null) {
            if (i3 <= byteBuf.readableBytes()) {
                setBytes(i2, byteBuf, byteBuf.readerIndex(), i3);
                byteBuf.readerIndex(byteBuf.readerIndex() + i3);
                return this;
            }
            throw new IndexOutOfBoundsException(String.format("length(%d) exceeds src.readableBytes(%d) where src is: %s", Integer.valueOf(i3), Integer.valueOf(byteBuf.readableBytes()), byteBuf));
        }
        throw new NullPointerException("src");
    }

    @Override // io.netty.buffer.ByteBuf
    public String toString() {
        if (refCnt() == 0) {
            return StringUtil.simpleClassName(this) + "(freed)";
        }
        StringBuilder sb = new StringBuilder();
        sb.append(StringUtil.simpleClassName(this));
        sb.append("(ridx: ");
        sb.append(this.readerIndex);
        sb.append(", widx: ");
        sb.append(this.writerIndex);
        sb.append(", cap: ");
        sb.append(capacity());
        if (this.maxCapacity != Integer.MAX_VALUE) {
            sb.append('/');
            sb.append(this.maxCapacity);
        }
        ByteBuf byteBufUnwrap = unwrap();
        if (byteBufUnwrap != null) {
            sb.append(", unwrapped: ");
            sb.append(byteBufUnwrap);
        }
        sb.append(')');
        return sb.toString();
    }

    @Override // io.netty.buffer.ByteBuf
    public int bytesBefore(int i2, int i3, byte b2) {
        int iIndexOf = indexOf(i2, i3 + i2, b2);
        if (iIndexOf < 0) {
            return -1;
        }
        return iIndexOf - i2;
    }

    @Override // io.netty.buffer.ByteBuf
    public int forEachByte(int i2, int i3, ByteProcessor byteProcessor) {
        checkIndex(i2, i3);
        return forEachByteAsc0(i2, i3, byteProcessor);
    }

    @Override // io.netty.buffer.ByteBuf
    public int forEachByteDesc(int i2, int i3, ByteProcessor byteProcessor) {
        checkIndex(i2, i3);
        return forEachByteDesc0(i2, i3, byteProcessor);
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf writeBytes(byte[] bArr) {
        writeBytes(bArr, 0, bArr.length);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf readBytes(byte[] bArr, int i2, int i3) {
        checkReadableBytes(i3);
        getBytes(this.readerIndex, bArr, i2, i3);
        this.readerIndex += i3;
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf writeBytes(ByteBuf byteBuf) {
        writeBytes(byteBuf, byteBuf.readableBytes());
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf writeBytes(ByteBuf byteBuf, int i2) {
        if (i2 <= byteBuf.readableBytes()) {
            writeBytes(byteBuf, byteBuf.readerIndex(), i2);
            byteBuf.readerIndex(byteBuf.readerIndex() + i2);
            return this;
        }
        throw new IndexOutOfBoundsException(String.format("length(%d) exceeds src.readableBytes(%d) where src is: %s", Integer.valueOf(i2), Integer.valueOf(byteBuf.readableBytes()), byteBuf));
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf readBytes(byte[] bArr) {
        readBytes(bArr, 0, bArr.length);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf readBytes(ByteBuf byteBuf) {
        readBytes(byteBuf, byteBuf.writableBytes());
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf readBytes(ByteBuf byteBuf, int i2) {
        if (i2 <= byteBuf.writableBytes()) {
            readBytes(byteBuf, byteBuf.writerIndex(), i2);
            byteBuf.writerIndex(byteBuf.writerIndex() + i2);
            return this;
        }
        throw new IndexOutOfBoundsException(String.format("length(%d) exceeds dst.writableBytes(%d) where dst is: %s", Integer.valueOf(i2), Integer.valueOf(byteBuf.writableBytes()), byteBuf));
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf writeBytes(ByteBuf byteBuf, int i2, int i3) {
        ensureAccessible();
        ensureWritable(i3);
        setBytes(this.writerIndex, byteBuf, i2, i3);
        this.writerIndex += i3;
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf readBytes(ByteBuf byteBuf, int i2, int i3) {
        checkReadableBytes(i3);
        getBytes(this.readerIndex, byteBuf, i2, i3);
        this.readerIndex += i3;
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf writeBytes(ByteBuffer byteBuffer) {
        ensureAccessible();
        int iRemaining = byteBuffer.remaining();
        ensureWritable(iRemaining);
        setBytes(this.writerIndex, byteBuffer);
        this.writerIndex += iRemaining;
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf readBytes(ByteBuffer byteBuffer) {
        int iRemaining = byteBuffer.remaining();
        checkReadableBytes(iRemaining);
        getBytes(this.readerIndex, byteBuffer);
        this.readerIndex += iRemaining;
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public int writeBytes(InputStream inputStream, int i2) throws IOException {
        ensureAccessible();
        ensureWritable(i2);
        int bytes = setBytes(this.writerIndex, inputStream, i2);
        if (bytes > 0) {
            this.writerIndex += bytes;
        }
        return bytes;
    }

    @Override // io.netty.buffer.ByteBuf
    public int readBytes(GatheringByteChannel gatheringByteChannel, int i2) throws IOException {
        checkReadableBytes(i2);
        int bytes = getBytes(this.readerIndex, gatheringByteChannel, i2);
        this.readerIndex += bytes;
        return bytes;
    }

    @Override // io.netty.buffer.ByteBuf
    public int writeBytes(ScatteringByteChannel scatteringByteChannel, int i2) throws IOException {
        ensureAccessible();
        ensureWritable(i2);
        int bytes = setBytes(this.writerIndex, scatteringByteChannel, i2);
        if (bytes > 0) {
            this.writerIndex += bytes;
        }
        return bytes;
    }

    @Override // io.netty.buffer.ByteBuf
    public int readBytes(FileChannel fileChannel, long j2, int i2) throws IOException {
        checkReadableBytes(i2);
        int bytes = getBytes(this.readerIndex, fileChannel, j2, i2);
        this.readerIndex += bytes;
        return bytes;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf readBytes(OutputStream outputStream, int i2) throws IOException {
        checkReadableBytes(i2);
        getBytes(this.readerIndex, outputStream, i2);
        this.readerIndex += i2;
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public int writeBytes(FileChannel fileChannel, long j2, int i2) throws IOException {
        ensureAccessible();
        ensureWritable(i2);
        int bytes = setBytes(this.writerIndex, fileChannel, j2, i2);
        if (bytes > 0) {
            this.writerIndex += bytes;
        }
        return bytes;
    }
}