// KGS!@#$%
    private static final byte[] S8 = {
        (byte)0x4b, (byte)0x47, (byte)0x53, (byte)0x21,
        (byte)0x40, (byte)0x23, (byte)0x24, (byte)0x25
    };
    /* Accepts key multiple of 7
     * Returns enc multiple of 8
     * Multiple is the same like: 21 byte key gives 24 byte result
     */
    private static void E( byte[] key, byte[] data, byte[] e ) {
        byte[] key7 = new byte[7];

    private byte padding;
    private byte readFlags;
    private int readLength;
    private long offset;
    private int minimumCount;
    private int channel;
    private int remainingBytes;


    /**
     * @param config
     * @param fileId
     * @param outputBuffer
     * @param outputBufferOffset
     */
    public Smb2ReadRequest ( Configuration config, byte[] fileId, byte[] outputBuffer, int outputBufferOffset ) {

  public void testBytes() {
    Sink sink = new Sink(4); // byte order insignificant here
    byte[] expected = {1, 2, 3, 4, 5, 6, 7, 8};
    sink.putByte((byte) 1);
    sink.putBytes(new byte[] {2, 3, 4, 5, 6});
    sink.putByte((byte) 7);
    sink.putBytes(new byte[] {});
    sink.putBytes(new byte[] {8});
    HashCode unused = sink.hash();
    sink.assertInvariants(8);
    sink.assertBytes(expected);

     */
    public void setBuffer ( byte[] buffer ) {
        this.txn_buf = buffer;
    }


    /**
     * @return the txn_buf
     */
    public byte[] releaseBuffer () {
        byte[] buf = this.txn_buf;
        this.txn_buf = null;
        return buf;
    }


    /**
     * @return the subCommand
     */
    public final byte getSubCommand () {
        return this.subCommand;

   *     {@link Byte#MAX_VALUE} if it is too large, or {@link Byte#MIN_VALUE} if it is too small
   */
  public static byte saturatedCast(long value) {
    if (value > Byte.MAX_VALUE) {
      return Byte.MAX_VALUE;
    }
    if (value < Byte.MIN_VALUE) {
      return Byte.MIN_VALUE;
    }
    return (byte) value;
  }

  /**

                raf.write(new byte[] {
                    0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8
                });
                raf.seek(0);
                assertEquals(0, raf.getFilePointer());

                byte[] buf = new byte[4];

                raf.readFully(buf);
                assertArrayEquals(new byte[] {
                    0x1, 0x2, 0x3, 0x4
                }, buf);

  }

  public void testRead_withProcessor() throws IOException {
    final byte[] processedBytes = new byte[bytes.length];
    ByteProcessor<byte[]> processor =
        new ByteProcessor<byte[]>() {
          int pos;

          @Override
          public boolean processBytes(byte[] buf, int off, int len) throws IOException {
            System.arraycopy(buf, off, processedBytes, pos, len);

  private enum HashMethod {
    MESSAGE_DIGEST_API() {
      @Override
      public byte[] hash(Algorithm algorithm, byte[] input) {
        MessageDigest md = algorithm.getMessageDigest();
        md.update(input);
        return md.digest();
      }
    },
    HASH_FUNCTION_DIRECT() {
      @Override
      public byte[] hash(Algorithm algorithm, byte[] input) {
        return algorithm.getHashFunction().hashBytes(input).asBytes();
      }

  private enum HashMethod {
    MESSAGE_DIGEST_API() {
      @Override
      public byte[] hash(Algorithm algorithm, byte[] input) {
        MessageDigest md = algorithm.getMessageDigest();
        md.update(input);
        return md.digest();
      }
    },
    HASH_FUNCTION_DIRECT() {
      @Override
      public byte[] hash(Algorithm algorithm, byte[] input) {
        return algorithm.getHashFunction().hashBytes(input).asBytes();
      }

    byte b4 = readAndCheckByte();
    byte b5 = readAndCheckByte();
    byte b6 = readAndCheckByte();
    byte b7 = readAndCheckByte();
    byte b8 = readAndCheckByte();

    return Longs.fromBytes(b8, b7, b6, b5, b4, b3, b2, b1);
  }

  /**
   * Reads a {@code float} as specified by {@link DataInputStream#readFloat()}, except using
   * little-endian byte order.
   *