*
     * @param src the source byte array
     * @param si the starting index in the source array
     * @return the decoded long value
     */
    public static long dec_uint64be(final byte[] src, final int si) {
        long l = dec_uint32be(src, si) & 0xFFFFFFFFL;
        l <<= 32L;
        l |= dec_uint32be(src, si + 4) & 0xFFFFFFFFL;
        return l;
    }

    /**

        }

        this.revision = Byte.parseByte(st.nextToken());
        final String tmp = st.nextToken();
        long id = 0;
        if (tmp.startsWith("0x")) {
            id = Long.parseLong(tmp.substring(2), 16);
        } else {
            id = Long.parseLong(tmp);
        }

        this.identifier_authority = new byte[6];
        for (int i = 5; id > 0; i--) {

     * Default timeout for durable handles (2 minutes)
     */
    public static final long DEFAULT_DURABLE_TIMEOUT = 120000;

    /**
     * Maximum timeout for durable handles (5 minutes)
     */
    public static final long MAX_DURABLE_TIMEOUT = 300000;

    /**
     * Persistent handles have infinite timeout
     */
    public static final long PERSISTENT_TIMEOUT = 0;

    /**
     * Private constructor to prevent instantiation

        "type": "keyword"
      },
      "expiredTime": {
        "type": "long"
      },
      "createdBy": {
        "type": "keyword"
      },
      "createdTime": {
        "type": "long"
      },
      "updatedBy": {
        "type": "keyword"
      },
      "updatedTime": {
        "type": "long"
      }
    }

            region.close();
            totalReleased.incrementAndGet();
        }
    }
    
    public long getTotalAllocated() { return totalAllocated.get(); }
    public long getTotalReleased() { return totalReleased.get(); }
    public long getActiveRegions() { return totalAllocated.get() - totalReleased.get(); }
}
```

### 4.5 RDMA Provider Implementations

    /**
     * Default constructor.
     */
    public IntervalControlHelper() {
        // Default constructor
    }

    /** Wait time in milliseconds when crawler is not running */
    protected long crawlerWaitMillis = 10000;

    /** List of interval rules for controlling crawler timing */
    protected List<IntervalRule> ruleList = new ArrayList<>();

    /**

    /**
     * Creates a new witness heartbeat response.
     */
    public WitnessHeartbeatResponse() {
        // Default constructor
    }

    private long sequenceNumber;
    private int returnCode;
    private long recommendedHeartbeatInterval;
    private String error;

    /**
     * Checks if the heartbeat was successful.
     *
     * @return true if successful
     */

   * @param terminationTimeout how long to wait for the executor to finish before terminating the
   *     JVM
   * @param timeUnit unit of time for the time parameter
   */
  @J2ktIncompatible
  @GwtIncompatible // TODO
  @SuppressWarnings("GoodTime") // should accept a java.time.Duration
  public static void addDelayedShutdownHook(
      ExecutorService service, long terminationTimeout, TimeUnit timeUnit) {

 * maximumSize}, {@link #maximumWeight(long) maximumWeight}, {@link #expireAfterWrite
 * expireAfterWrite}, {@link #expireAfterAccess expireAfterAccess}, {@link #weakKeys weakKeys},
 * {@link #weakValues weakValues}, or {@link #softValues softValues} are requested.
 *
 * <p>If {@link #maximumSize(long) maximumSize} or {@link #maximumWeight(long) maximumWeight} is

) : SSLSession {
  override fun getId(): ByteArray = delegate!!.id

  override fun getSessionContext(): SSLSessionContext = delegate!!.sessionContext

  override fun getCreationTime(): Long = delegate!!.creationTime

  override fun getLastAccessedTime(): Long = delegate!!.lastAccessedTime

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

  override fun isValid(): Boolean = delegate!!.isValid

  override fun putValue(