weakHashLength32WithSeeds(bytes, offset + length - 32, length * K1, K0, w);
    z += shiftMix(v[1]) * K1;
    x = rotateRight(z + x, 39) * K1;
    y = rotateRight(y, 33) * K1;

    // Decrease length to the nearest multiple of 64, and operate on 64-byte chunks.
    length = (length - 1) & ~63;
    do {
      x = rotateRight(x + y + v[0] + load64(bytes, offset + 16), 37) * K1;

  long size();

  /**
   * Returns a current snapshot of this cache's cumulative statistics, or a set of default values if
   * the cache is not recording statistics. All statistics begin at zero and never decrease over the
   * lifetime of the cache.
   *
   * <p><b>Warning:</b> this cache may not be recording statistical data. For example, a cache

   *   <li>When you reduce the number of buckets, you can accept that the most recently added
   *       buckets will be removed first. More concretely, if you are dividing traffic among tasks,
   *       you can decrease the number of tasks from 15 and 10, killing off the final 5 tasks, and
   *       {@code consistentHash} will handle it. If, however, you are dividing traffic among

   * provided key-value mapping, this method has no effect.
   *
   * <p>Note that a successful call to this method could cause the size of the bimap to increase by
   * one, stay the same, or even decrease by one.
   *
   * <p><b>Warning:</b> If an existing entry with this value is removed, the key for that entry is
   * discarded and not returned.
   *

 * worst case time complexity of O(N^2). You are extremely unlikely to hit this quadratic case on
 * randomly ordered data (the probability decreases faster than exponentially in N), but if you are
 * passing in unsanitized user data then a malicious user could force it. A light shuffle of the
 * data using an unpredictable seed should normally be enough to thwart this attack.

   * time which we translate to storedPermits. (We increase storedPermits with the amount of permits
   * that would have been produced in that idle time). So, if rate == 1 permit per second, and
   * arrivals come exactly one second after the previous, then storedPermits is _never_ increased --
   * we would only increase it for arrivals _later_ than the expected one second.
   */

  /**

              // we can skip them all.
              knownRunStart += maxRunBeforeFallback;
            } else {
              knownRunStart++; // the only case in which maxRunEnd doesn't increase by mRBF
              // happens about f * (1-f) for f = DESIRED_LOAD_FACTOR, so around 21% of the time
            }
            knownRunEnd = knownRunStart;
          } else {

 *       thoroughly as possible.
 *   <li><b>bit-dispersing:</b> masking out any <i>single bit</i> from a hash code should yield only
 *       the expected <i>twofold</i> increase to all collision rates. Informally, the "information"
 *       in the hash code should be as evenly "spread out" through the hash code's bits as possible.

            // we can skip them all.
            knownRunStart += maxRunBeforeFallback;
          } else {
            knownRunStart++; // the only case in which maxRunEnd doesn't increase by mRBF
            // happens about f * (1-f) for f = DESIRED_LOAD_FACTOR, so around 21% of the time
          }
          knownRunEnd = knownRunStart;
        } else {

    // About the term "aunt node": it's better to leave gender out of it, but for this the English
    // language has nothing for us. Except for the whimsical neologism "pibling" (!) which we
    // obviously could not expect to increase anyone's understanding of the code.

    /**
     * Swap {@code actualLastElement} with the conceptually correct last element of the heap.
     * Returns the index that {@code actualLastElement} now resides in.
     *