+ Long.numberOfLeadingZeros(~a)
            + Long.numberOfLeadingZeros(b)
            + Long.numberOfLeadingZeros(~b);
    if (leadingZeros > Long.SIZE + 1) {
      return a * b;
    }
    // the return value if we will overflow (which we calculate by overflowing a long :) )
    long limit = Long.MAX_VALUE + ((a ^ b) >>> (Long.SIZE - 1));
    if (leadingZeros < Long.SIZE | (a < 0 & b == Long.MIN_VALUE)) {

      buf[((x1 << 16) + (x2 << 8) + x3) % bufLen] ^= i % 256;
    }
    assertEquals(0x7a1d67c50ec7e167L, h);
  }

  private static long remix(long h) {
    h ^= h >>> 41;
    h *= 949921979;
    return h;
  }

  private static byte getChar(long h) {
    return (byte) ('a' + ((h & 0xfffff) % 26));
  }

import jcifs.internal.util.SMBUtil;
import jcifs.util.Hexdump;


/**
 * 
 */
public class FileBasicInfo implements BasicFileInformation {

    private long createTime;
    private long lastAccessTime;
    private long lastWriteTime;
    private long changeTime;
    private int attributes;


    /**
     * 
     */
    public FileBasicInfo () {}


    /**
     * @param create

      Runnable command, long initialDelay, long period, TimeUnit unit) {
    return delegate.scheduleAtFixedRate(wrapTask(command), initialDelay, period, unit);
  }

  @Override
  public final ScheduledFuture<?> scheduleWithFixedDelay(
      Runnable command, long initialDelay, long delay, TimeUnit unit) {
    return delegate.scheduleWithFixedDelay(wrapTask(command), initialDelay, delay, unit);
  }

    /** createdTime */
    protected Long createdTime;

    /** permissions */
    protected String[] permissions;

    /** reading */
    protected String reading;

    /** suggestWord */
    protected String suggestWord;

    /** updatedBy */
    protected String updatedBy;

    /** updatedTime */
    protected Long updatedTime;

    // [Referrers] *comment only

        runTest(number, count)
      }
      updateReports()
    } finally {
      client.dispatcher.executorService.shutdown()
    }
  }

  private fun runTest(
    number: Long,
    count: Long,
  ) {
    val latch = CountDownLatch(1)
    val startNanos = AtomicLong()
    newWebSocket(
      "/runCase?case=$number&agent=okhttp",
      object : WebSocketListener() {
        override fun onOpen(

        remaining,
        dataLength,
        dataOffset,
        off;
    private byte[] b;
    private long offset;

private int pad;

    int writeMode;

    SmbComWriteAndX() {
        super( null );
        command = SMB_COM_WRITE_ANDX;
    }
    SmbComWriteAndX( int fid, long offset, int remaining,
                    byte[] b, int off, int len, ServerMessageBlock andx ) {
        super( andx );

        if (valueSeparator.length() > 0) {
            final String[] values = rolesStr.split(valueSeparator);
            if (maxAge > 0) {
                try {
                    final long time = getCurrentTime() / 1000 - Long.parseLong(values[0]);
                    if (time > maxAge || time < 0) {
                        if (logger.isDebugEnabled()) {

  private long count;
  private long mark = -1;

  /**
   * Wraps another input stream, counting the number of bytes read.
   *
   * @param in the input stream to be wrapped
   */
  public CountingInputStream(InputStream in) {
    super(checkNotNull(in));
  }

  /** Returns the number of bytes read. */
  public long getCount() {
    return count;
  }

  @Override

    }
    return striped;
  }

  @Benchmark
  long timeConstruct(long reps) {
    long rvalue = 0;
    int numStripesLocal = numStripes;
    Impl implLocal = impl;
    for (long i = 0; i < reps; i++) {
      rvalue += implLocal.get(numStripesLocal).hashCode();
    }
    return rvalue;
  }

  @Benchmark
  long timeGetAt(long reps) {
    long rvalue = 0;
    int[] stripesLocal = stripes;