* <i>might</i> perform better than its longhand equivalent, but should not perform worse.
   *
   * @since 14.0
   */
  <T extends @Nullable Object> HashCode hashObject(
      @ParametricNullness T instance, Funnel<? super T> funnel);

  /**
   * Returns the number of bits (a multiple of 32) that each hash code produced by this hash
   * function has.
   */
  int bits();

     * Returns the number of suggested words.
     * @return The number of words.
     */
    public int getNum() {
        return num;
    }

    /**
     * Returns the total number of hits.
     * @return The total number of hits.
     */
    public long getTotal() {
        return total;
    }

    /**
     * Returns the list of suggested items.
     * @return The list of items.
     */

                  + " output bits; The unaffected bits are "
                  + "as follows: "
                  + ~(same & diff)
                  + ". This was "
                  + "determined after "
                  + count
                  + " trials.");
        }
      }
    }
  }

  /**
   * Test for avalanche. Avalanche means that output bits differ with roughly 1/2 probability on

package pubsub

import (
	"math"
	"math/bits"
)

// Mask allows filtering by a bitset mask.
type Mask uint64

const (
	// MaskAll is the mask for all entries.
	MaskAll Mask = math.MaxUint64
)

// MaskFromMaskable extracts mask from an interface.
func MaskFromMaskable(m Maskable) Mask {
	return Mask(m.Mask())
}

// Contains returns whether *all* flags in other is present in t.
func (t Mask) Contains(other Mask) bool {

  static final byte UNSET = 0;

  /** Number of bits used to store the numbers of hash table bits (max 30). */
  private static final int HASH_TABLE_BITS_MAX_BITS = 5;

  /** Use high bits of metadata for modification count. */
  static final int MODIFICATION_COUNT_INCREMENT = 1 << HASH_TABLE_BITS_MAX_BITS;

  /** Bitmask that selects the low bits of metadata to get hashTableBits. */

        final String index;
        if (hits.length > 0) {
            index = hits[0].getIndex();
        } else {
            index = SuggestConstants.EMPTY_STRING;
        }

        final boolean singleWordQuery = isSingleWordQuery(query);
        final boolean hiraganaQuery = isHiraganaQuery(query);
        for (int i = 0; i < hits.length && words.size() < size; i++) {

        final SearchHit[] hits = searchResponse.getHits().getHits();
        final List<String> words = new ArrayList<>();
        final List<SuggestItem> items = new ArrayList<>();

        final String index;
        if (hits.length > 0) {
            index = hits[0].getIndex();
        } else {
            index = SuggestConstants.EMPTY_STRING;
        }

    /**
     * Number of bytes processed so far mod. 2 power of 64.
     */
    private long count;

    /**
     * 512 bits input buffer = 16 x 32-bit words holds until reaches 512 bits.
     */
    private byte[] buffer = new byte[BLOCK_LENGTH];

    /**
     * 512 bits work buffer = 16 x 32-bit words
     */
    private final int[] X = new int[16];

    // Constructors

            // "c) bits 7 to 1 of the first subsequent octet shall not all be zero."
            if (0 == tagNo) {
                throw new IOException("corrupted stream - invalid high tag number found");
            }

            while ((b & 0x80) != 0) {
                if (tagNo >>> 24 != 0) {
                    throw new IOException("Tag number more than 31 bits");
                }

        value: Int,
        prefixMask: Int,
        bits: Int,
      ) {
        var value = value
        // Write the raw value for a single byte value.
        if (value < prefixMask) {
          out.writeByte(bits or value)
          return
        }

        // Write the mask to start a multibyte value.
        out.writeByte(bits or prefixMask)
        value -= prefixMask