"sortOrder": {
        "type": "integer"
      },
      "createdBy": {
        "type": "keyword"
      },
      "createdTime": {
        "type": "long"
      },
      "updatedBy": {
        "type": "keyword"
      },
      "updatedTime": {
        "type": "long"
      },
      "description" : {
        "type": "text",
        "analyzer": "standard_analyzer"
      }
    }

   *
   * TODO: make this inline once this is fixed: https://github.com/oracle/graal/issues/3466
   */
  fun schedule(
    name: String,
    delayNanos: Long = 0L,
    block: () -> Long,
  ) {
    schedule(
      object : Task(name) {
        override fun runOnce(): Long {
          return block()
        }
      },
      delayNanos,
    )
  }

  /**
   * Executes [block] once on a task runner thread.

      "sortOrder": {
        "type": "integer"
      },
      "createdBy": {
        "type": "keyword"
      },
      "createdTime": {
        "type": "long"
      },
      "updatedBy": {
        "type": "keyword"
      },
      "updatedTime": {
        "type": "long"
      },
      "description" : {
        "type": "text",
        "analyzer": "standard_analyzer"
      }
    }

   * > GeneralizedTime.
   */
  internal val time: DerAdapter<Long> =
    object : DerAdapter<Long> {
      override fun matches(header: DerHeader): Boolean {
        return Adapters.UTC_TIME.matches(header) || Adapters.GENERALIZED_TIME.matches(header)
      }

      override fun fromDer(reader: DerReader): Long {
        val peekHeader =
          reader.peekHeader()

   * Returns a nonempty contiguous set containing all {@code long} values from {@code lower}
   * (inclusive) to {@code upper} (inclusive). (These are the same values contained in {@code
   * Range.closed(lower, upper)}.)
   *
   * @throws IllegalArgumentException if {@code lower} is greater than {@code upper}
   * @since 23.0
   */
  public static ContiguousSet<Long> closed(long lower, long upper) {

/**
 * @param <ENTITY> The type of entity.
 * @author ESFlute (using FreeGen)
 */
public class EsPagingResultBean<ENTITY> extends PagingResultBean<ENTITY> {

    private static final long serialVersionUID = 1L;

    protected long took;
    private int totalShards;
    private int successfulShards;
    private int failedShards;
    private TotalHits totalHits;
    private Aggregations aggregations;

    int approxSize = IntMath.divide(n * IntMath.log2(n, CEILING), Long.SIZE, CEILING);
    ArrayList<BigInteger> bignums = new ArrayList<>(approxSize);

    // Start from the pre-computed maximum long factorial.
    int startingNumber = LongMath.factorials.length;
    long product = LongMath.factorials[startingNumber - 1];
    // Strip off 2s from this value.
    int shift = Long.numberOfTrailingZeros(product);
    product >>= shift;

      // attributes are declared in the cookie string.
      if (deltaSeconds == Long.MIN_VALUE) {
        expiresAt = Long.MIN_VALUE
      } else if (deltaSeconds != -1L) {
        val deltaMilliseconds =
          if (deltaSeconds <= Long.MAX_VALUE / 1000) {
            deltaSeconds * 1000
          } else {
            Long.MAX_VALUE
          }
        expiresAt = currentTimeMillis + deltaMilliseconds

import jcifs.internal.SMBProtocolDecodingException;
import jcifs.internal.util.SMBUtil;


/**
 *
 */
public class FileFsSizeInformation implements AllocInfo {

    private long alloc; // Also handles SmbQueryFSSizeInfo
    private long free;
    private int sectPerAlloc;
    private int bytesPerSect;


    /**
     * {@inheritDoc}
     *

  }

  private void setSuccessor(int entry, int succ) {
    long succMask = (~0L) >>> 32;
    setLink(entry, (link(entry) & ~succMask) | ((succ + 1) & succMask));
  }

  private void setPredecessor(int entry, int pred) {
    long predMask = ~0L << 32;
    setLink(entry, (link(entry) & ~predMask) | ((long) (pred + 1) << 32));
  }

  private void setSucceeds(int pred, int succ) {