blake

package org.runeforge.net;

/**
 * A legal, more safe, and more efficient alternative to the "stream" class
 * found in most wL-based servers. This class performs capacity ensuring and
 * uses more familiar data-type naming conventions. It also has every method you
 * would ever need (and more, I'm afraid) to implement the RuneScape protocol,
 * and applies encryption to the data in the buffer automatically.
 *
 * @author blakeman8192
 */
public class RSBuffer
{

    private byte[] buffer;
    private int offset, sizeOffset, bitPosition, length;
    private ISAACCipher encryption, decryption;
    public static int[] bitMask = new int[32];

    static
    {
        for (int i = 0; i < bitMask.length; i++)
            RSBuffer.bitMask[i] = (1 << i) - 1;
    }

    /**
     * Initializes offset with value 0 and buffer with capacity of 128.
     */
    public RSBuffer()
    {
        offset = 0;
        buffer = new byte[128];
    }

    /**
     * Initializes offset with value 0 and buffer with the argued capacity.
     *
     * @param capacity
     *            The capacity of the buffer.
     */
    public RSBuffer(int capacity)
    {
        offset = 0;
        buffer = new byte[capacity];
    }

    public RSBuffer(byte[] buffer, int length)
    {
        offset = 0;
        this.buffer = buffer;
        this.length = length;
    }

    public int getRemaining()
    {
        return length - offset;
    }

    /**
     * Gets the internal buffer.
     */
    public byte[] getBuffer()
    {
        return buffer;
    }

    /**
     * Sets the ISAAC cipher of this buffer. Note that this buffer generates the
     * cipher itself from the two keys.
     *
     * @param serverKey
     *            The server key of the cipher.
     * @param clientKey
     *            The client key of the cipher.
     */
    public void setISAACSeed(long serverKey, long clientKey)
    {
        int[] seed = new int[]
        { (int) (clientKey >> 32), (int) clientKey, (int) (serverKey >> 32), (int) serverKey };
        decryption = new ISAACCipher(seed);
        for (int i : seed)
            i += 50;
        encryption = new ISAACCipher(seed);
    }

    /**
     * Clears the buffer: sets every value inside the buffer to 0 and sets the
     * offset to 0.
     */
    public void clear()
    {
        for (int i = 0; i < offset; i++)
            buffer[i] = 0;
        offset = 0;
    }

    /**
     * Gets the offset of the buffer.
     */
    public int getOffset()
    {
        return offset;
    }

    /**
     * Gets the encryption <code>ISAACCipher</code>.
     */
    public ISAACCipher getEncryption()
    {
        return encryption;
    }

    /**
     * Gets the decryption <code>ISAACCipher</code>.
     */
    public ISAACCipher getDecryption()
    {
        return decryption;
    }

    /**
     * Ensures that the internal buffer can have another byte written to it, if
     * not, the buffer will be doubled in size.
     */
    protected void ensureCapacity()
    {
        if (offset + 1 < buffer.length)
            return;
        byte[] currentBuffer = new byte[buffer.length];
        System.arraycopy(buffer, 0, currentBuffer, 0, offset);
        buffer = new byte[buffer.length * 2];
        System.arraycopy(currentBuffer, 0, buffer, 0, offset);
    }

    /**
     * Starts bit access.
     *
     * @return The instance of this class, for chaining.
     */
    public RSBuffer startBitAccess()
    {
        bitPosition = offset * 8;
        return this;
    }

    /**
     * Ends bit access.
     *
     * @return The instance of this class, for chaining.
     */
    public RSBuffer endBitAccess()
    {
        offset = (bitPosition + 7) / 8;
        return this;
    }

    /**
     * Puts bits into the buffer.
     *
     * @param amount
     *            The amount of bits.
     * @param value
     *            The value of the bits.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putBits(int amount, int value)
    {
        int byteOffset = bitPosition >> 3;
        int bitOffset = 8 - (bitPosition & 7);
        bitPosition += amount;
        for (; amount > bitOffset; bitOffset = 8)
        {
            buffer[byteOffset] &= ~bitMask[bitOffset];
            buffer[byteOffset++] |= (value >> (amount - bitOffset)) & bitMask[bitOffset];

            amount -= bitOffset;
        }
        if (amount == bitOffset)
        {
            buffer[byteOffset] &= ~bitMask[bitOffset];
            buffer[byteOffset] |= value & bitMask[bitOffset];
        } else
        {
            buffer[byteOffset] &= ~(bitMask[amount] << (bitOffset - amount));
            buffer[byteOffset] |= (value & bitMask[amount]) << (bitOffset - amount);
        }
        return this;
    }

    /**
     * Creates a packet.
     *
     * @param i
     *            The opcode of the packet.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer createPacket(int i)
    {
        return put(i + encryption.nextInt());
    }

    /**
     * Creates a variable-sized packet.
     *
     * @param i
     *            The opcode of the packet.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer createPacketVarSize(int i)
    {
        createPacket(i);
        sizeOffset = offset;
        return put(0);
    }

    /**
     * Ends a variable-sized packet.
     *
     * @return The instance of this class, for chaining.
     */
    public RSBuffer endPacketVarSize()
    {
        put(offset - sizeOffset, sizeOffset);
        return this;
    }

    /**
     * Creates a variable-sized packet where the size is written as a
     * <code>short</code>.
     *
     * @param i
     *            The opcode of the packet.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer createPacketVarSizeShort(int i)
    {
        createPacket(i);
        sizeOffset = offset;
        return putShort(0);
    }

    /**
     * Ends a variable-sized packet where the size is written as a
     * <code>short</code>.
     *
     * @return The instance of this class, for chaining.
     */
    public RSBuffer endPacketVarSizeShort()
    {
        put((offset - sizeOffset) >> 8, sizeOffset++);
        put(offset - sizeOffset, sizeOffset);
        return this;
    }

    /**
     * Puts a <code>byte</code> into the buffer.
     *
     * @param i
     *            The <code>byte</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer put(int i)
    {
        ensureCapacity();
        buffer[offset++] = (byte) i;
        return this;
    }

    public int getOpcode()
    {
        return get() - decryption.nextInt() & 0xff;
    }

    /**
     * Puts a <code>byte</code> into the argued position in the buffer.
     *
     * @param i
     *            The <code>byte</code> value to put.
     * @param offset
     *            The position of the byte.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer put(int i, int offset)
    {
        buffer[offset] = (byte) i;
        return this;
    }

    /**
     * Gets a <code>byte</code> from the buffer, and decrements the offset.
     */
    public int get()
    {
        return buffer[offset++] & 0xff;
    }

    /**
     * Gets a special-A <code>byte</code> from the buffer.
     */
    public int getA()
    {
        return get() - 128;
    }

    /**
     * Gets a special-C <code>byte</code> from the buffer.
     */
    public int getC()
    {
        return -get();
    }

    /**
     * Gets a special-S <code>byte</code> from the buffer.
     */
    public int getS()
    {
        return 128 - get();
    }

    /**
     * Gets an <code>short</code> from the buffer.
     */
    public int getShort()
    {
        return (get() << 8) | get();
    }

    /**
     * Gets a special-A <code>short</code> from the buffer.
     */
    public int getShortA()
    {
        return (get() << 8) | getA();
    }

    /**
     * Gets a special-C <code>short</code> from the buffer.
     */
    public int getShortC()
    {
        return (get() << 8) | getC();
    }

    /**
     * Gets a special-S <code>short</code> from the buffer.
     */
    public int getShortS()
    {
        return (get() << 8) | getS();
    }

    /**
     * Gets a little-endian <code>short</code> from the buffer.
     */
    public int getLEShort()
    {
        return get() | (get() << 8);
    }

    /**
     * Gets a little-endian special-A <code>short</code> from the buffer.
     */
    public int getLEShortA()
    {
        return getA() | (get() << 8);
    }

    /**
     * Gets a little-endian special-C <code>short</code> from the buffer.
     */
    public int getLEShortC()
    {
        return getC() | (get() << 8);
    }

    /**
     * Gets a little-endian special-S <code>short</code> from the buffer.
     */
    public int getLEShortS()
    {
        return getS() | (get() << 8);
    }

    /**
     * Gets a <code>tribyte</code> from the buffer.
     */
    public int getTribyte()
    {
        return (get() << 16) | getShort();
    }

    /**
     * Gets a special-A <code>tribyte</code> from the buffer.
     */
    public int getTribyteA()
    {
        return (get() << 16) | getShortA();
    }

    /**
     * Gets a special-C <code>tribyte</code> from the buffer.
     */
    public int getTribyteC()
    {
        return (get() << 16) | getShortC();
    }

    /**
     * Gets a special-S <code>tribyte</code> from the buffer.
     */
    public int getTribyteS()
    {
        return (get() << 16) | getShortS();
    }

    /**
     * Gets a little-endian <code>tribyte</code> from the buffer.
     */
    public int getLETribyte()
    {
        return getShort() | (get() << 16);
    }

    /**
     * Gets a little-endian special-A <code>tribyte</code> from the buffer.
     */
    public int getLETribyteA()
    {
        return getShortA() | (get() << 16);
    }

    /**
     * Gets a little-endian special-C <code>tribyte</code> from the buffer.
     */
    public int getLETribyteC()
    {
        return getShortC() | (get() << 16);
    }

    /**
     * Gets a little-endian special-S <code>tribyte</code> from the buffer.
     */
    public int getLETribyteS()
    {
        return getShortS() | (get() << 16);
    }

    /**
     * Gets an <code>int</code> from the buffer.
     */
    public int getInt()
    {
        return (getShort() << 16) | getShort();
    }

    /**
     * Gets an <code>int1</code> from the buffer.
     */
    public int getInt1()
    {
        return (get() << 16) | (get() << 24) | getLEShort();
    }

    /**
     * Gets a special-A <code>int1</code> from the buffer.
     */
    public int getInt1A()
    {
        return (get() << 16) | (get() << 24) | getLEShortA();
    }

    /**
     * Gets a special-C <code>int1</code> from the buffer.
     */
    public int getInt1C()
    {
        return (get() << 16) | (get() << 24) | getLEShortC();
    }

    /**
     * Gets a special-S <code>int1</code> from the buffer.
     */
    public int getInt1S()
    {
        return (get() << 16) | (get() << 24) | getLEShortS();
    }

    /**
     * Gets an <code>int2</code> from the buffer.
     */
    public int getInt2()
    {
        return getShort() | (get() << 24) | (get() << 16);
    }

    /**
     * Gets a special-A <code>int2</code> from the buffer.
     */
    public int getInt2A()
    {
        return getShortA() | (get() << 24) | (get() << 16);
    }

    /**
     * Gets a special-C <code>int2</code> from the buffer.
     */
    public int getInt2C()
    {
        return getShortC() | (get() << 24) | (get() << 16);
    }

    /**
     * Gets a special-S <code>int2</code> from the buffer.
     */
    public int getInt2S()
    {
        return getShortS() | (get() << 24) | (get() << 16);
    }

    /**
     * Gets a special-A <code>int</code> from the buffer.
     */
    public int getIntA()
    {
        return (getShort() << 16) | getShortA();
    }

    /**
     * Gets a special-C <code>int</code> from the buffer.
     */
    public int getIntC()
    {
        return (getShort() << 16) | getShortC();
    }

    /**
     * Gets a special-S <code>int</code> from the buffer.
     */
    public int getIntS()
    {
        return (getShort() << 16) | getShortS();
    }

    /**
     * Gets a little-endian <code>int</code> from the buffer.
     */
    public int getLEInt()
    {
        return getShort() | (getShort() << 16);
    }

    /**
     * Gets a little-endian special-A <code>int</code> from the buffer.
     */
    public int getLEIntA()
    {
        return getShortA() | (getShort() << 16);
    }

    /**
     * Gets a little-endian special-C <code>int</code> from the buffer.
     */
    public int getLEIntC()
    {
        return getShortC() | (getShort() << 16);
    }

    /**
     * Gets a little-endian special-S <code>int</code> from the buffer.
     */
    public int getLEIntS()
    {
        return getShortS() | (getShort() << 16);
    }

    /**
     * Gets a <code>long</code> from the buffer.
     */
    public long getLong()
    {
        return ((long) getInt() << 32L) | (long) getInt();
    }

    /**
     * Gets a special-A <code>long</code> from the buffer.
     */
    public long getLongA()
    {
        return ((long) getInt() << 32L) | (long) getIntA();
    }

    /**
     * Gets a special-C <code>long</code> from the buffer.
     */
    public long getLongC()
    {
        return ((long) getInt() << 32L) | (long) getIntC();
    }

    /**
     * Gets a special-S <code>long</code> from the buffer.
     */
    public long getLongS()
    {
        return ((long) getInt() << 32L) | (long) getIntS();
    }

    /**
     * Gets a little-endian <code>long</code> from the buffer.
     */
    public long getLELong()
    {
        return (long) getInt() | ((long) getInt() << 32L);
    }

    /**
     * Gets a little-endian special-A <code>long</code> from the buffer.
     */
    public long getLELongA()
    {
        return (long) getIntA() | ((long) getInt() << 32L);
    }

    /**
     * Gets a little-endian special-C <code>long</code> from the buffer.
     */
    public long getLELongC()
    {
        return (long) getIntC() | ((long) getInt() << 32L);
    }

    /**
     * Gets a little-endian special-S <code>long</code> from the buffer.
     */
    public long getLELongS()
    {
        return (long) getIntS() | ((long) getInt() << 32L);
    }

    /**
     * Gets an <code>RSString</code> from the buffer.
     */
    public String getRSString()
    {
        int data;
        StringBuilder builder = new StringBuilder();
        while ((data = get()) != '\n')
            builder.append((char) data);
        return builder.toString();
    }

    /**
     * Puts a <code>byte[]</code> into the buffer.
     *
     * @param buffer
     *            The <code>byte[]</code> to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer put(byte[] buffer)
    {
        for (byte b : buffer)
            put(b);
        return this;
    }

    /**
     * Puts a special-A <code>byte</code> into the buffer.
     *
     * @param i
     *            The special-A <code>byte</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putA(int i)
    {
        return put(i + 128);
    }

    /**
     * Puts a special-C <code>byte</code> into the buffer.
     *
     * @param i
     *            The special-C <code>byte</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putC(int i)
    {
        return put(-i);
    }

    /**
     * Puts a special-S <code>byte</code> into the buffer.
     *
     * @param i
     *            The special-S <code>byte</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putS(int i)
    {
        return put(128 - i);
    }

    /**
     * Puts a <code>short</code> into the buffer.
     *
     * @param i
     *            The <code>short</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putShort(int i)
    {
        return put(i >> 8).put(i);
    }

    /**
     * Puts a special-A <code>short</code> into the buffer.
     *
     * @param i
     *            The special-A <code>short</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putShortA(int i)
    {
        return put(i >> 8).putA(i);
    }

    /**
     * Puts a special-C <code>short</code> into the buffer.
     *
     * @param i
     *            The special-C <code>short</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putShortC(int i)
    {
        return put(i >> 8).putC(i);
    }

    /**
     * Puts a special-S <code>short</code> into the buffer.
     *
     * @param i
     *            The special-S <code>short</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putShortS(int i)
    {
        return put(i >> 8).putS(i);
    }

    /**
     * Puts a little-endian <code>short</code> into the buffer.
     *
     * @param i
     *            The <code>short</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putLEShort(int i)
    {
        return put(i).put(i >> 8);
    }

    /**
     * Puts a little-endian special-A <code>short</code> into the buffer.
     *
     * @param i
     *            The special-A <code>short</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putLEShortA(int i)
    {
        return putA(i).put(i >> 8);
    }

    /**
     * Puts a little-endian special-C <code>short</code> into the buffer.
     *
     * @param i
     *            The special-C <code>short</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putLEShortC(int i)
    {
        return putC(i).put(i >> 8);
    }

    /**
     * Puts a little-endian special-S <code>short</code> into the buffer.
     *
     * @param i
     *            The special-S <code>short</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putLEShortS(int i)
    {
        return putS(i).put(i >> 8);
    }

    /**
     * Puts a <code>tribyte</code> into the buffer.
     *
     * @param i
     *            The <code>tribyte</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putTribyte(int i)
    {
        return put(i >> 16).putShort(i);
    }

    /**
     * Puts a special-A <code>tribyte</code> into the buffer.
     *
     * @param i
     *            The special-A <code>tribyte</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putTribyteA(int i)
    {
        return put(i >> 16).putShortA(i);
    }

    /**
     * Puts a special-C <code>tribyte</code> into the buffer.
     *
     * @param i
     *            The special-C <code>tribyte</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putTribyteC(int i)
    {
        return put(i >> 16).putShortC(i);
    }

    /**
     * Puts a special-S <code>tribyte</code> into the buffer.
     *
     * @param i
     *            The special-S <code>tribyte</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putTribyteS(int i)
    {
        return put(i >> 16).putShortS(i);
    }

    /**
     * Puts a little-endian <code>tribyte</code> into the buffer.
     *
     * @param i
     *            The <code>tribyte</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putLETribyte(int i)
    {
        return putLEShort(i).put(i >> 16);
    }

    /**
     * Puts a little-endian special-A <code>tribyte</code> into the buffer.
     *
     * @param i
     *            The special-A <code>tribyte</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putLETribyteA(int i)
    {
        return putLEShortA(i).put(i >> 16);
    }

    /**
     * Puts a little-endian special-C <code>tribyte</code> into the buffer.
     *
     * @param i
     *            The special-C <code>tribyte</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putLETribyteC(int i)
    {
        return putLEShortC(i).put(i >> 16);
    }

    /**
     * Puts a little-endian special-S <code>tribyte</code> into the buffer.
     *
     * @param i
     *            The special-S <code>tribyte</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putLETribyteS(int i)
    {
        return putLEShortS(i).put(i >> 16);
    }

    /**
     * Puts an <code>int</code> into the buffer.
     *
     * @param i
     *            The <code>int</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putInt(int i)
    {
        return putShort(i >> 16).putShort(i);
    }

    /**
     * Puts an <code>int1</code> into the buffer.
     *
     * @param i
     *            The <code>int1</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putInt1(int i)
    {
        return putShort(i).put(i >> 24).put(i >> 16);
    }

    /**
     * Puts a special-A <code>int1</code> into the buffer.
     *
     * @param i
     *            The special-A <code>int1</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putInt1A(int i)
    {
        return putShortA(i).put(i >> 24).put(i >> 16);
    }

    /**
     * Puts a special-C <code>int1</code> into the buffer.
     *
     * @param i
     *            The special-C <code>int1</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putInt1C(int i)
    {
        return putShortC(i).put(i >> 24).put(i >> 16);
    }

    /**
     * Puts a special-S <code>int1</code> into the buffer.
     *
     * @param i
     *            The special-S <code>int1</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putInt1S(int i)
    {
        return putShortS(i).put(i >> 24).put(i >> 16);
    }

    /**
     * Puts an <code>int2</code> into the buffer.
     *
     * @param i
     *            The <code>int2</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putInt2(int i)
    {
        return put(i >> 16).put(i >> 24).putLEShort(i);
    }

    /**
     * Puts a special-A <code>int2</code> into the buffer.
     *
     * @param i
     *            The special-A <code>int2</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putInt2A(int i)
    {
        return put(i >> 16).put(i >> 24).putLEShortA(i);
    }

    /**
     * Puts a special-C <code>int2</code> into the buffer.
     *
     * @param i
     *            The special-C <code>int2</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putInt2C(int i)
    {
        return put(i >> 16).put(i >> 24).putLEShortC(i);
    }

    /**
     * Puts a special-S <code>int2</code> into the buffer.
     *
     * @param i
     *            The special-S <code>int2</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putInt2S(int i)
    {
        return put(i >> 16).put(i >> 24).putLEShortS(i);
    }

    /**
     * Puts a special-A <code>int</code> into the buffer.
     *
     * @param i
     *            The special-A <code>int</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putIntA(int i)
    {
        return putShortA(i >> 16).putShortA(i);
    }

    /**
     * Puts a special-C <code>int</code> into the buffer.
     *
     * @param i
     *            The special-C <code>int</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putIntC(int i)
    {
        return putShortC(i >> 16).putShortC(i);
    }

    /**
     * Puts a special-S <code>int</code> into the buffer.
     *
     * @param i
     *            The special-S <code>int</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putIntS(int i)
    {
        return putShortS(i >> 16).putShortS(i);
    }

    /**
     * Puts a little-endian <code>int</code> into the buffer.
     *
     * @param i
     *            The <code>int</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putLEInt(int i)
    {
        return putLEShort(i >> 16).putLEShort(i);
    }

    /**
     * Puts a little-endian special-A <code>int</code> into the buffer.
     *
     * @param i
     *            The special-A <code>int</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putLEIntA(int i)
    {
        return putLEShortA(i >> 16).putLEShortA(i);
    }

    /**
     * Puts a little-endian special-C <code>int</code> into the buffer.
     *
     * @param i
     *            The special-C <code>int</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putLEIntC(int i)
    {
        return putLEShortC(i >> 16).putLEShortC(i);
    }

    /**
     * Puts a little-endian special-S <code>int</code> into the buffer.
     *
     * @param i
     *            The special-S <code>int</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putLEIntS(int i)
    {
        return putLEShortS(i >> 16).putLEShortS(i);
    }

    /**
     * Puts a <code>long</code> into the buffer.
     *
     * @param i
     *            The <code>long</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putLong(long i)
    {
        return putInt((int) (i >> 32)).putInt((int) i);
    }

    /**
     * Puts a special-A <code>long</code> into the buffer.
     *
     * @param i
     *            The special-A <code>long</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putLongA(long i)
    {
        return putIntA((int) (i >> 32)).putIntA((int) i);
    }

    /**
     * Puts a special-C <code>long</code> into the buffer.
     *
     * @param i
     *            The special-C <code>long</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putLongC(long i)
    {
        return putIntC((int) (i >> 32)).putIntC((int) i);
    }

    /**
     * Puts a special-S <code>long</code> into the buffer.
     *
     * @param i
     *            The special-S <code>long</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putLongS(long i)
    {
        return putIntS((int) (i >> 32)).putIntS((int) i);
    }

    /**
     * Puts a little-endian <code>long</code> into the buffer.
     *
     * @param i
     *            The <code>long</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putLELong(long i)
    {
        return putLEInt((int) i).putLEInt((int) (i >> 32));
    }

    /**
     * Puts a little-endian special-A <code>long</code> into the buffer.
     *
     * @param i
     *            The special-A <code>long</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putLELongA(long i)
    {
        return putLEIntA((int) i).putLEIntA((int) (i >> 32));
    }

    /**
     * Puts a little-endian special-C <code>long</code> into the buffer.
     *
     * @param i
     *            The special-C <code>long</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putLELongC(long i)
    {
        return putLEIntC((int) i).putLEIntC((int) (i >> 32));
    }

    /**
     * Puts a little-endian special-S <code>long</code> into the buffer.
     *
     * @param i
     *            The special-S <code>long</code> value to put.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putLELongS(long i)
    {
        return putLEIntS((int) i).putLEIntS((int) (i >> 32));
    }

    /**
     * Puts an <code>RSString</code> into the buffer.
     *
     * @param s
     *            The <code>RSString</code> value to write.
     * @return The instance of this class, for chaining.
     */
    public RSBuffer putRSString(String s)
    {
        for (byte b : s.getBytes())
            put(b);
        return put('\n');
    }

    private class ISAACCipher
    {
        private static final int SIZEL = 8;
        private static final int SIZE = 1 << SIZEL;
        private static final int MASK = (SIZE - 1) << 2;
        private int count;
        private int[] rsl;
        private int[] mem;
        private int a;
        private int b;
        private int c;

        /**
         * This constructor creates and initializes an new instance using a
         * user-provided seed.<br>
         * Equivalent to <code>randinit(ctx, TRUE)</code> after putting seed in
         * <code>randctx</code> in the C implementation.
         *
         * @param seed
         *            The seed.
         */
        private ISAACCipher(int[] seed)
        {
            mem = new int[SIZE];
            rsl = new int[SIZE];
            System.arraycopy(seed, 0, rsl, 0, (seed.length <= rsl.length) ? seed.length : rsl.length);
            init(true);
        }

        /**
         * Generate 256 results.<br>
         * This is a small (not fast) implementation.
         */
        private final void isaac()
        {
            int i, x, y;
            b += ++c;
            for (i = 0; i < SIZE; ++i)
            {
                x = mem[i];
                switch (i & 3)
                {
                case 0:
                    a ^= a << 13;
                    break;
                case 1:
                    a ^= a >>> 6;
                    break;
                case 2:
                    a ^= a << 2;
                    break;
                case 3:
                    a ^= a >>> 16;
                    break;
                }
                a += mem[(i + SIZE / 2) & (SIZE - 1)];
                mem[i] = y = mem[((x) & MASK) >> 2] + a + b;
                rsl[i] = b = mem[((y >> SIZEL) & MASK) >> 2] + x;
            }
        }

        /**
         * Initialize or reinitialize this instance.
         *
         * @param flag
         *            If <code>true</code> then use the seed (which the
         *            constructor placed in <code>rsl[]</code>) for
         *            initialization.
         */
        private final void init(boolean flag)
        {
            int i;
            int a, b, c, d, e, f, g, h;
            a = b = c = d = e = f = g = h = 0x9e3779b9;
            for (i = 0; i < 4; ++i)
            {
                a ^= b << 11;
                d += a;
                b += c;
                b ^= c >>> 2;
                e += b;
                c += d;
                c ^= d << 8;
                f += c;
                d += e;
                d ^= e >>> 16;
                g += d;
                e += f;
                e ^= f << 10;
                h += e;
                f += g;
                f ^= g >>> 4;
                a += f;
                g += h;
                g ^= h << 8;
                b += g;
                h += a;
                h ^= a >>> 9;
                c += h;
                a += b;
            }
            for (i = 0; i < SIZE; i += 8)
            {
                if (flag)
                {
                    a += rsl[i];
                    b += rsl[i + 1];
                    c += rsl[i + 2];
                    d += rsl[i + 3];
                    e += rsl[i + 4];
                    f += rsl[i + 5];
                    g += rsl[i + 6];
                    h += rsl[i + 7];
                }
                a ^= b << 11;
                d += a;
                b += c;
                b ^= c >>> 2;
                e += b;
                c += d;
                c ^= d << 8;
                f += c;
                d += e;
                d ^= e >>> 16;
                g += d;
                e += f;
                e ^= f << 10;
                h += e;
                f += g;
                f ^= g >>> 4;
                a += f;
                g += h;
                g ^= h << 8;
                b += g;
                h += a;
                h ^= a >>> 9;
                c += h;
                a += b;
                mem[i] = a;
                mem[i + 1] = b;
                mem[i + 2] = c;
                mem[i + 3] = d;
                mem[i + 4] = e;
                mem[i + 5] = f;
                mem[i + 6] = g;
                mem[i + 7] = h;
            }
            if (flag)
            {
                for (i = 0; i < SIZE; i += 8)
                {
                    a += mem[i];
                    b += mem[i + 1];
                    c += mem[i + 2];
                    d += mem[i + 3];
                    e += mem[i + 4];
                    f += mem[i + 5];
                    g += mem[i + 6];
                    h += mem[i + 7];
                    a ^= b << 11;
                    d += a;
                    b += c;
                    b ^= c >>> 2;
                    e += b;
                    c += d;
                    c ^= d << 8;
                    f += c;
                    d += e;
                    d ^= e >>> 16;
                    g += d;
                    e += f;
                    e ^= f << 10;
                    h += e;
                    f += g;
                    f ^= g >>> 4;
                    a += f;
                    g += h;
                    g ^= h << 8;
                    b += g;
                    h += a;
                    h ^= a >>> 9;
                    c += h;
                    a += b;
                    mem[i] = a;
                    mem[i + 1] = b;
                    mem[i + 2] = c;
                    mem[i + 3] = d;
                    mem[i + 4] = e;
                    mem[i + 5] = f;
                    mem[i + 6] = g;
                    mem[i + 7] = h;
                }
            }
            isaac();
            count = SIZE;
        }

        /**
         * Get a random integer value.
         */
        public final int nextInt()
        {
            if (0 == count--)
            {
                isaac();
                count = SIZE - 1;
            }

            return (rsl[count]);
        }

    }

}