package io.netty.buffer;

import com.seewo.sdk.model.SDKKeyboardCode;
import io.netty.util.internal.MathUtil;
import io.netty.util.internal.ObjectUtil;
import io.netty.util.internal.PlatformDependent;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.ReadOnlyBufferException;

/* JADX INFO: loaded from: classes.dex */
final class UnsafeByteBufUtil {
    private static final boolean UNALIGNED = PlatformDependent.isUnaligned();
    private static final byte ZERO = 0;

    private UnsafeByteBufUtil() {
    }

    static ByteBuf copy(AbstractByteBuf abstractByteBuf, long j2, int i2, int i3) {
        abstractByteBuf.checkIndex(i2, i3);
        ByteBuf byteBufDirectBuffer = abstractByteBuf.alloc().directBuffer(i3, abstractByteBuf.maxCapacity());
        if (i3 != 0) {
            if (byteBufDirectBuffer.hasMemoryAddress()) {
                PlatformDependent.copyMemory(j2, byteBufDirectBuffer.memoryAddress(), i3);
                byteBufDirectBuffer.setIndex(0, i3);
            } else {
                byteBufDirectBuffer.writeBytes(abstractByteBuf, i2, i3);
            }
        }
        return byteBufDirectBuffer;
    }

    static byte getByte(long j2) {
        return PlatformDependent.getByte(j2);
    }

    static void getBytes(AbstractByteBuf abstractByteBuf, long j2, int i2, ByteBuf byteBuf, int i3, int i4) {
        abstractByteBuf.checkIndex(i2, i4);
        ObjectUtil.checkNotNull(byteBuf, "dst");
        if (MathUtil.isOutOfBounds(i3, i4, byteBuf.capacity())) {
            throw new IndexOutOfBoundsException("dstIndex: " + i3);
        }
        if (byteBuf.hasMemoryAddress()) {
            PlatformDependent.copyMemory(j2, byteBuf.memoryAddress() + ((long) i3), i4);
        } else if (byteBuf.hasArray()) {
            PlatformDependent.copyMemory(j2, byteBuf.array(), byteBuf.arrayOffset() + i3, i4);
        } else {
            byteBuf.setBytes(i3, abstractByteBuf, i2, i4);
        }
    }

    static int getInt(long j2) {
        if (!UNALIGNED) {
            return (PlatformDependent.getByte(j2 + 3) & 255) | (PlatformDependent.getByte(j2) << SDKKeyboardCode.FUNCTION_KEY_BOARD_U) | ((PlatformDependent.getByte(1 + j2) & 255) << 16) | ((PlatformDependent.getByte(2 + j2) & 255) << 8);
        }
        int i2 = PlatformDependent.getInt(j2);
        return PlatformDependent.BIG_ENDIAN_NATIVE_ORDER ? i2 : Integer.reverseBytes(i2);
    }

    static int getIntLE(long j2) {
        if (!UNALIGNED) {
            return (PlatformDependent.getByte(j2 + 3) << SDKKeyboardCode.FUNCTION_KEY_BOARD_U) | (PlatformDependent.getByte(j2) & 255) | ((PlatformDependent.getByte(1 + j2) & 255) << 8) | ((PlatformDependent.getByte(2 + j2) & 255) << 16);
        }
        int i2 = PlatformDependent.getInt(j2);
        return PlatformDependent.BIG_ENDIAN_NATIVE_ORDER ? Integer.reverseBytes(i2) : i2;
    }

    static long getLong(long j2) {
        if (!UNALIGNED) {
            return (((long) PlatformDependent.getByte(j2 + 7)) & 255) | (((long) PlatformDependent.getByte(j2)) << 56) | ((((long) PlatformDependent.getByte(1 + j2)) & 255) << 48) | ((((long) PlatformDependent.getByte(2 + j2)) & 255) << 40) | ((((long) PlatformDependent.getByte(3 + j2)) & 255) << 32) | ((((long) PlatformDependent.getByte(4 + j2)) & 255) << 24) | ((((long) PlatformDependent.getByte(5 + j2)) & 255) << 16) | ((((long) PlatformDependent.getByte(6 + j2)) & 255) << 8);
        }
        long j3 = PlatformDependent.getLong(j2);
        return PlatformDependent.BIG_ENDIAN_NATIVE_ORDER ? j3 : Long.reverseBytes(j3);
    }

    static long getLongLE(long j2) {
        if (!UNALIGNED) {
            return (((long) PlatformDependent.getByte(j2 + 7)) << 56) | (((long) PlatformDependent.getByte(j2)) & 255) | ((((long) PlatformDependent.getByte(1 + j2)) & 255) << 8) | ((((long) PlatformDependent.getByte(2 + j2)) & 255) << 16) | ((((long) PlatformDependent.getByte(3 + j2)) & 255) << 24) | ((((long) PlatformDependent.getByte(4 + j2)) & 255) << 32) | ((((long) PlatformDependent.getByte(5 + j2)) & 255) << 40) | ((255 & ((long) PlatformDependent.getByte(6 + j2))) << 48);
        }
        long j3 = PlatformDependent.getLong(j2);
        return PlatformDependent.BIG_ENDIAN_NATIVE_ORDER ? Long.reverseBytes(j3) : j3;
    }

    static short getShort(long j2) {
        if (!UNALIGNED) {
            return (short) ((PlatformDependent.getByte(j2 + 1) & 255) | (PlatformDependent.getByte(j2) << 8));
        }
        short s = PlatformDependent.getShort(j2);
        return PlatformDependent.BIG_ENDIAN_NATIVE_ORDER ? s : Short.reverseBytes(s);
    }

    static short getShortLE(long j2) {
        if (!UNALIGNED) {
            return (short) ((PlatformDependent.getByte(j2 + 1) << 8) | (PlatformDependent.getByte(j2) & 255));
        }
        short s = PlatformDependent.getShort(j2);
        return PlatformDependent.BIG_ENDIAN_NATIVE_ORDER ? Short.reverseBytes(s) : s;
    }

    static int getUnsignedMedium(long j2) {
        int iReverseBytes;
        byte b;
        int i2;
        if (!UNALIGNED) {
            iReverseBytes = ((PlatformDependent.getByte(j2) & 255) << 16) | ((PlatformDependent.getByte(1 + j2) & 255) << 8);
            b = PlatformDependent.getByte(j2 + 2);
        } else {
            if (PlatformDependent.BIG_ENDIAN_NATIVE_ORDER) {
                iReverseBytes = PlatformDependent.getByte(j2) & 255;
                i2 = (PlatformDependent.getShort(j2 + 1) & 65535) << 8;
                return i2 | iReverseBytes;
            }
            iReverseBytes = (Short.reverseBytes(PlatformDependent.getShort(j2)) & 65535) << 8;
            b = PlatformDependent.getByte(j2 + 2);
        }
        i2 = b & 255;
        return i2 | iReverseBytes;
    }

    static int getUnsignedMediumLE(long j2) {
        int iReverseBytes;
        int i2;
        if (!UNALIGNED) {
            int i3 = PlatformDependent.getByte(j2) & 255;
            long j3 = j2 + 1;
            iReverseBytes = i3 | ((PlatformDependent.getByte(j3) & 255) << 8);
            i2 = (PlatformDependent.getByte(j3) & 255) << 16;
        } else if (PlatformDependent.BIG_ENDIAN_NATIVE_ORDER) {
            iReverseBytes = (Short.reverseBytes(PlatformDependent.getShort(j2)) & 65535) << 8;
            i2 = PlatformDependent.getByte(j2 + 2) & 255;
        } else {
            iReverseBytes = PlatformDependent.getByte(j2) & 255;
            i2 = (PlatformDependent.getShort(j2 + 1) & 65535) << 8;
        }
        return i2 | iReverseBytes;
    }

    static UnpooledUnsafeDirectByteBuf newUnsafeDirectByteBuf(ByteBufAllocator byteBufAllocator, int i2, int i3) {
        return PlatformDependent.useDirectBufferNoCleaner() ? new UnpooledUnsafeNoCleanerDirectByteBuf(byteBufAllocator, i2, i3) : new UnpooledUnsafeDirectByteBuf(byteBufAllocator, i2, i3);
    }

    static void setByte(long j2, int i2) {
        PlatformDependent.putByte(j2, (byte) i2);
    }

    static int setBytes(AbstractByteBuf abstractByteBuf, long j2, int i2, InputStream inputStream, int i3) throws IOException {
        abstractByteBuf.checkIndex(i2, i3);
        ByteBuf byteBufHeapBuffer = abstractByteBuf.alloc().heapBuffer(i3);
        try {
            byte[] bArrArray = byteBufHeapBuffer.array();
            int iArrayOffset = byteBufHeapBuffer.arrayOffset();
            int i4 = inputStream.read(bArrArray, iArrayOffset, i3);
            if (i4 > 0) {
                PlatformDependent.copyMemory(bArrArray, iArrayOffset, j2, i4);
            }
            return i4;
        } finally {
            byteBufHeapBuffer.release();
        }
    }

    static void setInt(long j2, int i2) {
        if (UNALIGNED) {
            if (!PlatformDependent.BIG_ENDIAN_NATIVE_ORDER) {
                i2 = Integer.reverseBytes(i2);
            }
            PlatformDependent.putInt(j2, i2);
        } else {
            PlatformDependent.putByte(j2, (byte) (i2 >>> 24));
            PlatformDependent.putByte(1 + j2, (byte) (i2 >>> 16));
            PlatformDependent.putByte(2 + j2, (byte) (i2 >>> 8));
            PlatformDependent.putByte(j2 + 3, (byte) i2);
        }
    }

    static void setIntLE(long j2, int i2) {
        if (UNALIGNED) {
            if (PlatformDependent.BIG_ENDIAN_NATIVE_ORDER) {
                i2 = Integer.reverseBytes(i2);
            }
            PlatformDependent.putInt(j2, i2);
        } else {
            PlatformDependent.putByte(j2, (byte) i2);
            PlatformDependent.putByte(1 + j2, (byte) (i2 >>> 8));
            PlatformDependent.putByte(2 + j2, (byte) (i2 >>> 16));
            PlatformDependent.putByte(j2 + 3, (byte) (i2 >>> 24));
        }
    }

    static void setLong(long j2, long j3) {
        if (UNALIGNED) {
            if (!PlatformDependent.BIG_ENDIAN_NATIVE_ORDER) {
                j3 = Long.reverseBytes(j3);
            }
            PlatformDependent.putLong(j2, j3);
            return;
        }
        PlatformDependent.putByte(j2, (byte) (j3 >>> 56));
        PlatformDependent.putByte(1 + j2, (byte) (j3 >>> 48));
        PlatformDependent.putByte(2 + j2, (byte) (j3 >>> 40));
        PlatformDependent.putByte(3 + j2, (byte) (j3 >>> 32));
        PlatformDependent.putByte(4 + j2, (byte) (j3 >>> 24));
        PlatformDependent.putByte(5 + j2, (byte) (j3 >>> 16));
        PlatformDependent.putByte(6 + j2, (byte) (j3 >>> 8));
        PlatformDependent.putByte(j2 + 7, (byte) j3);
    }

    static void setLongLE(long j2, long j3) {
        if (UNALIGNED) {
            if (PlatformDependent.BIG_ENDIAN_NATIVE_ORDER) {
                j3 = Long.reverseBytes(j3);
            }
            PlatformDependent.putLong(j2, j3);
            return;
        }
        PlatformDependent.putByte(j2, (byte) j3);
        PlatformDependent.putByte(1 + j2, (byte) (j3 >>> 8));
        PlatformDependent.putByte(2 + j2, (byte) (j3 >>> 16));
        PlatformDependent.putByte(3 + j2, (byte) (j3 >>> 24));
        PlatformDependent.putByte(4 + j2, (byte) (j3 >>> 32));
        PlatformDependent.putByte(5 + j2, (byte) (j3 >>> 40));
        PlatformDependent.putByte(6 + j2, (byte) (j3 >>> 48));
        PlatformDependent.putByte(j2 + 7, (byte) (j3 >>> 56));
    }

    static void setMedium(long j2, int i2) {
        if (!UNALIGNED) {
            PlatformDependent.putByte(j2, (byte) (i2 >>> 16));
            PlatformDependent.putByte(1 + j2, (byte) (i2 >>> 8));
            PlatformDependent.putByte(j2 + 2, (byte) i2);
        } else if (PlatformDependent.BIG_ENDIAN_NATIVE_ORDER) {
            PlatformDependent.putByte(j2, (byte) i2);
            PlatformDependent.putShort(j2 + 1, (short) (i2 >>> 8));
        } else {
            PlatformDependent.putShort(j2, Short.reverseBytes((short) (i2 >>> 8)));
            PlatformDependent.putByte(j2 + 2, (byte) i2);
        }
    }

    static void setMediumLE(long j2, int i2) {
        if (!UNALIGNED) {
            PlatformDependent.putByte(j2, (byte) i2);
            PlatformDependent.putByte(1 + j2, (byte) (i2 >>> 8));
            PlatformDependent.putByte(j2 + 2, (byte) (i2 >>> 16));
        } else if (PlatformDependent.BIG_ENDIAN_NATIVE_ORDER) {
            PlatformDependent.putShort(j2, Short.reverseBytes((short) (i2 >>> 8)));
            PlatformDependent.putByte(j2 + 2, (byte) i2);
        } else {
            PlatformDependent.putByte(j2, (byte) i2);
            PlatformDependent.putShort(j2 + 1, (short) (i2 >>> 8));
        }
    }

    static void setShort(long j2, int i2) {
        if (!UNALIGNED) {
            PlatformDependent.putByte(j2, (byte) (i2 >>> 8));
            PlatformDependent.putByte(j2 + 1, (byte) i2);
        } else {
            short sReverseBytes = (short) i2;
            if (!PlatformDependent.BIG_ENDIAN_NATIVE_ORDER) {
                sReverseBytes = Short.reverseBytes(sReverseBytes);
            }
            PlatformDependent.putShort(j2, sReverseBytes);
        }
    }

    static void setShortLE(long j2, int i2) {
        if (!UNALIGNED) {
            PlatformDependent.putByte(j2, (byte) i2);
            PlatformDependent.putByte(j2 + 1, (byte) (i2 >>> 8));
        } else {
            short sReverseBytes = (short) i2;
            if (PlatformDependent.BIG_ENDIAN_NATIVE_ORDER) {
                sReverseBytes = Short.reverseBytes(sReverseBytes);
            }
            PlatformDependent.putShort(j2, sReverseBytes);
        }
    }

    static void setZero(byte[] bArr, int i2, int i3) {
        if (i3 == 0) {
            return;
        }
        PlatformDependent.setMemory(bArr, i2, i3, (byte) 0);
    }

    static byte getByte(byte[] bArr, int i2) {
        return PlatformDependent.getByte(bArr, i2);
    }

    static void setByte(byte[] bArr, int i2, int i3) {
        PlatformDependent.putByte(bArr, i2, (byte) i3);
    }

    static void setZero(AbstractByteBuf abstractByteBuf, long j2, int i2, int i3) {
        if (i3 == 0) {
            return;
        }
        abstractByteBuf.checkIndex(i2, i3);
        PlatformDependent.setMemory(j2, i3, (byte) 0);
    }

    static int getInt(byte[] bArr, int i2) {
        if (!UNALIGNED) {
            return (PlatformDependent.getByte(bArr, i2 + 3) & 255) | (PlatformDependent.getByte(bArr, i2) << SDKKeyboardCode.FUNCTION_KEY_BOARD_U) | ((PlatformDependent.getByte(bArr, i2 + 1) & 255) << 16) | ((PlatformDependent.getByte(bArr, i2 + 2) & 255) << 8);
        }
        int i3 = PlatformDependent.getInt(bArr, i2);
        return PlatformDependent.BIG_ENDIAN_NATIVE_ORDER ? i3 : Integer.reverseBytes(i3);
    }

    static int getIntLE(byte[] bArr, int i2) {
        if (!UNALIGNED) {
            return (PlatformDependent.getByte(bArr, i2 + 3) << SDKKeyboardCode.FUNCTION_KEY_BOARD_U) | (PlatformDependent.getByte(bArr, i2) & 255) | ((PlatformDependent.getByte(bArr, i2 + 1) & 255) << 8) | ((PlatformDependent.getByte(bArr, i2 + 2) & 255) << 16);
        }
        int i3 = PlatformDependent.getInt(bArr, i2);
        return PlatformDependent.BIG_ENDIAN_NATIVE_ORDER ? Integer.reverseBytes(i3) : i3;
    }

    static long getLong(byte[] bArr, int i2) {
        if (!UNALIGNED) {
            return (((long) PlatformDependent.getByte(bArr, i2 + 7)) & 255) | (((long) PlatformDependent.getByte(bArr, i2)) << 56) | ((((long) PlatformDependent.getByte(bArr, i2 + 1)) & 255) << 48) | ((((long) PlatformDependent.getByte(bArr, i2 + 2)) & 255) << 40) | ((((long) PlatformDependent.getByte(bArr, i2 + 3)) & 255) << 32) | ((((long) PlatformDependent.getByte(bArr, i2 + 4)) & 255) << 24) | ((((long) PlatformDependent.getByte(bArr, i2 + 5)) & 255) << 16) | ((((long) PlatformDependent.getByte(bArr, i2 + 6)) & 255) << 8);
        }
        long j2 = PlatformDependent.getLong(bArr, i2);
        return PlatformDependent.BIG_ENDIAN_NATIVE_ORDER ? j2 : Long.reverseBytes(j2);
    }

    static long getLongLE(byte[] bArr, int i2) {
        if (!UNALIGNED) {
            return (((long) PlatformDependent.getByte(bArr, i2 + 7)) << 56) | (((long) PlatformDependent.getByte(bArr, i2)) & 255) | ((((long) PlatformDependent.getByte(bArr, i2 + 1)) & 255) << 8) | ((((long) PlatformDependent.getByte(bArr, i2 + 2)) & 255) << 16) | ((((long) PlatformDependent.getByte(bArr, i2 + 3)) & 255) << 24) | ((((long) PlatformDependent.getByte(bArr, i2 + 4)) & 255) << 32) | ((((long) PlatformDependent.getByte(bArr, i2 + 5)) & 255) << 40) | ((255 & ((long) PlatformDependent.getByte(bArr, i2 + 6))) << 48);
        }
        long j2 = PlatformDependent.getLong(bArr, i2);
        return PlatformDependent.BIG_ENDIAN_NATIVE_ORDER ? Long.reverseBytes(j2) : j2;
    }

    static short getShort(byte[] bArr, int i2) {
        if (!UNALIGNED) {
            return (short) ((PlatformDependent.getByte(bArr, i2 + 1) & 255) | (PlatformDependent.getByte(bArr, i2) << 8));
        }
        short s = PlatformDependent.getShort(bArr, i2);
        return PlatformDependent.BIG_ENDIAN_NATIVE_ORDER ? s : Short.reverseBytes(s);
    }

    static short getShortLE(byte[] bArr, int i2) {
        if (UNALIGNED) {
            short s = PlatformDependent.getShort(bArr, i2);
            return PlatformDependent.BIG_ENDIAN_NATIVE_ORDER ? Short.reverseBytes(s) : s;
        }
        return (short) ((PlatformDependent.getByte(i2) & 255) | (PlatformDependent.getByte(i2 + 1) << 8));
    }

    static void setShort(byte[] bArr, int i2, int i3) {
        if (UNALIGNED) {
            short sReverseBytes = (short) i3;
            if (!PlatformDependent.BIG_ENDIAN_NATIVE_ORDER) {
                sReverseBytes = Short.reverseBytes(sReverseBytes);
            }
            PlatformDependent.putShort(bArr, i2, sReverseBytes);
            return;
        }
        PlatformDependent.putByte(bArr, i2, (byte) (i3 >>> 8));
        PlatformDependent.putByte(bArr, i2 + 1, (byte) i3);
    }

    static void setShortLE(byte[] bArr, int i2, int i3) {
        if (UNALIGNED) {
            short sReverseBytes = (short) i3;
            if (PlatformDependent.BIG_ENDIAN_NATIVE_ORDER) {
                sReverseBytes = Short.reverseBytes(sReverseBytes);
            }
            PlatformDependent.putShort(bArr, i2, sReverseBytes);
            return;
        }
        PlatformDependent.putByte(bArr, i2, (byte) i3);
        PlatformDependent.putByte(bArr, i2 + 1, (byte) (i3 >>> 8));
    }

    static int getUnsignedMedium(byte[] bArr, int i2) {
        int iReverseBytes;
        byte b;
        int i3;
        if (UNALIGNED) {
            if (PlatformDependent.BIG_ENDIAN_NATIVE_ORDER) {
                iReverseBytes = PlatformDependent.getByte(bArr, i2) & 255;
                i3 = (PlatformDependent.getShort(bArr, i2 + 1) & 65535) << 8;
                return i3 | iReverseBytes;
            }
            iReverseBytes = (Short.reverseBytes(PlatformDependent.getShort(bArr, i2)) & 65535) << 8;
            b = PlatformDependent.getByte(bArr, i2 + 2);
        } else {
            iReverseBytes = ((PlatformDependent.getByte(bArr, i2) & 255) << 16) | ((PlatformDependent.getByte(bArr, i2 + 1) & 255) << 8);
            b = PlatformDependent.getByte(bArr, i2 + 2);
        }
        i3 = b & 255;
        return i3 | iReverseBytes;
    }

    static int getUnsignedMediumLE(byte[] bArr, int i2) {
        int iReverseBytes;
        int i3;
        if (UNALIGNED) {
            if (PlatformDependent.BIG_ENDIAN_NATIVE_ORDER) {
                iReverseBytes = (Short.reverseBytes(PlatformDependent.getShort(bArr, i2)) & 65535) << 8;
                i3 = PlatformDependent.getByte(bArr, i2 + 2) & 255;
            } else {
                iReverseBytes = PlatformDependent.getByte(bArr, i2) & 255;
                i3 = (PlatformDependent.getShort(bArr, i2 + 1) & 65535) << 8;
            }
        } else {
            iReverseBytes = (PlatformDependent.getByte(bArr, i2) & 255) | ((PlatformDependent.getByte(bArr, i2 + 1) & 255) << 8);
            i3 = (PlatformDependent.getByte(bArr, i2 + 2) & 255) << 16;
        }
        return i3 | iReverseBytes;
    }

    static void setInt(byte[] bArr, int i2, int i3) {
        if (UNALIGNED) {
            if (!PlatformDependent.BIG_ENDIAN_NATIVE_ORDER) {
                i3 = Integer.reverseBytes(i3);
            }
            PlatformDependent.putInt(bArr, i2, i3);
        } else {
            PlatformDependent.putByte(bArr, i2, (byte) (i3 >>> 24));
            PlatformDependent.putByte(bArr, i2 + 1, (byte) (i3 >>> 16));
            PlatformDependent.putByte(bArr, i2 + 2, (byte) (i3 >>> 8));
            PlatformDependent.putByte(bArr, i2 + 3, (byte) i3);
        }
    }

    static void setIntLE(byte[] bArr, int i2, int i3) {
        if (UNALIGNED) {
            if (PlatformDependent.BIG_ENDIAN_NATIVE_ORDER) {
                i3 = Integer.reverseBytes(i3);
            }
            PlatformDependent.putInt(bArr, i2, i3);
        } else {
            PlatformDependent.putByte(bArr, i2, (byte) i3);
            PlatformDependent.putByte(bArr, i2 + 1, (byte) (i3 >>> 8));
            PlatformDependent.putByte(bArr, i2 + 2, (byte) (i3 >>> 16));
            PlatformDependent.putByte(bArr, i2 + 3, (byte) (i3 >>> 24));
        }
    }

    static void setBytes(AbstractByteBuf abstractByteBuf, long j2, int i2, ByteBuf byteBuf, int i3, int i4) {
        abstractByteBuf.checkIndex(i2, i4);
        ObjectUtil.checkNotNull(byteBuf, "src");
        if (MathUtil.isOutOfBounds(i3, i4, byteBuf.capacity())) {
            throw new IndexOutOfBoundsException("srcIndex: " + i3);
        }
        if (i4 != 0) {
            if (byteBuf.hasMemoryAddress()) {
                PlatformDependent.copyMemory(byteBuf.memoryAddress() + ((long) i3), j2, i4);
            } else if (byteBuf.hasArray()) {
                PlatformDependent.copyMemory(byteBuf.array(), byteBuf.arrayOffset() + i3, j2, i4);
            } else {
                byteBuf.getBytes(i3, abstractByteBuf, i2, i4);
            }
        }
    }

    static void getBytes(AbstractByteBuf abstractByteBuf, long j2, int i2, byte[] bArr, int i3, int i4) {
        abstractByteBuf.checkIndex(i2, i4);
        ObjectUtil.checkNotNull(bArr, "dst");
        if (MathUtil.isOutOfBounds(i3, i4, bArr.length)) {
            throw new IndexOutOfBoundsException("dstIndex: " + i3);
        }
        if (i4 != 0) {
            PlatformDependent.copyMemory(j2, bArr, i3, i4);
        }
    }

    static void setMedium(byte[] bArr, int i2, int i3) {
        if (UNALIGNED) {
            if (PlatformDependent.BIG_ENDIAN_NATIVE_ORDER) {
                PlatformDependent.putByte(bArr, i2, (byte) i3);
                PlatformDependent.putShort(bArr, i2 + 1, (short) (i3 >>> 8));
                return;
            } else {
                PlatformDependent.putShort(bArr, i2, Short.reverseBytes((short) (i3 >>> 8)));
                PlatformDependent.putByte(bArr, i2 + 2, (byte) i3);
                return;
            }
        }
        PlatformDependent.putByte(bArr, i2, (byte) (i3 >>> 16));
        PlatformDependent.putByte(bArr, i2 + 1, (byte) (i3 >>> 8));
        PlatformDependent.putByte(bArr, i2 + 2, (byte) i3);
    }

    static void setMediumLE(byte[] bArr, int i2, int i3) {
        if (UNALIGNED) {
            if (PlatformDependent.BIG_ENDIAN_NATIVE_ORDER) {
                PlatformDependent.putShort(bArr, i2, Short.reverseBytes((short) (i3 >>> 8)));
                PlatformDependent.putByte(bArr, i2 + 2, (byte) i3);
                return;
            } else {
                PlatformDependent.putByte(bArr, i2, (byte) i3);
                PlatformDependent.putShort(bArr, i2 + 1, (short) (i3 >>> 8));
                return;
            }
        }
        PlatformDependent.putByte(bArr, i2, (byte) i3);
        PlatformDependent.putByte(bArr, i2 + 1, (byte) (i3 >>> 8));
        PlatformDependent.putByte(bArr, i2 + 2, (byte) (i3 >>> 16));
    }

    static void setLong(byte[] bArr, int i2, long j2) {
        if (UNALIGNED) {
            if (!PlatformDependent.BIG_ENDIAN_NATIVE_ORDER) {
                j2 = Long.reverseBytes(j2);
            }
            PlatformDependent.putLong(bArr, i2, j2);
            return;
        }
        PlatformDependent.putByte(bArr, i2, (byte) (j2 >>> 56));
        PlatformDependent.putByte(bArr, i2 + 1, (byte) (j2 >>> 48));
        PlatformDependent.putByte(bArr, i2 + 2, (byte) (j2 >>> 40));
        PlatformDependent.putByte(bArr, i2 + 3, (byte) (j2 >>> 32));
        PlatformDependent.putByte(bArr, i2 + 4, (byte) (j2 >>> 24));
        PlatformDependent.putByte(bArr, i2 + 5, (byte) (j2 >>> 16));
        PlatformDependent.putByte(bArr, i2 + 6, (byte) (j2 >>> 8));
        PlatformDependent.putByte(bArr, i2 + 7, (byte) j2);
    }

    static void setLongLE(byte[] bArr, int i2, long j2) {
        if (UNALIGNED) {
            if (PlatformDependent.BIG_ENDIAN_NATIVE_ORDER) {
                j2 = Long.reverseBytes(j2);
            }
            PlatformDependent.putLong(bArr, i2, j2);
            return;
        }
        PlatformDependent.putByte(bArr, i2, (byte) j2);
        PlatformDependent.putByte(bArr, i2 + 1, (byte) (j2 >>> 8));
        PlatformDependent.putByte(bArr, i2 + 2, (byte) (j2 >>> 16));
        PlatformDependent.putByte(bArr, i2 + 3, (byte) (j2 >>> 24));
        PlatformDependent.putByte(bArr, i2 + 4, (byte) (j2 >>> 32));
        PlatformDependent.putByte(bArr, i2 + 5, (byte) (j2 >>> 40));
        PlatformDependent.putByte(bArr, i2 + 6, (byte) (j2 >>> 48));
        PlatformDependent.putByte(bArr, i2 + 7, (byte) (j2 >>> 56));
    }

    static void getBytes(AbstractByteBuf abstractByteBuf, long j2, int i2, ByteBuffer byteBuffer) {
        abstractByteBuf.checkIndex(i2);
        int iMin = Math.min(abstractByteBuf.capacity() - i2, byteBuffer.remaining());
        if (iMin == 0) {
            return;
        }
        if (byteBuffer.isDirect()) {
            if (!byteBuffer.isReadOnly()) {
                PlatformDependent.copyMemory(j2, PlatformDependent.directBufferAddress(byteBuffer) + ((long) byteBuffer.position()), iMin);
                byteBuffer.position(byteBuffer.position() + iMin);
                return;
            }
            throw new ReadOnlyBufferException();
        }
        if (byteBuffer.hasArray()) {
            PlatformDependent.copyMemory(j2, byteBuffer.array(), byteBuffer.arrayOffset() + byteBuffer.position(), iMin);
            byteBuffer.position(byteBuffer.position() + iMin);
        } else {
            byteBuffer.put(abstractByteBuf.nioBuffer());
        }
    }

    static void setBytes(AbstractByteBuf abstractByteBuf, long j2, int i2, byte[] bArr, int i3, int i4) {
        abstractByteBuf.checkIndex(i2, i4);
        if (i4 != 0) {
            PlatformDependent.copyMemory(bArr, i3, j2, i4);
        }
    }

    static void setBytes(AbstractByteBuf abstractByteBuf, long j2, int i2, ByteBuffer byteBuffer) {
        abstractByteBuf.checkIndex(i2, byteBuffer.remaining());
        int iRemaining = byteBuffer.remaining();
        if (iRemaining == 0) {
            return;
        }
        if (byteBuffer.isDirect()) {
            PlatformDependent.copyMemory(PlatformDependent.directBufferAddress(byteBuffer) + ((long) byteBuffer.position()), j2, byteBuffer.remaining());
            byteBuffer.position(byteBuffer.position() + iRemaining);
        } else {
            if (byteBuffer.hasArray()) {
                PlatformDependent.copyMemory(byteBuffer.array(), byteBuffer.arrayOffset() + byteBuffer.position(), j2, iRemaining);
                byteBuffer.position(byteBuffer.position() + iRemaining);
                return;
            }
            ByteBuf byteBufHeapBuffer = abstractByteBuf.alloc().heapBuffer(iRemaining);
            try {
                byte[] bArrArray = byteBufHeapBuffer.array();
                byteBuffer.get(bArrArray, byteBufHeapBuffer.arrayOffset(), iRemaining);
                PlatformDependent.copyMemory(bArrArray, byteBufHeapBuffer.arrayOffset(), j2, iRemaining);
            } finally {
                byteBufHeapBuffer.release();
            }
        }
    }

    static void getBytes(AbstractByteBuf abstractByteBuf, long j2, int i2, OutputStream outputStream, int i3) throws IOException {
        abstractByteBuf.checkIndex(i2, i3);
        if (i3 != 0) {
            ByteBuf byteBufHeapBuffer = abstractByteBuf.alloc().heapBuffer(i3);
            try {
                byte[] bArrArray = byteBufHeapBuffer.array();
                int iArrayOffset = byteBufHeapBuffer.arrayOffset();
                PlatformDependent.copyMemory(j2, bArrArray, iArrayOffset, i3);
                outputStream.write(bArrArray, iArrayOffset, i3);
            } finally {
                byteBufHeapBuffer.release();
            }
        }
    }
}