}
		builder.WriteString("OFFSET ")
		builder.AddVar(builder, limit.Offset)
	}
}

// MergeClause merge order by clauses
func (limit Limit) MergeClause(clause *Clause) {
	clause.Name = ""

	if v, ok := clause.Expression.(Limit); ok {
		if (limit.Limit == nil || *limit.Limit == 0) && v.Limit != nil {
			limit.Limit = v.Limit
		}

		if limit.Offset == 0 && v.Offset > 0 {
			limit.Offset = v.Offset

    }

    /**
     * Gets the offset in the data buffer.
     *
     * @return the offset
     */
    public final int getOffset() {
        return this.offset;
    }

    /**
     * Adjusts the offset by the specified amount.
     *
     * @param n the amount to adjust the offset
     */
    public void adjustOffset(final int n) {
        this.offset += n;
    }

    /**

			"SELECT * FROM `users` LIMIT ?",
			[]interface{}{limit10},
		},
		{
			[]clause.Interface{clause.Select{}, clause.From{}, clause.Limit{Limit: &limit10, Offset: 20}, clause.Limit{Offset: 30}, clause.Limit{Limit: &limitNeg10}},
			"SELECT * FROM `users` OFFSET ?",
			[]interface{}{30},
		},
		{

  }

  private static long hashLength33To64(byte[] bytes, int offset, int length) {
    long z = load64(bytes, offset + 24);
    long a = load64(bytes, offset) + (length + load64(bytes, offset + length - 16)) * K0;
    long b = rotateRight(a + z, 52);
    long c = rotateRight(a, 37);
    a += load64(bytes, offset + 8);
    c += rotateRight(a, 7);
    a += load64(bytes, offset + 16);
    long vf = a + z;

     *
     * @param data the data buffer
     * @param offset the offset in the buffer
     * @param length the length of data to compress
     * @param algorithm the compression algorithm to use
     * @return the compressed data
     * @throws CIFSException if compression fails
     */
    byte[] compress(byte[] data, int offset, int length, int algorithm) throws CIFSException;

  }

  public void testLongsOffset() {
    assertEquals(1, DiscreteDomain.longs().offset(0L, 1).longValue());
    assertEquals(Long.MAX_VALUE, DiscreteDomain.longs().offset(0L, Long.MAX_VALUE).longValue());
  }

  public void testLongsOffsetExceptions() {
    assertThrows(IllegalArgumentException.class, () -> DiscreteDomain.longs().offset(0L, -1));
    assertThrows(

        this.offset = offset;
        this.maxCount = minCount = maxCount;
        command = SMB_COM_READ_ANDX;
        openTimeout = 0xFFFFFFFF;
    }

    void setParam(final int fid, final long offset, final int maxCount) {
        this.fid = fid;
        this.offset = offset;
        this.maxCount = minCount = maxCount;
    }

    @Override
    int getBatchLimit(final byte command) {

     */
    public static final int SMB2_LOCKFLAG_FAIL_IMMEDIATELY = 0x10;

    private final long offset;
    private final long length;
    private final int flags;

    /**
     * Constructs an SMB2 lock element with the specified parameters.
     *
     * @param offset the byte offset in the file where the lock begins
     * @param length the number of bytes to lock

     * @param offset the offset in the buffer where data starts
     * @param len the length of data to digest
     */
    public void update(final byte[] input, final int offset, final int len) {
        if (LogStream.level >= 5) {
            log.println("update: " + updates + " " + offset + ":" + len);
            Hexdump.hexdump(log, input, offset, Math.min(len, 256));
            log.flush();

        this.readLength = readLength;
    }

    /**
     * Sets the file offset from which to start reading
     *
     * @param offset
     *            the offset to set
     */
    public void setOffset(final long offset) {
        this.offset = offset;
    }

    /**
     * Sets the minimum number of bytes that must be read for the operation to succeed
     *