protected final String index;

    /** The time taken in milliseconds. */
    protected final long tookMs;

    /** The list of suggested words. */
    protected final List<String> words;

    /** The number of suggested words. */
    protected final int num;

    /** The total number of hits. */
    protected final long total;

    /** The list of suggested items. */
    protected final List<SuggestItem> items;

    if (x <= 0) {
      throw new IllegalArgumentException(role + " (" + x + ") must be > 0");
    }
    return x;
  }

  @CanIgnoreReturnValue
  static long checkPositive(String role, long x) {
    if (x <= 0) {
      throw new IllegalArgumentException(role + " (" + x + ") must be > 0");
    }
    return x;
  }

  @CanIgnoreReturnValue

            SMBUtil.writeInt8(Long.MAX_VALUE, buffer, 8); // Max times
            SMBUtil.writeInt8(Long.MAX_VALUE, buffer, 16);
            SMBUtil.writeInt8(Long.MAX_VALUE, buffer, 24);
            SMBUtil.writeInt8(Long.MAX_VALUE, buffer, 32);
            SMBUtil.writeInt8(Long.MAX_VALUE, buffer, 40); // Max allocation size
            SMBUtil.writeInt8(Long.MAX_VALUE, buffer, 48); // Max end of file

  public static SpecialRandom valueOf(String s) {
    return (s.length() == 0) ? new SpecialRandom() : new SpecialRandom(Long.parseLong(s));
  }

  private final boolean hasSeed;
  private final long seed;

  public SpecialRandom() {
    this.hasSeed = false;
    this.seed = 0;
  }

  public SpecialRandom(long seed) {
    super(seed);
    this.hasSeed = true;
    this.seed = seed;
  }

  @Override

  private inner class FixedLengthSource(
    url: HttpUrl,
    private var bytesRemaining: Long,
  ) : AbstractSource(url) {
    init {
      if (bytesRemaining == 0L) {
        responseBodyComplete(trailers = Headers.EMPTY)
      }
    }

    override fun read(
      sink: Buffer,
      byteCount: Long,
    ): Long {
      require(byteCount >= 0L) { "byteCount < 0: $byteCount" }
      check(!closed) { "closed" }

    private byte oplockLevel;
    private byte openFlags;
    private int createAction;
    private long creationTime;
    private long lastAccessTime;
    private long lastWriteTime;
    private long changeTime;
    private long allocationSize;
    private long endOfFile;
    private int fileAttributes;
    private final byte[] fileId = new byte[16];
    private CreateContextResponse[] createContexts;

  public void putLast(E e) throws InterruptedException {
    delegate().putLast(e);
  }

  @Override
  public boolean offerFirst(E e, long timeout, TimeUnit unit) throws InterruptedException {
    return delegate().offerFirst(e, timeout, unit);
  }

  @Override
  public boolean offerLast(E e, long timeout, TimeUnit unit) throws InterruptedException {
    return delegate().offerLast(e, timeout, unit);
  }

  @Override

    /**
     * Returns the creation time of the access result.
     *
     * @return the creation time
     */
    Long getCreateTime();

    /**
     * Sets the creation time of the access result.
     *
     * @param createTime the creation time
     */
    void setCreateTime(Long createTime);

    /**
     * Returns the execution time of the access.
     *
     * @return the execution time

@NullUnmarked
public class StopwatchBenchmark {
  @Benchmark
  long stopwatch(int reps) {
    long total = 0;
    for (int i = 0; i < reps; i++) {
      Stopwatch s = Stopwatch.createStarted();
      // here is where you would do something
      total += s.elapsed(NANOSECONDS);
    }
    return total;
  }

  @Benchmark
  long manual(int reps) {
    long total = 0;
    for (int i = 0; i < reps; i++) {

      T target, Class<T> interfaceType, long timeoutDuration, TimeUnit timeoutUnit) {
    checkNotNull(target);
    checkNotNull(interfaceType);
    checkNotNull(timeoutUnit);
    return target; // ha ha
  }

  @CanIgnoreReturnValue // TODO(kak): consider removing this
  @Override
  @ParametricNullness
  public <T extends @Nullable Object> T callWithTimeout(