// Check offset overflow. Must fit in int32.
	MOVQ 2147483647+1(AX), AX       // ERROR "offset too large"
	MOVQ 3395469782(R10), R8        // ERROR "offset too large"
	LEAQ 3395469782(AX), AX         // ERROR "offset too large"
	ADDQ 3395469782(AX), AX         // ERROR "offset too large"
	ADDL 3395469782(AX), AX         // ERROR "offset too large"

     * @param fid the file identifier
     * @param offset the file offset at which to write
     * @param remaining the number of bytes remaining to be written
     * @param b the data buffer containing bytes to write
     * @param off the offset in the buffer where data starts
     * @param len the number of bytes to write
     */

        final int offset = readULong(src, index + 4);
        final byte[] buffer = new byte[length];
        System.arraycopy(src, offset, buffer, 0, length);
        return buffer;
    }

    static void writeULong(final byte[] dest, final int offset, final int ulong) {
        dest[offset] = (byte) (ulong & 0xff);
        dest[offset + 1] = (byte) (ulong >> 8 & 0xff);

        return this;
    }

    /**
     * Gets the fragment offset.
     *
     * @return the fragment offset value
     */
    public int getFragmentOffset() {
        return fragmentOffset;
    }

    /**
     * Sets the fragment offset with fluent interface.
     *
     * @param fragmentOffset the fragment offset value
     * @return this HighlightInfo instance for method chaining
     */

	for _, block := range enBlocks[:dataBlocks] {
		// Skip blocks until we have reached our offset.
		if offset >= int64(len(block)) {
			// Decrement offset.
			offset -= int64(len(block))
			continue
		}

		// Skip until offset.
		block = block[offset:]

		// Reset the offset for next iteration to read everything
		// from subsequent blocks.
		offset = 0

		// We have written all the blocks, write the last remaining block.

  private final class SlicedByteSource extends ByteSource {

    final long offset;
    final long length;

    SlicedByteSource(long offset, long length) {
      checkArgument(offset >= 0, "offset (%s) may not be negative", offset);
      checkArgument(length >= 0, "length (%s) may not be negative", length);
      this.offset = offset;
      this.length = length;
    }

    @Override

        int offset = 0;
        if (domainLength > 0) {
            writeUShort(targetInfo, offset, 2);
            offset += 2;
            writeUShort(targetInfo, offset, domainLength);
            offset += 2;
            System.arraycopy(domain, 0, targetInfo, offset, domainLength);
            offset += domainLength;
        }
        if (serverLength > 0) {

        byte[] buffer = new byte[512];
        int offset = 0;

        // Write setup
        offset += trans2QueryFSInfo.writeSetupWireFormat(buffer, offset);
        assertEquals(2, offset);

        // Write parameters
        offset += trans2QueryFSInfo.writeParametersWireFormat(buffer, offset);
        assertEquals(4, offset);

        // Write data
        offset += trans2QueryFSInfo.writeDataWireFormat(buffer, offset);

    return ImmutableList.of(element);
  }

  @Override
  boolean isPartialView() {
    return false;
  }

  @Override
  int copyIntoArray(@Nullable Object[] dst, int offset) {
    dst[offset] = element;
    return offset + 1;
  }

  @Override
  public final int hashCode() {
    return element.hashCode();
  }

  @Override
  public String toString() {
    return '[' + element.toString() + ']';

    private int fid, count, offset, remaining, off;
    private byte[] b;

    SmbComWrite() {
        command = SMB_COM_WRITE;
    }

    SmbComWrite(final int fid, final int offset, final int remaining, final byte[] b, final int off, final int len) {
        this.fid = fid;
        this.count = len;
        this.offset = offset;
        this.remaining = remaining;
        this.b = b;