//-----------------------------------------------------------------------------
// MurmurHash, by Austin Appleby
// Note - This code makes a few assumptions about how your machine behaves -
// 1. We can read a 4-byte value from any address without crashing
// 2. sizeof(int) == 4
// And it has a few limitations -
// 1. It will not work incrementally.
// 2. It will not produce the same results on little-endian and big-endian
//    machines.
// Changing the seed value will totally change the output of the hash.
// If you don't have a preference, use a seed of 0.
unsigned int MurmurHash ( const void * key, int len, unsigned int seed )
{
    // 'm' and 'r' are mixing constants generated offline.
    // They're not really 'magic', they just happen to work well.
    const unsigned int m = 0xc6a4a793;
    const int r = 16;
    // Initialize the hash to a 'random' value
    unsigned int h = seed ^ (len * m);
    // Mix 4 bytes at a time into the hash
    const unsigned char * data = (const unsigned char *)key;
    while(len >= 4)
    {
        h += *(unsigned int *)data;
        h *= m;
        h ^= h >> r;
        data += 4;
        len -= 4;
    }
    // Handle the last few bytes of the input array
    switch(len)
    {
    case 3:
        h += data[2] << 16;
    case 2:
        h += data[1] << 8;
    case 1:
        h += data[0];
        h *= m;
        h ^= h >> r;
    };
    // Do a few final mixes of the hash to ensure the last few
    // bytes are well-incorporated.
    h *= m;
    h ^= h >> 10;
    h *= m;
    h ^= h >> 17;
    return h;
}

use std::convert::TryInto;
pub struct MurmurHashV1 {}
impl MurmurHashV1 {
    pub fn hash(key: &[u8], seed: u32) -> u32 {
        let m = 0xc6a4a793;
        let r = 16;
        let len = key.len();
        let mut h = seed ^ (len.wrapping_mul(m) as u32);
        let remain = len % 4;
        let mut offset = len;
        if remain > 0 {
            offset = len - remain;
        }
        let data = key[..offset].chunks(4).map(|it| u32::from_le_bytes(it.try_into().unwrap())).collect::<Vec<u32>>();
        for item in data {
            h = h.wrapping_add(item);
            h = h.wrapping_mul(m as u32);
            h ^= h >> r;
        }
        if remain >= 3 {
            h = h.wrapping_add((key[offset + 2] as u32).wrapping_shl(16));
        }
        if remain >= 2 {
            h = h.wrapping_add((key[offset + 1] as u32).wrapping_shl(8));
        }
        if remain >= 1 {
            h = h.wrapping_add(key[offset] as u32);
            h = h.wrapping_mul(m as u32);
            h ^= h >> r;
        }
        h = h.wrapping_mul(m as u32);
        h ^= h >> 10;
        h = h.wrapping_mul(m as u32);
        h ^= h >> 17;
        h
    }
}
#[cfg(test)]
mod tests {
    use crate::MurmurHashV1;
    #[test]
    fn it_works() {
        let result = MurmurHashV1::hash("1234567".as_bytes(), 0);
        println!("hash(1234567) = {}", result);
    }
}

package main
import (
  "encoding/binary"
  "fmt"
)
func murmurhash(key []byte, seed uint32) uint32 {
  m := uint32(0xc6a4a793)
  r := 16
  keyLen := uint32(len(key))
  var h = seed ^ (keyLen * m)
  offset := 0
  e := binary.LittleEndian
  for keyLen >= 4 {
    h += e.Uint32(key[offset : offset+4])
    h *= m
    h ^= h >> r
    offset += 4
    keyLen -= 4
  }
  switch keyLen {
  case 3:
    h += uint32(key[offset+2]) << 16
    fallthrough
  case 2:
    h += uint32(key[offset+1]) << 8
    fallthrough
  case 1:
    h += uint32(key[offset])
    h *= m
    h ^= h >> r
  }
  h *= m
  h ^= h >> 10
  h *= m
  h ^= h >> 17
  return h
}
func main() {
  fmt.Println(murmurhash([]byte("1234567"), 0))
}