* @return the lease flags
     */
    public int getLeaseFlags() {
        return leaseFlags;
    }

    /**
     * Sets the lease flags for this request
     * @param leaseFlags the lease flags to set
     */
    public void setLeaseFlags(int leaseFlags) {
        this.leaseFlags = leaseFlags;
    }

    @Override
    public int size() {
        // Context header: 16 bytes

     */
    @Override
    public int size() {
        return size8(Smb2Constants.SMB2_HEADER_LENGTH + 4);
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#writeBytesWireFormat(byte[], int)
     */
    @Override
    protected int writeBytesWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;
        SMBUtil.writeInt2(4, dst, dstIndex);

  private static Readable getChunkedReadable(String input, int chunk) {
    Reader reader = getChunkedReader(input, chunk);
    return new Readable() {
      @Override
      public int read(CharBuffer cbuf) throws IOException {
        return reader.read(cbuf);
      }
    };
  }

  private static Reader getChunkedReader(String input, int chunk) {
    return new FilterReader(new StringReader(input)) {

  private static Readable getChunkedReadable(String input, int chunk) {
    Reader reader = getChunkedReader(input, chunk);
    return new Readable() {
      @Override
      public int read(CharBuffer cbuf) throws IOException {
        return reader.read(cbuf);
      }
    };
  }

  private static Reader getChunkedReader(String input, int chunk) {
    return new FilterReader(new StringReader(input)) {

	decrypter io.Reader
	// Start sequence number
	startSeqNum uint32
	// Current part index
	partIndex int
	// Parts information
	parts []ObjectPartInfo

	objectEncryptionKey                []byte
	partDecRelOffset, partEncRelOffset int64
}

func (d *DecryptBlocksReader) buildDecrypter(partID int) error {
	var partIDbin [4]byte
	binary.LittleEndian.PutUint32(partIDbin[:], uint32(partID)) // marshal part ID

    }

    @Override
    protected int writeParameterWordsWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    protected int writeBytesWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    protected int readParameterWordsWireFormat(final byte[] buffer, final int bufferIndex) {

        }

        @ParameterizedTest
        @MethodSource("flagsProvider")
        void verifiesCreateDisposition(int flags, int expected) {
            SmbComNTCreateAndX req = createRequest(flags, 0);
            // Use reflection to read the private field createDisposition
            int actual = (int) getPrivateField(req, "createDisposition");
            assertEquals(expected, actual, "createDisposition should match");
        }

        long overallStart = System.nanoTime();

        for (int t = 0; t < threadCount; t++) {
            final int threadId = t;
            executor.submit(() -> {
                try {
                    startLatch.await();

                    long threadStart = System.nanoTime();
                    for (int i = 0; i < operationsPerThread; i++) {
                        try {

 * DNS resolvable hosts.
 */

public class UniAddress {

    private static final int RESOLVER_WINS = 0;
    private static final int RESOLVER_BCAST = 1;
    private static final int RESOLVER_DNS = 2;
    private static final int RESOLVER_LMHOSTS = 3;

    private static int[] resolveOrder;
    private static InetAddress baddr;

    private static LogStream log = LogStream.getInstance();

        if (fitsInLong(difference)) {
          int expected = (x < y) ? 1 : 0;
          int actual = LongMath.lessThanBranchFree(x, y);
          assertEquals(expected, actual);
        }
      }
    }
  }

  // Throws an ArithmeticException if "the simple implementation" of binomial coefficients overflows
  @GwtIncompatible // TODO
  private long simpleBinomial(int n, int k) {
    long accum = 1;