package io.netty.buffer;

import g.a.a.a.a;
import io.netty.handler.codec.memcache.binary.BinaryMemcacheOpcodes;
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 */
public final class UnsafeByteBufUtil {
    public static final /* synthetic */ boolean $assertionsDisabled = false;
    private static final boolean UNALIGNED = PlatformDependent.isUnaligned();
    private static final byte ZERO = 0;

    private UnsafeByteBufUtil() {
    }

    public 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;
    }

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

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

    private static void getBytes(long j2, byte[] bArr, int i2, int i3, OutputStream outputStream, int i4) throws IOException {
        do {
            int iMin = Math.min(i3, i4);
            long j3 = iMin;
            PlatformDependent.copyMemory(j2, bArr, i2, j3);
            outputStream.write(bArr, i2, iMin);
            i4 -= iMin;
            j2 += j3;
        } while (i4 > 0);
    }

    public 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(a.l("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);
        }
    }

    public static void getBytes(AbstractByteBuf abstractByteBuf, long j2, int i2, OutputStream outputStream, int i3) {
        abstractByteBuf.checkIndex(i2, i3);
        if (i3 != 0) {
            int iMin = Math.min(i3, 8192);
            if (!abstractByteBuf.alloc().isDirectBufferPooled()) {
                getBytes(j2, new byte[iMin], 0, iMin, outputStream, i3);
                return;
            }
            ByteBuf byteBufHeapBuffer = abstractByteBuf.alloc().heapBuffer(iMin);
            try {
                getBytes(j2, byteBufHeapBuffer.array(), byteBufHeapBuffer.arrayOffset(), iMin, outputStream, i3);
            } finally {
                byteBufHeapBuffer.release();
            }
        }
    }

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

    public 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(a.l("dstIndex: ", i3));
        }
        if (i4 != 0) {
            PlatformDependent.copyMemory(j2, bArr, i3, i4);
        }
    }

    public static int getInt(long j2) {
        if (!UNALIGNED) {
            return (PlatformDependent.getByte(j2 + 3) & 255) | (PlatformDependent.getByte(j2) << BinaryMemcacheOpcodes.FLUSHQ) | ((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);
    }

    public static int getInt(byte[] bArr, int i2) {
        if (!UNALIGNED) {
            return (PlatformDependent.getByte(bArr, i2 + 3) & 255) | (PlatformDependent.getByte(bArr, i2) << BinaryMemcacheOpcodes.FLUSHQ) | ((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);
    }

    public static int getIntLE(long j2) {
        if (!UNALIGNED) {
            return (PlatformDependent.getByte(j2 + 3) << BinaryMemcacheOpcodes.FLUSHQ) | (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;
    }

    public static int getIntLE(byte[] bArr, int i2) {
        if (!UNALIGNED) {
            return (PlatformDependent.getByte(bArr, i2 + 3) << BinaryMemcacheOpcodes.FLUSHQ) | (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;
    }

    public 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);
    }

    public 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);
    }

    public 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;
    }

    public 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;
    }

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

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

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

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

    public static int getUnsignedMedium(long j2) {
        int i2;
        int i3;
        if (UNALIGNED) {
            i2 = (PlatformDependent.getByte(j2) & 255) << 16;
            boolean z2 = PlatformDependent.BIG_ENDIAN_NATIVE_ORDER;
            short sReverseBytes = PlatformDependent.getShort(j2 + 1);
            if (!z2) {
                sReverseBytes = Short.reverseBytes(sReverseBytes);
            }
            i3 = sReverseBytes & 65535;
        } else {
            i2 = ((PlatformDependent.getByte(j2) & 255) << 16) | ((PlatformDependent.getByte(1 + j2) & 255) << 8);
            i3 = PlatformDependent.getByte(j2 + 2) & 255;
        }
        return i3 | i2;
    }

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

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

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

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

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

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

    public static int setBytes(AbstractByteBuf abstractByteBuf, long j2, int i2, InputStream inputStream, int i3) {
        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();
        }
    }

    public 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(a.l("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);
            }
        }
    }

    public static void setBytes(AbstractByteBuf abstractByteBuf, long j2, int i2, ByteBuffer byteBuffer) {
        int iRemaining = byteBuffer.remaining();
        if (iRemaining == 0) {
            return;
        }
        if (byteBuffer.isDirect()) {
            abstractByteBuf.checkIndex(i2, iRemaining);
            PlatformDependent.copyMemory(PlatformDependent.directBufferAddress(byteBuffer) + ((long) byteBuffer.position()), j2, iRemaining);
        } else {
            if (!byteBuffer.hasArray()) {
                if (iRemaining < 8) {
                    setSingleBytes(abstractByteBuf, j2, i2, byteBuffer, iRemaining);
                    return;
                } else {
                    abstractByteBuf.internalNioBuffer(i2, iRemaining).put(byteBuffer);
                    return;
                }
            }
            abstractByteBuf.checkIndex(i2, iRemaining);
            PlatformDependent.copyMemory(byteBuffer.array(), byteBuffer.position() + byteBuffer.arrayOffset(), j2, iRemaining);
        }
        byteBuffer.position(byteBuffer.position() + iRemaining);
    }

    public 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);
        }
    }

    public 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);
        }
    }

    public 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);
        }
    }

    public 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));
        }
    }

    public 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));
        }
    }

    public 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);
    }

    public 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);
    }

    public 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));
    }

    public 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));
    }

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

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

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

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

    public 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);
        }
    }

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

    public 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);
        }
    }

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

    private static void setSingleBytes(AbstractByteBuf abstractByteBuf, long j2, int i2, ByteBuffer byteBuffer, int i3) {
        abstractByteBuf.checkIndex(i2, i3);
        int iLimit = byteBuffer.limit();
        for (int iPosition = byteBuffer.position(); iPosition < iLimit; iPosition++) {
            PlatformDependent.putByte(j2, byteBuffer.get(iPosition));
            j2++;
        }
        byteBuffer.position(iLimit);
    }

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

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