return 16; // 8 + 4 + 4
    }

    /**
     * Encode this structure to byte array
     *
     * @param dst destination buffer
     * @param dstIndex starting index
     * @return number of bytes written
     */
    public int encode(byte[] dst, int dstIndex) {
        SMBUtil.writeInt8(offset, dst, dstIndex);
        SMBUtil.writeInt4(token, dst, dstIndex + 8);
        SMBUtil.writeInt4(length, dst, dstIndex + 12);

 *      writes to and reads from an existing pipe descriptor in one operation.
 * <li> <code>CreateFile</code>, <code>ReadFile</code>,
 *      <code>WriteFile</code>, and <code>CloseFile</code> A byte-type pipe can
 *      be opened, written to, read from and closed using the standard Win32
 *      file operations.
 * </ul>
 *
 * <p>The jCIFS API maps all of these operations into the standard Java

        // Prepare buffer
        byte[] buffer = new byte[100];
        int startIndex = 10;

        // Encode
        int bytesWritten = info.encode(buffer, startIndex);

        // Verify bytes written (encode returns 40, which includes 4 padding bytes)
        assertEquals(40, bytesWritten);

        // Create a new FileBasicInfo and decode to verify encoding
        FileBasicInfo decoded = new FileBasicInfo();

    void testWriteHeaderWireFormat() {
        packet.type = SessionServicePacket.SESSION_REQUEST;
        packet.length = 0x1234;

        byte[] dst = new byte[10];
        int written = packet.writeHeaderWireFormat(dst, 0);

        assertEquals(4, written);
        assertEquals((byte) SessionServicePacket.SESSION_REQUEST, dst[0]);
        assertEquals((byte) 0x00, dst[1]); // No extended bit
        assertEquals((byte) 0x12, dst[2]);

   * fact the static type of {@link Throwable} is occasionally justified even for a method with no
   * {@code throws} clause: Some such methods can in fact throw a checked exception (e.g., by
   * calling code written in Kotlin).) Typically, we want to let a {@link Throwable} from such a
   * method propagate untouched, just as we'd typically let it do for a non-reflective call.

        bb.putInt(data1); // data1 (4 bytes, little-endian)
        bb.putShort(data2); // data2 (2 bytes, little-endian)
        bb.putShort(data3); // data3 (2 bytes, little-endian)

        // Last 8 bytes (data4) written directly as big-endian bytes
        // Extract individual bytes from leastSig and write them directly
        for (int i = 0; i < 8; i++) {
            result[8 + i] = (byte) (leastSig >>> (56 - i * 8));
        }

   * http://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp, which contained the
   * following header:
   *
   * MurmurHash3 was written by Austin Appleby, and is placed in the public domain. The author
   * hereby disclaims copyright to this source code.
   */
  static int smear(int hashCode) {

     * @param outputBuffer the output buffer for decompressed data
     * @param outputOffset the offset in the output buffer
     * @param algorithm the compression algorithm that was used
     * @return the number of bytes written to the output buffer
     * @throws CIFSException if decompression fails
     */
    int decompress(byte[] compressedData, int offset, int length, byte[] outputBuffer, int outputOffset, int algorithm)

     * Writes the packet to the specified byte array in wire format.
     *
     * @param dst the destination byte array to write to
     * @param dstIndex the starting index in the destination array
     * @return written bytes
     */
    public int writeWireFormat(final byte[] dst, final int dstIndex) {
        this.length = writeTrailerWireFormat(dst, dstIndex + HEADER_LENGTH);
        writeHeaderWireFormat(dst, dstIndex);

  @Override
  public void writeChar(int v) throws IOException {
    writeShort(v);
  }

  /**
   * Writes a {@code String} as specified by {@link DataOutputStream#writeChars(String)}, except
   * each character is written using little-endian byte order.
   *
   * @throws IOException if an I/O error occurs
   */
  @Override
  public void writeChars(String s) throws IOException {
    for (int i = 0; i < s.length(); i++) {