@SuppressWarnings("fallthrough")
    public static int hash(byte[] k, int initval) {
        int a, b, c, len;
        int offset = 0;
        int[] abcBuffer;

        /* Set up the internal state */
        len = k.length;
        a = b = 0x9e3779b9; /* the golden ratio; an arbitrary value */
        c = initval; /* the previous hash value */

        // handle most of the key
        while (len >= 12) {
            a += (unsign(k[offset + 0]) + (unsign(k[offset + 1]) << 8)
                    + (unsign(k[offset + 2]) << 16)
                    + (unsign(k[offset + 3]) << 24));
            b += (unsign(k[offset + 4]) + (unsign(k[offset + 5]) << 8)
                    + (unsign(k[offset + 6]) << 16)
                    + (unsign(k[offset + 7]) << 24));
            c += (unsign(k[offset + 8]) + (unsign(k[offset + 9]) << 8)
                    + (unsign(k[offset + 10]) << 16)
                    + (unsign(k[offset + 11]) << 24));
            abcBuffer = mix(a, b, c);
            a = abcBuffer[0];
            b = abcBuffer[1];
            c = abcBuffer[2];
            offset += 12;
            len -= 12;
        }

        // handle the last 11 bytes
        c += k.length;
        switch (len) {
            // all the case statements fall through
            case 11:
                c += (unsign(k[offset + 10]) << 24);

            case 10:
                c += (unsign(k[offset + 9]) << 16);

            case 9:
                c += (unsign(k[offset + 8]) << 8);

                /* the first byte of c is reserved for the length */
            case 8:
                b += (unsign(k[offset + 7]) << 24);

            case 7:
                b += (unsign(k[offset + 6]) << 16);

            case 6:
                b += (unsign(k[offset + 5]) << 8);

            case 5:
                b += unsign(k[offset + 4]);

            case 4:
                a += (unsign(k[offset + 3]) << 24);

            case 3:
                a += (unsign(k[offset + 2]) << 16);

            case 2:
                a += (unsign(k[offset + 1]) << 8);

            case 1:
                a += unsign(k[offset + 0]);

                /* case 0: nothing left to add */
        }
        abcBuffer = mix(a, b, c);
        return abcBuffer[2];
    }
The hash function

<p>
hash() -- hash a variable-length key into a 32-bit value<br>
k       : the key (the unaligned variable-length array of bytes)<br>
len     : the length of the key, counting by bytes<br>
initval : can be any 4-byte value

<p>
Returns a 32-bit value.  Every bit of the key affects every bit of
the return value.  Every 1-bit and 2-bit delta achieves avalanche.
About 6*len+35 instructions.

<p>
The best hash table sizes are powers of 2.  There is no need to do
mod a prime (mod is sooo slow!).  If you need less than 32 bits,
use a bitmask.  For example, if you need only 10 bits, do
h = (h &amp; hashmask(10));
In which case, the hash table should have hashsize(10) elements.

If you are hashing n strings (ub1 **)k, do it like this:
 for (i=0, h=0; i&lt;n; ++i) h = hash( k[i], len[i], h);

<p>
By Bob Jenkins, 1996.  bob_jenkins@burtleburtle.net.  You may use this
code any way you wish, private, educational, or commercial.  It's free.

<p>
See http://burtleburtle.net/bob/hash/evahash.html
Use for hash table lookup, or anything where one collision in 2^^32 is
acceptable.  Do NOT use for cryptographic purposes.

@param k the key
@param initval the previous hash, or an arbitrary value
@return A 32 bit hash value
vespajlib/src/main/java/com/yahoo/collections/BobHash.java