int exponent = getExponent(d);
    long bits = doubleToRawLongBits(d);
    bits &= SIGNIFICAND_MASK;
    return (exponent == MIN_EXPONENT - 1) ? bits << 1 : bits | IMPLICIT_BIT;
  }

  static boolean isFinite(double d) {
    return getExponent(d) <= MAX_EXPONENT;
  }

  static boolean isNormal(double d) {
    return getExponent(d) >= MIN_EXPONENT;
  }

  /*

@Experimental
public interface Project {

    /**
     * {@return the project groupId}.
     */
    @Nonnull
    String getGroupId();

    /**
     * {@return the project artifactId}.
     */
    @Nonnull
    String getArtifactId();

    /**
     * {@return the project version}.
     */
    @Nonnull
    String getVersion();

    /**
     * {@return the project packaging}.
     * <p>

     *
     * @param value the string value to quote
     * @return the quoted string if it contains spaces, otherwise the original value
     */
    protected String quote(final String value) {
        if (value.split("\\s").length > 1) {
            return new StringBuilder().append('"').append(value.replace('"', ' ')).append('"').toString();
        }
        return value;
    }

    /**

    return delegate().put(key, value);
  }

  @Override
  public void putAll(Map<? extends K, ? extends V> map) {
    delegate().putAll(map);
  }

  @Override
  public Set<K> keySet() {
    return delegate().keySet();
  }

  @Override
  public Collection<V> values() {
    return delegate().values();
  }

  @Override
  public Set<Entry<K, V>> entrySet() {

      return sortedBackingMap().comparator();
    }

    @Override
    public R firstKey() {
      return sortedBackingMap().firstKey();
    }

    @Override
    public R lastKey() {
      return sortedBackingMap().lastKey();
    }

    @Override
    public SortedMap<R, Map<C, V>> headMap(R toKey) {
      checkNotNull(toKey);

		if tmpMaxWait > 0 {
			if tmpMaxWait < waitTick {
				time.Sleep(tmpMaxWait)
				return
			}
			time.Sleep(waitTick)
			tmpMaxWait -= waitTick
		}
		if tmpMaxWait <= 0 {
			return
		}
	}
}

func currentHTTPIO() int {
	httpServer := newHTTPServerFn()
	if httpServer == nil {
		return 0
	}

	return httpServer.GetRequestCount() - activeListeners()
}

func waitForLowHTTPReq() {

     *
     * @return The default current page number.
     */
    protected int getDefaultCurrentPageNumber() {
        return DEFAULT_CURRENT_PAGE_NUMBER;
    }

    /**
     * Returns the total number of records.
     *
     * @return The total number of records.
     */
    public int getAllRecordCount() {
        return allRecordCount;
    }

    /**

	if time.Since(time.UnixMilli(t.lastUpdateMs.Load())) < ttl {
		// There is a new value, release lock and return it.
		if v = t.val.Load(); v != nil {
			return *v, nil
		}
	}

	if err := t.update(ctx); err != nil {
		var empty T
		return empty, err
	}

	return *t.val.Load(), nil
}

// Get will return a cached value or fetch a new one.

		return ctx
	}
	return srv
}

// UseCustomLogger use customized logger for this HTTP *Server
func (srv *Server) UseCustomLogger(l *log.Logger) *Server {
	srv.ErrorLog = l
	return srv
}

// UseTCPOptions use custom TCP options on raw socket
func (srv *Server) UseTCPOptions(opts TCPOptions) *Server {
	srv.TCPOptions = opts
	return srv
}

        @Nullable
        public Path getPath() {
            return path;
        }

        @Override
        @Nonnull
        public InputStream openStream() throws IOException {
            return Files.newInputStream(path);
        }

        @Override
        @Nonnull
        public String getLocation() {
            return location;
        }

        @Override
        @Nullable