algorithm Murmur3_32 is
    // Note: In this version, all arithmetic is performed with unsigned 32-bit integers.
    //       In the case of overflow, the result is reduced modulo 232.
    input: key, len, seed
    c1 ← 0xcc9e2d51
    c2 ← 0x1b873593
    r1 ← 15
    r2 ← 13
    m ← 5
    n ← 0xe6546b64
    hash ← seed
    for each fourByteChunk of key do
        k ← fourByteChunk
        k ← k × c1
        k ← k ROL r1
        k ← k × c2
        hash ← hash XOR k
        hash ← hash ROL r2
        hash ← (hash × m) + n
    with any remainingBytesInKey do
        remainingBytes ← SwapToLittleEndian(remainingBytesInKey)
        // Note: Endian swapping is only necessary on big-endian machines.
        //       The purpose is to place the meaningful digits towards the low end of the value,
        //       so that these digits have the greatest potential to affect the low range digits
        //       in the subsequent multiplication.  Consider that locating the meaningful digits
        //       in the high range would produce a greater effect upon the high digits of the
        //       multiplication, and notably, that such high digits are likely to be discarded
        //       by the modulo arithmetic under overflow.  We don't want that.
        remainingBytes ← remainingBytes × c1
        remainingBytes ← remainingBytes ROL r1
        remainingBytes ← remainingBytes × c2
        hash ← hash XOR remainingBytes
    hash ← hash XOR len
    hash ← hash XOR (hash >> 16)
    hash ← hash × 0x85ebca6b
    hash ← hash XOR (hash >> 13)
    hash ← hash × 0xc2b2ae35
    hash ← hash XOR (hash >> 16)

use std::convert::TryInto;
use std::u32;
const C1: u32 = 0xcc9e_2d51;
const C2: u32 = 0x1b87_3593;
const D: u32 = 0xe654_6b64;
const FMIX1: u32 = 0x85eb_ca6b;
const FMIX2: u32 = 0xc2b2_ae35;
fn fmix32(mut h: u32) -> u32 {
    h ^= h >> 16;
    h = h.wrapping_mul(FMIX1);
    h ^= h >> 13;
    h = h.wrapping_mul(FMIX2);
    h ^= h >> 16;
    h
}
pub fn murmurhash3(key: &[u8], seed: u32) -> u32 {
    let mut h = seed;
    let mut chunks = key.chunks_exact(4);
    while let Some(chunk) = chunks.next() {
        let mut k: u32 = u32::from_le_bytes(chunk.try_into().unwrap());
        k = k.wrapping_mul(C1);
        k = k.rotate_left(15);
        k = k.wrapping_mul(C2);
        h ^= k;
        h = h.rotate_left(13);
        h = (h.wrapping_mul(5)).wrapping_add(D);
    }
    let remainder = chunks.remainder();
    match remainder.len() {
        3 => {
            let mut k = u32::from(remainder[2]) << 16;
            k ^= u32::from(remainder[1]) << 8;
            k ^= u32::from(remainder[0]);
            k = k.wrapping_mul(C1);
            k = k.rotate_left(15);
            k = k.wrapping_mul(C2);
            h ^= k;
        }
        2 => {
            let mut k = u32::from(remainder[1]) << 8;
            k ^= u32::from(remainder[0]);
            k = k.wrapping_mul(C1);
            k = k.rotate_left(15);
            k = k.wrapping_mul(C2);
            h ^= k;
        }
        1 => {
            let mut k = u32::from(remainder[0]);
            k = k.wrapping_mul(C1);
            k = k.rotate_left(15);
            k = k.wrapping_mul(C2);
            h ^= k;
        }
        _ => {}
    }
    fmix32(h ^ key.len() as u32)
}

const C1 = 0xcc9e_2d51
const C2 = 0x1b87_3593
const D = 0xe654_6b64
const FMIX1 = 0x85eb_ca6b
const FMIX2 = 0xc2b2_ae35
func fmix32(h uint32) uint32 {
  h ^= h >> 16
  h *= FMIX1
  h ^= h >> 13
  h *= FMIX2
  h ^= h >> 16
  return h
}
func murmurhash3(key []byte, seed uint32) uint32 {
  h := seed
  keyLen := uint32(len(key))
  offset := 0
  e := binary.LittleEndian
  for keyLen >= 4 {
    k := e.Uint32(key[offset : offset+4])
    fmt.Println(k)
    k *= C1
    k = bits.RotateLeft32(k, 15)
    k *= C2
    h ^= k
    h = bits.RotateLeft32(h, 13)
    h *= 5
    h += D
    offset += 4
    keyLen -= 4
  }
  k1 := uint32(0)
  switch keyLen {
  case 3:
    k1 ^= uint32(key[offset+2]) << 16
    fallthrough
  case 2:
    k1 ^= uint32(key[offset+1]) << 8
    fallthrough
  case 1:
    k1 ^= uint32(key[offset])
    k1 *= C1
    k1 = bits.RotateLeft32(k1, 15)
    k1 *= C2
    h ^= k1
  }
  return fmix32(h ^ uint32(len(key)))
}