private static BigInteger oldSlowFactorial(int n1, int n2) {
    assert n1 <= n2;
    if (IntMath.log2(n2, CEILING) * (n2 - n1) < Long.SIZE - 1) {
      // the result will definitely fit into a long
      long result = 1;
      for (int i = n1 + 1; i <= n2; i++) {
        result *= i;
      }
      return BigInteger.valueOf(result);
    }

    /*

            return SmbFile.ATTR_READONLY | SmbFile.ATTR_DIRECTORY;
        }

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

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

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

        @Override
        public String toString() {

    /**
     * The archive stream factory.
     */
    @Resource
    protected ArchiveStreamFactory archiveStreamFactory;

    /**
     * The maximum content size.
     */
    protected long maxContentSize = -1;

    /**
     * Creates a new ZipExtractor instance.
     */
    public ZipExtractor() {
        super();
    }

    @Override

    }
  }

  /** A view of a subsection of the containing byte source. */
  private final class SlicedByteSource extends ByteSource {

    final long offset;
    final long length;

    SlicedByteSource(long offset, long length) {
      checkArgument(offset >= 0, "offset (%s) may not be negative", offset);
      checkArgument(length >= 0, "length (%s) may not be negative", length);

  /**
   * @since 15.0 (previously returned ScheduledFuture)
   */
  @Override
  ListenableScheduledFuture<?> scheduleAtFixedRate(
      Runnable command, long initialDelay, long period, TimeUnit unit);

  /**
   * Duration-based overload of {@link #scheduleAtFixedRate(Runnable, long, long, TimeUnit)}.
   *
   * @since 29.0
   */
  @J2ktIncompatible
  default ListenableScheduledFuture<?> scheduleAtFixedRate(

        return this;
    }

    public void setCreatedTime_Equal(Long createdTime) {
        setCreatedTime_Term(createdTime, null);
    }

    public void setCreatedTime_Equal(Long createdTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setCreatedTime_Term(createdTime, opLambda);
    }

    public void setCreatedTime_Term(Long createdTime) {
        setCreatedTime_Term(createdTime, null);
    }

   *     wrap(String.class) == String.class
   * </pre>
   */
  public static <T> Class<T> wrap(Class<T> type) {
    checkNotNull(type);

    // cast is safe: long.class and Long.class are both of type Class<Long>
    @SuppressWarnings("unchecked")
    Class<T> wrapped = (Class<T>) PRIMITIVE_TO_WRAPPER_TYPE.get(type);
    return (wrapped == null) ? type : wrapped;
  }

  /**

    }

  fun throttleBody(
    bytesPerPeriod: Long,
    period: Long,
    unit: TimeUnit,
  ) = apply {
    throttleBytesPerPeriod = bytesPerPeriod
    throttlePeriodAmount = period
    throttlePeriodUnit = unit
  }

  fun getThrottlePeriod(unit: TimeUnit): Long = unit.convert(throttlePeriodAmount, throttlePeriodUnit)

  fun setBodyDelay(
    delay: Long,
    unit: TimeUnit,
  ) = apply {

     * @param remoteKey remote memory key
     * @param length number of bytes to read
     * @throws IOException if read fails
     */
    public abstract void rdmaRead(RdmaMemoryRegion localRegion, long remoteAddress, int remoteKey, int length) throws IOException;

    /**
     * Perform RDMA write operation
     *
     * @param localRegion local memory region to write from

            return 0;
        }

        @Override
        public long createTime() {
            return 0;
        }

        @Override
        public long lastModified() {
            return 0;
        }

        @Override
        public long lastAccess() {
            return 0;
        }

        @Override
        public long length() {
            return 0;
        }

        @Override