override fun writeTo(sink: BufferedSink) {
      try {
        var i = 0
        while (i < contentLength()) {
          sink.write(chunk!!)
          sink.flush()
          Thread.sleep(100)
          i += chunk.size
        }
      } catch (e: IOException) {
        ioe = e
      } catch (e: InterruptedException) {
        throw RuntimeException(e)
      }
    }
  }

	return reply, nil
}

type lockStats struct {
	Total          int
	Writes         int
	Reads          int
	LockQueue      int
	LocksAbandoned int
	LastCleanup    *time.Time
}

func (l *localLocker) stats() lockStats {
	return lockStats{
		Total:       len(l.lockMap),
		Reads:       int(l.readers.Load()),
		Writes:      int(l.writers.Load()),
		LockQueue:   int(l.waitMutex.Load()),

  }

  /**
   * Returns a new, empty builder for {@link ImmutableLongArray} instances, sized to hold up to
   * {@code initialCapacity} values without resizing. The returned builder is not thread-safe.
   *
   * <p><b>Performance note:</b> When feasible, {@code initialCapacity} should be the exact number
   * of values that will be added, if that knowledge is readily available. It is better to guess a

  }

  /**
   * Returns a new, empty builder for {@link ImmutableIntArray} instances, sized to hold up to
   * {@code initialCapacity} values without resizing. The returned builder is not thread-safe.
   *
   * <p><b>Performance note:</b> When feasible, {@code initialCapacity} should be the exact number
   * of values that will be added, if that knowledge is readily available. It is better to guess a

        // start
        AccessTimeoutTarget accessTimeoutTarget = null;
        TimeoutTask accessTimeoutTask = null;
        if (accessTimeout != null) {
            accessTimeoutTarget = new AccessTimeoutTarget(Thread.currentThread());
            accessTimeoutTask = TimeoutManager.getInstance().addTimeoutTarget(accessTimeoutTarget, accessTimeout, false);
        }

        final ExtractData data = new ExtractData();

import (
	"sync"
	"time"
)

// EvictCallback is used to get a callback when a cache entry is evicted
type EvictCallback[K comparable, V any] func(key K, value V)

// LRU implements a thread-safe LRU with expirable entries.
type LRU[K comparable, V any] struct {
	size      int
	evictList *LruList[K, V]
	items     map[K]*Entry[K, V]
	onEvict   EvictCallback[K, V]

	// expirable options
	mu   sync.Mutex

    call: Call,
    delay: Long,
  ): Thread {
    val thread =
      object : Thread("canceler") {
        override fun run() {
          try {
            sleep(delay)
          } catch (e: InterruptedException) {
            throw AssertionError()
          }
          call.cancel()
        }
      }
    thread.start()
    return thread
  }

    checkNotNull(runnable, "Runnable was null.");
    checkNotNull(executor, "Executor was null.");

    // Lock while we check state. We must maintain the lock while adding the new pair so that
    // another thread can't run the list out from under us. We only add to the list if we have not
    // yet started execution.
    synchronized (this) {
      if (!executed) {

    result = 31 * result + defaultValue.hashCode()
    result = 31 * result + (if (typeHint) 1 else 0)
    return result
  }

  override fun toString(): String = "$name [$tagClass/$tag]"

  /** Reads and writes values without knowledge of the enclosing tag, length, or defaults. */
  interface Codec<T> {
    fun decode(reader: DerReader): T

    fun encode(
      writer: DerWriter,
      value: T,
    )

if NOT "%FESS_HEAP_SIZE%" == "" set FESS_MAX_MEM=%FESS_HEAP_SIZE%

call:convertxm %FESS_MIN_MEM% JVM_XMS
call:convertxm %FESS_MAX_MEM% JVM_XMX

CALL "%FESS_HOME%\bin\fess.in.bat"

rem thread stack size
set JVM_SS=256