},
          "queryTime" : {
            "type" : "long"
          },
          "referer" : {
            "type" : "keyword"
          },
          "requestedAt" : {
            "type" : "date",
            "format" : "date_optional_time"
          },
          "responseTime" : {
            "type" : "long"
          },
          "roles" : {
            "type" : "keyword"
          },

  private inner class FixedLengthSource(private var bytesRemaining: Long) :
    AbstractSource() {
    init {
      if (bytesRemaining == 0L) {
        responseBodyComplete()
      }
    }

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

    return SECONDS.toMicros(1L) / stableIntervalMicros;
  }

  @Override
  final long queryEarliestAvailable(long nowMicros) {
    return nextFreeTicketMicros;
  }

  @Override
  final long reserveEarliestAvailable(int requiredPermits, long nowMicros) {
    resync(nowMicros);
    long returnValue = nextFreeTicketMicros;
    double storedPermitsToSpend = min(requiredPermits, this.storedPermits);

    /**
     * @return the lastWriteTime
     */
    @Override
    public final long getLastWriteTime () {
        return this.lastWriteTime;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.SmbBasicFileInfo#getCreateTime()
     */
    @Override
    public long getCreateTime () {
        return 0;
    }


    /**
     * {@inheritDoc}
     *

        return 0;
    }


    @Override
    public long getCreateTime () {
        return 0L;
    }


    @Override
    public long getLastWriteTime () {
        return 0L;
    }


    @Override
    public long getLastAccessTime () {
        return 0L;
    }


    @Override
    public long getSize () {
        return this.endOfFile;
    }


    /**

    private static final Logger logger = LogManager.getLogger(WebFsIndexHelper.class);

    private static final String DISABLE_URL_ENCODE = "#DISABLE_URL_ENCODE";

    protected long maxAccessCount = Long.MAX_VALUE;

    protected long crawlingExecutionInterval = Constants.DEFAULT_CRAWLING_EXECUTION_INTERVAL;

    protected int indexUpdaterPriority = Thread.MAX_PRIORITY;

    protected int crawlerPriority = Thread.NORM_PRIORITY;

    return delegate!!.id
  }

  override fun getSessionContext(): SSLSessionContext {
    return delegate!!.sessionContext
  }

  override fun getCreationTime(): Long {
    return delegate!!.creationTime
  }

  override fun getLastAccessedTime(): Long {
    return delegate!!.lastAccessedTime
  }

  override fun invalidate() {
    delegate!!.invalidate()
  }

  override fun isValid(): Boolean {

        return 8;
    }


    public static long dec_uint64be ( byte[] src, int si ) {
        long l;
        l = dec_uint32be(src, si) & 0xFFFFFFFFL;
        l <<= 32L;
        l |= dec_uint32be(src, si + 4) & 0xFFFFFFFFL;
        return l;
    }


    public static long dec_uint64le ( byte[] src, int si ) {
        long l;
        l = dec_uint32le(src, si + 4) & 0xFFFFFFFFL;

          },
          "configParameter" : {
            "type" : "keyword"
          },
          "createdBy" : {
            "type" : "keyword"
          },
          "createdTime" : {
            "type" : "long"
          },
          "depth" : {
            "type" : "integer"
          },
          "description" : {
            "type" : "text"
          },
          "excludedDocPaths" : {

 */
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++) {