code: public static HashFunction goodFastHash(int minimumBits) {
      int bits = checkPositiveAndMakeMultipleOf32(minimumBits);
  
      if (bits == 32) {
        return Murmur3_32HashFunction.GOOD_FAST_HASH_32;
      }
      if (bits <= 128) {
        return Murmur3_128HashFunction.GOOD_FAST_HASH_128;
      }
  
      // Otherwise, join together some 128-bit murmur3s
      int hashFunctionsNeeded = (bits + 127) / 128;
      HashFunction[] hashFunctions = new HashFunction[hashFunctionsNeeded];
      hashFunctions[0] = Murmur3_128HashFunction.GOOD_FAST_HASH_128;
      int seed = GOOD_FAST_HASH_SEED;
      for (int i = 1; i < hashFunctionsNeeded; i++) {
        seed += 1500450271; // a prime; shouldn't matter
        hashFunctions[i] = murmur3_128(seed);
      }
      return new ConcatenatedHashFunction(hashFunctions);
    }
docs: Returns a general-purpose, <b>temporary-use</b>, non-cryptographic hash function. The algorithm
  the returned function implements is unspecified and subject to change without notice.
  
  <p><b>Warning:</b> a new random seed for these functions is chosen each time the {@code
  Hashing} class is loaded. <b>Do not use this method</b> if hash codes may escape the current
  process in any way, for example being sent over RPC, or saved to disk. For a general-purpose,
  non-cryptographic hash function that will never change behavior, we suggest {@link
  #murmur3_128}.
  
  <p>Repeated calls to this method on the same loaded {@code Hashing} class, using the same value
  for {@code minimumBits}, will return identically-behaving {@link HashFunction} instances.
  
  @param minimumBits a positive integer (can be arbitrarily large)
  @return a hash function, described above, that produces hash codes of length {@code
  minimumBits} or greater