diff --git a/debian/changelog b/debian/changelog
index fcedae5..d661567 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,9 @@
+golang-github-spaolacci-murmur3 (1.1.0+git20190317.539464a-1) UNRELEASED; urgency=medium
+
+  * New upstream snapshot.
+
+ -- Debian Janitor <janitor@jelmer.uk>  Sun, 26 Jan 2020 21:15:35 +0000
+
 golang-github-spaolacci-murmur3 (1.1-3) unstable; urgency=medium
 
   * Team upload.
diff --git a/murmur128.go b/murmur128.go
index a4b618b..a4fd7e7 100644
--- a/murmur128.go
+++ b/murmur128.go
@@ -3,6 +3,7 @@ package murmur3
 import (
 	//"encoding/binary"
 	"hash"
+	"math/bits"
 	"unsafe"
 )
 
@@ -68,20 +69,20 @@ func (d *digest128) bmix(p []byte) (tail []byte) {
 		k1, k2 := t[0], t[1]
 
 		k1 *= c1_128
-		k1 = (k1 << 31) | (k1 >> 33) // rotl64(k1, 31)
+		k1 = bits.RotateLeft64(k1, 31)
 		k1 *= c2_128
 		h1 ^= k1
 
-		h1 = (h1 << 27) | (h1 >> 37) // rotl64(h1, 27)
+		h1 = bits.RotateLeft64(h1, 27)
 		h1 += h2
 		h1 = h1*5 + 0x52dce729
 
 		k2 *= c2_128
-		k2 = (k2 << 33) | (k2 >> 31) // rotl64(k2, 33)
+		k2 = bits.RotateLeft64(k2, 33)
 		k2 *= c1_128
 		h2 ^= k2
 
-		h2 = (h2 << 31) | (h2 >> 33) // rotl64(h2, 31)
+		h2 = bits.RotateLeft64(h2, 31)
 		h2 += h1
 		h2 = h2*5 + 0x38495ab5
 	}
@@ -117,7 +118,7 @@ func (d *digest128) Sum128() (h1, h2 uint64) {
 		k2 ^= uint64(d.tail[8]) << 0
 
 		k2 *= c2_128
-		k2 = (k2 << 33) | (k2 >> 31) // rotl64(k2, 33)
+		k2 = bits.RotateLeft64(k2, 33)
 		k2 *= c1_128
 		h2 ^= k2
 
@@ -147,7 +148,7 @@ func (d *digest128) Sum128() (h1, h2 uint64) {
 	case 1:
 		k1 ^= uint64(d.tail[0]) << 0
 		k1 *= c1_128
-		k1 = (k1 << 31) | (k1 >> 33) // rotl64(k1, 31)
+		k1 = bits.RotateLeft64(k1, 31)
 		k1 *= c2_128
 		h1 ^= k1
 	}
@@ -176,12 +177,6 @@ func fmix64(k uint64) uint64 {
 	return k
 }
 
-/*
-func rotl64(x uint64, r byte) uint64 {
-	return (x << r) | (x >> (64 - r))
-}
-*/
-
 // Sum128 returns the MurmurHash3 sum of data. It is equivalent to the
 // following sequence (without the extra burden and the extra allocation):
 //     hasher := New128()
@@ -195,7 +190,7 @@ func Sum128(data []byte) (h1 uint64, h2 uint64) { return Sum128WithSeed(data, 0)
 //     hasher.Write(data)
 //     return hasher.Sum128()
 func Sum128WithSeed(data []byte, seed uint32) (h1 uint64, h2 uint64) {
-	d := &digest128{h1: uint64(seed), h2: uint64(seed)}
+	d := digest128{h1: uint64(seed), h2: uint64(seed)}
 	d.seed = seed
 	d.tail = d.bmix(data)
 	d.clen = len(data)
diff --git a/murmur32.go b/murmur32.go
index e32c995..552976a 100644
--- a/murmur32.go
+++ b/murmur32.go
@@ -4,6 +4,7 @@ package murmur3
 
 import (
 	"hash"
+	"math/bits"
 	"unsafe"
 )
 
@@ -55,11 +56,11 @@ func (d *digest32) bmix(p []byte) (tail []byte) {
 		k1 := *(*uint32)(unsafe.Pointer(&p[i*4]))
 
 		k1 *= c1_32
-		k1 = (k1 << 15) | (k1 >> 17) // rotl32(k1, 15)
+		k1 = bits.RotateLeft32(k1, 15)
 		k1 *= c2_32
 
 		h1 ^= k1
-		h1 = (h1 << 13) | (h1 >> 19) // rotl32(h1, 13)
+		h1 = bits.RotateLeft32(h1, 13)
 		h1 = h1*4 + h1 + 0xe6546b64
 	}
 	d.h1 = h1
@@ -81,7 +82,7 @@ func (d *digest32) Sum32() (h1 uint32) {
 	case 1:
 		k1 ^= uint32(d.tail[0])
 		k1 *= c1_32
-		k1 = (k1 << 15) | (k1 >> 17) // rotl32(k1, 15)
+		k1 = bits.RotateLeft32(k1, 15)
 		k1 *= c2_32
 		h1 ^= k1
 	}
@@ -97,12 +98,6 @@ func (d *digest32) Sum32() (h1 uint32) {
 	return h1
 }
 
-/*
-func rotl32(x uint32, r byte) uint32 {
-	return (x << r) | (x >> (32 - r))
-}
-*/
-
 // Sum32 returns the MurmurHash3 sum of data. It is equivalent to the
 // following sequence (without the extra burden and the extra allocation):
 //     hasher := New32()
@@ -129,11 +124,11 @@ func Sum32WithSeed(data []byte, seed uint32) uint32 {
 		k1 := *(*uint32)(unsafe.Pointer(p))
 
 		k1 *= c1_32
-		k1 = (k1 << 15) | (k1 >> 17) // rotl32(k1, 15)
+		k1 = bits.RotateLeft32(k1, 15)
 		k1 *= c2_32
 
 		h1 ^= k1
-		h1 = (h1 << 13) | (h1 >> 19) // rotl32(h1, 13)
+		h1 = bits.RotateLeft32(h1, 13)
 		h1 = h1*4 + h1 + 0xe6546b64
 	}
 
@@ -150,7 +145,7 @@ func Sum32WithSeed(data []byte, seed uint32) uint32 {
 	case 1:
 		k1 ^= uint32(tail[0])
 		k1 *= c1_32
-		k1 = (k1 << 15) | (k1 >> 17) // rotl32(k1, 15)
+		k1 = bits.RotateLeft32(k1, 15)
 		k1 *= c2_32
 		h1 ^= k1
 	}
diff --git a/murmur64.go b/murmur64.go
index 65a410a..04fd82a 100644
--- a/murmur64.go
+++ b/murmur64.go
@@ -48,7 +48,7 @@ func Sum64(data []byte) uint64 { return Sum64WithSeed(data, 0) }
 //     hasher.Write(data)
 //     return hasher.Sum64()
 func Sum64WithSeed(data []byte, seed uint32) uint64 {
-	d := &digest128{h1: uint64(seed), h2: uint64(seed)}
+	d := digest128{h1: uint64(seed), h2: uint64(seed)}
 	d.seed = seed
 	d.tail = d.bmix(data)
 	d.clen = len(data)
diff --git a/murmur_test.go b/murmur_test.go
index fe564d0..945e4e2 100644
--- a/murmur_test.go
+++ b/murmur_test.go
@@ -2,6 +2,7 @@ package murmur3
 
 import (
 	"fmt"
+	"strconv"
 	"testing"
 )
 
@@ -113,153 +114,76 @@ func TestIncremental(t *testing.T) {
 	}
 }
 
-//---
-
-func bench32(b *testing.B, length int) {
-	buf := make([]byte, length)
-	b.SetBytes(int64(length))
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		Sum32(buf)
+func Benchmark32(b *testing.B) {
+	buf := make([]byte, 8192)
+	for length := 1; length <= cap(buf); length *= 2 {
+		b.Run(strconv.Itoa(length), func(b *testing.B) {
+			buf = buf[:length]
+			b.SetBytes(int64(length))
+			b.ReportAllocs()
+			b.ResetTimer()
+			for i := 0; i < b.N; i++ {
+				Sum32(buf)
+			}
+		})
 	}
 }
 
-func Benchmark32_1(b *testing.B) {
-	bench32(b, 1)
-}
-func Benchmark32_2(b *testing.B) {
-	bench32(b, 2)
-}
-func Benchmark32_4(b *testing.B) {
-	bench32(b, 4)
-}
-func Benchmark32_8(b *testing.B) {
-	bench32(b, 8)
-}
-func Benchmark32_16(b *testing.B) {
-	bench32(b, 16)
-}
-func Benchmark32_32(b *testing.B) {
-	bench32(b, 32)
-}
-func Benchmark32_64(b *testing.B) {
-	bench32(b, 64)
-}
-func Benchmark32_128(b *testing.B) {
-	bench32(b, 128)
-}
-func Benchmark32_256(b *testing.B) {
-	bench32(b, 256)
-}
-func Benchmark32_512(b *testing.B) {
-	bench32(b, 512)
-}
-func Benchmark32_1024(b *testing.B) {
-	bench32(b, 1024)
-}
-func Benchmark32_2048(b *testing.B) {
-	bench32(b, 2048)
-}
-func Benchmark32_4096(b *testing.B) {
-	bench32(b, 4096)
-}
-func Benchmark32_8192(b *testing.B) {
-	bench32(b, 8192)
-}
-
-//---
+func BenchmarkPartial32(b *testing.B) {
+	buf := make([]byte, 128)
+	for length := 8; length <= cap(buf); length *= 2 {
+		b.Run(strconv.Itoa(length), func(b *testing.B) {
+			buf = buf[:length]
+			b.SetBytes(int64(length))
+			b.ReportAllocs()
 
-func benchPartial32(b *testing.B, length int) {
-	buf := make([]byte, length)
-	b.SetBytes(int64(length))
+			start := (32 / 8) / 2
+			chunks := 7
+			k := length / chunks
+			tail := (length - start) % k
 
-	start := (32 / 8) / 2
-	chunks := 7
-	k := length / chunks
-	tail := (length - start) % k
+			b.ResetTimer()
+			for i := 0; i < b.N; i++ {
+				hasher := New32()
+				hasher.Write(buf[0:start])
 
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		hasher := New32()
-		hasher.Write(buf[0:start])
+				for j := start; j+k <= length; j += k {
+					hasher.Write(buf[j : j+k])
+				}
 
-		for j := start; j+k <= length; j += k {
-			hasher.Write(buf[j : j+k])
-		}
-
-		hasher.Write(buf[length-tail:])
-		hasher.Sum32()
+				hasher.Write(buf[length-tail:])
+				hasher.Sum32()
+			}
+		})
 	}
 }
 
-func BenchmarkPartial32_8(b *testing.B) {
-	benchPartial32(b, 8)
-}
-func BenchmarkPartial32_16(b *testing.B) {
-	benchPartial32(b, 16)
-}
-func BenchmarkPartial32_32(b *testing.B) {
-	benchPartial32(b, 32)
-}
-func BenchmarkPartial32_64(b *testing.B) {
-	benchPartial32(b, 64)
-}
-func BenchmarkPartial32_128(b *testing.B) {
-	benchPartial32(b, 128)
-}
-
-//---
-
-func bench128(b *testing.B, length int) {
-	buf := make([]byte, length)
-	b.SetBytes(int64(length))
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		Sum128(buf)
+func Benchmark64(b *testing.B) {
+	buf := make([]byte, 8192)
+	for length := 1; length <= cap(buf); length *= 2 {
+		b.Run(strconv.Itoa(length), func(b *testing.B) {
+			buf = buf[:length]
+			b.SetBytes(int64(length))
+			b.ReportAllocs()
+			b.ResetTimer()
+			for i := 0; i < b.N; i++ {
+				Sum64(buf)
+			}
+		})
 	}
 }
 
-func Benchmark128_1(b *testing.B) {
-	bench128(b, 1)
-}
-func Benchmark128_2(b *testing.B) {
-	bench128(b, 2)
-}
-func Benchmark128_4(b *testing.B) {
-	bench128(b, 4)
-}
-func Benchmark128_8(b *testing.B) {
-	bench128(b, 8)
-}
-func Benchmark128_16(b *testing.B) {
-	bench128(b, 16)
-}
-func Benchmark128_32(b *testing.B) {
-	bench128(b, 32)
-}
-func Benchmark128_64(b *testing.B) {
-	bench128(b, 64)
-}
-func Benchmark128_128(b *testing.B) {
-	bench128(b, 128)
-}
-func Benchmark128_256(b *testing.B) {
-	bench128(b, 256)
-}
-func Benchmark128_512(b *testing.B) {
-	bench128(b, 512)
-}
-func Benchmark128_1024(b *testing.B) {
-	bench128(b, 1024)
-}
-func Benchmark128_2048(b *testing.B) {
-	bench128(b, 2048)
-}
-func Benchmark128_4096(b *testing.B) {
-	bench128(b, 4096)
-}
-func Benchmark128_8192(b *testing.B) {
-	bench128(b, 8192)
+func Benchmark128(b *testing.B) {
+	buf := make([]byte, 8192)
+	for length := 1; length <= cap(buf); length *= 2 {
+		b.Run(strconv.Itoa(length), func(b *testing.B) {
+			buf = buf[:length]
+			b.SetBytes(int64(length))
+			b.ReportAllocs()
+			b.ResetTimer()
+			for i := 0; i < b.N; i++ {
+				Sum128(buf)
+			}
+		})
+	}
 }
-
-//---