vendor: add ipfs cid libraries

vendor/github.com/gxed/hashland/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Lawrence E. Bakst
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

vendor/github.com/gxed/hashland/keccakpg/go.mod

@@ -0,0 +1 @@
+module github.com/gxed/hashland/keccakpg

vendor/github.com/gxed/hashland/keccakpg/keccak.go

@@ -0,0 +1,224 @@
+// Package keccak implements the Keccak (SHA-3) hash algorithm.
+// http://keccak.noekeon.org.
+package keccakpg
+
+import (
+	_ "fmt"
+	"hash"
+)
+
+const stdRounds = 24
+
+var roundConstants = []uint64{
+	0x0000000000000001, 0x0000000000008082,
+	0x800000000000808A, 0x8000000080008000,
+	0x000000000000808B, 0x0000000080000001,
+	0x8000000080008081, 0x8000000000008009,
+	0x000000000000008A, 0x0000000000000088,
+	0x0000000080008009, 0x000000008000000A,
+	0x000000008000808B, 0x800000000000008B,
+	0x8000000000008089, 0x8000000000008003,
+	0x8000000000008002, 0x8000000000000080,
+	0x000000000000800A, 0x800000008000000A,
+	0x8000000080008081, 0x8000000000008080,
+	0x0000000080000001, 0x8000000080008008,
+}
+
+var rotationConstants = [24]uint{
+	1, 3, 6, 10, 15, 21, 28, 36,
+	45, 55, 2, 14, 27, 41, 56, 8,
+	25, 43, 62, 18, 39, 61, 20, 44,
+}
+
+var piLane = [24]uint{
+	10, 7, 11, 17, 18, 3, 5, 16,
+	8, 21, 24, 4, 15, 23, 19, 13,
+	12, 2, 20, 14, 22, 9, 6, 1,
+}
+
+type keccak struct {
+	S         [25]uint64
+	size      int
+	blockSize int
+	rounds    int
+	buf       []byte
+}
+
+func newKeccak(bitlen, rounds int) hash.Hash {
+	var h keccak
+	h.size = bitlen / 8
+	h.blockSize = (200 - 2*h.size)
+	h.rounds = rounds
+	if rounds != stdRounds {
+		//fmt.Printf("keccak: warning non standard number of rounds %d vs %d\n", rounds, stdRounds)
+	}
+	return &h
+}
+
+func NewCustom(bits, rounds int) hash.Hash {
+	return newKeccak(bits, rounds)
+}
+
+func New160() hash.Hash {
+	return newKeccak(160, stdRounds)
+}
+
+func New224() hash.Hash {
+	return newKeccak(224, stdRounds)
+}
+
+func New256() hash.Hash {
+	return newKeccak(256, stdRounds)
+}
+
+func New384() hash.Hash {
+	return newKeccak(384, stdRounds)
+}
+
+func New512() hash.Hash {
+	return newKeccak(512, stdRounds)
+}
+
+func (k *keccak) Write(b []byte) (int, error) {
+	n := len(b)
+
+	if len(k.buf) > 0 {
+		x := k.blockSize - len(k.buf)
+		if x > len(b) {
+			x = len(b)
+		}
+		k.buf = append(k.buf, b[:x]...)
+		b = b[x:]
+
+		if len(k.buf) < k.blockSize {
+			return n, nil
+		}
+
+		k.f(k.buf)
+		k.buf = nil
+	}
+
+	for len(b) >= k.blockSize {
+		k.f(b[:k.blockSize])
+		b = b[k.blockSize:]
+	}
+
+	k.buf = b
+
+	return n, nil
+}
+
+func (k0 *keccak) Sum(b []byte) []byte {
+
+	k := *k0
+
+	last := k.pad(k.buf)
+	k.f(last)
+
+	buf := make([]byte, len(k.S)*8)
+	for i := range k.S {
+		putUint64le(buf[i*8:], k.S[i])
+	}
+	return append(b, buf[:k.size]...)
+}
+
+func (k *keccak) Reset() {
+	for i := range k.S {
+		k.S[i] = 0
+	}
+	k.buf = nil
+}
+
+func (k *keccak) Size() int {
+	return k.size
+}
+
+func (k *keccak) BlockSize() int {
+	return k.blockSize
+}
+
+func rotl64(x uint64, n uint) uint64 {
+	return (x << n) | (x >> (64 - n))
+}
+
+func (k *keccak) f(block []byte) {
+
+	if len(block) != k.blockSize {
+		panic("f() called with invalid block size")
+	}
+
+	for i := 0; i < k.blockSize/8; i++ {
+		k.S[i] ^= uint64le(block[i*8:])
+	}
+
+	for r := 0; r < k.rounds; r++ {
+		var bc [5]uint64
+
+		// theta
+		for i := range bc {
+			bc[i] = k.S[i] ^ k.S[5+i] ^ k.S[10+i] ^ k.S[15+i] ^ k.S[20+i]
+		}
+		for i := range bc {
+			t := bc[(i+4)%5] ^ rotl64(bc[(i+1)%5], 1)
+			for j := 0; j < len(k.S); j += 5 {
+				k.S[i+j] ^= t
+			}
+		}
+
+		// rho phi
+		temp := k.S[1]
+		for i := range piLane {
+			j := piLane[i]
+			temp2 := k.S[j]
+			k.S[j] = rotl64(temp, rotationConstants[i])
+			temp = temp2
+		}
+
+		// chi
+		for j := 0; j < len(k.S); j += 5 {
+			for i := range bc {
+				bc[i] = k.S[j+i]
+			}
+			for i := range bc {
+				k.S[j+i] ^= (^bc[(i+1)%5]) & bc[(i+2)%5]
+			}
+		}
+
+		// iota
+		k.S[0] ^= roundConstants[r]
+	}
+}
+
+func (k *keccak) pad(block []byte) []byte {
+
+	padded := make([]byte, k.blockSize)
+
+	copy(padded, k.buf)
+	padded[len(k.buf)] = 0x01
+	padded[len(padded)-1] |= 0x80
+
+	return padded
+}
+
+func uint64le(v []byte) uint64 {
+	return uint64(v[0]) |
+		uint64(v[1])<<8 |
+		uint64(v[2])<<16 |
+		uint64(v[3])<<24 |
+		uint64(v[4])<<32 |
+		uint64(v[5])<<40 |
+		uint64(v[6])<<48 |
+		uint64(v[7])<<56
+
+}
+
+func putUint64le(v []byte, x uint64) {
+	v[0] = byte(x)
+	v[1] = byte(x >> 8)
+	v[2] = byte(x >> 16)
+	v[3] = byte(x >> 24)
+	v[4] = byte(x >> 32)
+	v[5] = byte(x >> 40)
+	v[6] = byte(x >> 48)
+	v[7] = byte(x >> 56)
+}

vendor/github.com/gxed/hashland/keccakpg/package.json

@@ -0,0 +1,14 @@
+{
+  "author": "whyrusleeping",
+  "bugs": {},
+  "gx": {
+    "dvcsimport": "github.com/gxed/hashland/keccakpg"
+  },
+  "gxVersion": "0.10.0",
+  "language": "go",
+  "license": "",
+  "name": "keccakpg",
+  "releaseCmd": "git commit -a -m \"gx publish $VERSION\"",
+  "version": "0.0.1"
+}
+

vendor/github.com/gxed/hashland/murmur3/LICENSE

@@ -0,0 +1,24 @@
+Copyright 2013, Sébastien Paolacci.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the library nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/gxed/hashland/murmur3/README.md

@@ -0,0 +1,84 @@
+murmur3
+=======
+
+Native Go implementation of Austin Appleby's third MurmurHash revision (aka
+MurmurHash3).
+
+Reference algorithm has been slightly hacked as to support the streaming mode
+required by Go's standard [Hash interface](http://golang.org/pkg/hash/#Hash).
+
+
+Benchmarks
+----------
+
+Go tip as of 2014-06-12 (i.e almost go1.3), core i7 @ 3.4 Ghz. All runs
+include hasher instantiation and sequence finalization.
+
+<pre>
+
+Benchmark32_1        500000000     7.69 ns/op      130.00 MB/s
+Benchmark32_2        200000000     8.83 ns/op      226.42 MB/s
+Benchmark32_4        500000000     7.99 ns/op      500.39 MB/s
+Benchmark32_8        200000000     9.47 ns/op      844.69 MB/s
+Benchmark32_16       100000000     12.1 ns/op     1321.61 MB/s
+Benchmark32_32       100000000     18.3 ns/op     1743.93 MB/s
+Benchmark32_64        50000000     30.9 ns/op     2071.64 MB/s
+Benchmark32_128       50000000     57.6 ns/op     2222.96 MB/s
+Benchmark32_256       20000000      116 ns/op     2188.60 MB/s
+Benchmark32_512       10000000      226 ns/op     2260.59 MB/s
+Benchmark32_1024       5000000      452 ns/op     2263.73 MB/s
+Benchmark32_2048       2000000      891 ns/op     2296.02 MB/s
+Benchmark32_4096       1000000     1787 ns/op     2290.92 MB/s
+Benchmark32_8192        500000     3593 ns/op     2279.68 MB/s
+Benchmark128_1       100000000     26.1 ns/op       38.33 MB/s
+Benchmark128_2       100000000     29.0 ns/op       69.07 MB/s
+Benchmark128_4        50000000     29.8 ns/op      134.17 MB/s
+Benchmark128_8        50000000     31.6 ns/op      252.86 MB/s
+Benchmark128_16      100000000     26.5 ns/op      603.42 MB/s
+Benchmark128_32      100000000     28.6 ns/op     1117.15 MB/s
+Benchmark128_64       50000000     35.5 ns/op     1800.97 MB/s
+Benchmark128_128      50000000     50.9 ns/op     2515.50 MB/s
+Benchmark128_256      20000000     76.9 ns/op     3330.11 MB/s
+Benchmark128_512      20000000      135 ns/op     3769.09 MB/s
+Benchmark128_1024     10000000      250 ns/op     4094.38 MB/s
+Benchmark128_2048      5000000      477 ns/op     4290.75 MB/s
+Benchmark128_4096      2000000      940 ns/op     4353.29 MB/s
+Benchmark128_8192      1000000     1838 ns/op     4455.47 MB/s
+
+</pre>
+
+
+<pre>
+
+benchmark              Go1.0 MB/s    Go1.1 MB/s  speedup    Go1.2 MB/s  speedup    Go1.3 MB/s  speedup
+Benchmark32_1               98.90        118.59    1.20x        114.79    0.97x        130.00    1.13x
+Benchmark32_2              168.04        213.31    1.27x        210.65    0.99x        226.42    1.07x
+Benchmark32_4              414.01        494.19    1.19x        490.29    0.99x        500.39    1.02x
+Benchmark32_8              662.19        836.09    1.26x        836.46    1.00x        844.69    1.01x
+Benchmark32_16             917.46       1304.62    1.42x       1297.63    0.99x       1321.61    1.02x
+Benchmark32_32            1141.93       1737.54    1.52x       1728.24    0.99x       1743.93    1.01x
+Benchmark32_64            1289.47       2039.51    1.58x       2038.20    1.00x       2071.64    1.02x
+Benchmark32_128           1299.23       2097.63    1.61x       2177.13    1.04x       2222.96    1.02x
+Benchmark32_256           1369.90       2202.34    1.61x       2213.15    1.00x       2188.60    0.99x
+Benchmark32_512           1399.56       2255.72    1.61x       2264.49    1.00x       2260.59    1.00x
+Benchmark32_1024          1410.90       2285.82    1.62x       2270.99    0.99x       2263.73    1.00x
+Benchmark32_2048          1422.14       2297.62    1.62x       2269.59    0.99x       2296.02    1.01x
+Benchmark32_4096          1420.53       2307.81    1.62x       2273.43    0.99x       2290.92    1.01x
+Benchmark32_8192          1424.79       2312.87    1.62x       2286.07    0.99x       2279.68    1.00x
+Benchmark128_1               8.32         30.15    3.62x         30.84    1.02x         38.33    1.24x
+Benchmark128_2              16.38         59.72    3.65x         59.37    0.99x         69.07    1.16x
+Benchmark128_4              32.26        112.96    3.50x        114.24    1.01x        134.17    1.17x
+Benchmark128_8              62.68        217.88    3.48x        218.18    1.00x        252.86    1.16x
+Benchmark128_16            128.47        451.57    3.51x        474.65    1.05x        603.42    1.27x
+Benchmark128_32            246.18        910.42    3.70x        871.06    0.96x       1117.15    1.28x
+Benchmark128_64            449.05       1477.64    3.29x       1449.24    0.98x       1800.97    1.24x
+Benchmark128_128           762.61       2222.42    2.91x       2217.30    1.00x       2515.50    1.13x
+Benchmark128_256          1179.92       3005.46    2.55x       2931.55    0.98x       3330.11    1.14x
+Benchmark128_512          1616.51       3590.75    2.22x       3592.08    1.00x       3769.09    1.05x
+Benchmark128_1024         1964.36       3979.67    2.03x       4034.01    1.01x       4094.38    1.01x
+Benchmark128_2048         2225.07       4156.93    1.87x       4244.17    1.02x       4290.75    1.01x
+Benchmark128_4096         2360.15       4299.09    1.82x       4392.35    1.02x       4353.29    0.99x
+Benchmark128_8192         2411.50       4356.84    1.81x       4480.68    1.03x       4455.47    0.99x
+
+</pre>
+

vendor/github.com/gxed/hashland/murmur3/go.mod

@@ -0,0 +1 @@
+module github.com/gxed/hashland/murmur3

vendor/github.com/gxed/hashland/murmur3/murmur.go

@@ -0,0 +1,65 @@
+// Copyright 2013, Sébastien Paolacci. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+Native (and fast) implementation of Austin Appleby's MurmurHash3.
+
+Package murmur3 implements Austin Appleby's non-cryptographic MurmurHash3.
+
+ Reference implementation:
+    http://code.google.com/p/smhasher/wiki/MurmurHash3
+
+ History, characteristics and (legacy) perfs:
+    https://sites.google.com/site/murmurhash/
+    https://sites.google.com/site/murmurhash/statistics
+*/
+package murmur3
+
+type bmixer interface {
+	bmix(p []byte) (tail []byte)
+	Size() (n int)
+	reset()
+}
+
+type digest struct {
+	clen int      // Digested input cumulative length.
+	tail []byte   // 0 to Size()-1 bytes view of `buf'.
+	buf  [16]byte // Expected (but not required) to be Size() large.
+	bmixer
+}
+
+func (d *digest) BlockSize() int { return 1 }
+
+func (d *digest) Write(p []byte) (n int, err error) {
+	n = len(p)
+	d.clen += n
+
+	if len(d.tail) > 0 {
+		// Stick back pending bytes.
+		nfree := d.Size() - len(d.tail) // nfree ∈ [1, d.Size()-1].
+		if nfree < len(p) {
+			// One full block can be formed.
+			block := append(d.tail, p[:nfree]...)
+			p = p[nfree:]
+			_ = d.bmix(block) // No tail.
+		} else {
+			// Tail's buf is large enough to prevent reallocs.
+			p = append(d.tail, p...)
+		}
+	}
+
+	d.tail = d.bmix(p)
+
+	// Keep own copy of the 0 to Size()-1 pending bytes.
+	nn := copy(d.buf[:], d.tail)
+	d.tail = d.buf[:nn]
+
+	return n, nil
+}
+
+func (d *digest) Reset() {
+	d.clen = 0
+	d.tail = nil
+	d.bmixer.reset()
+}

vendor/github.com/gxed/hashland/murmur3/murmur128.go

@@ -0,0 +1,189 @@
+package murmur3
+
+import (
+	//"encoding/binary"
+	"hash"
+	"unsafe"
+)
+
+const (
+	c1_128 = 0x87c37b91114253d5
+	c2_128 = 0x4cf5ad432745937f
+)
+
+// Make sure interfaces are correctly implemented.
+var (
+	_ hash.Hash = new(digest128)
+	_ Hash128   = new(digest128)
+	_ bmixer    = new(digest128)
+)
+
+// Hack: the standard api doesn't define any Hash128 interface.
+type Hash128 interface {
+	hash.Hash
+	Sum128() (uint64, uint64)
+}
+
+// digest128 represents a partial evaluation of a 128 bites hash.
+type digest128 struct {
+	digest
+	h1 uint64 // Unfinalized running hash part 1.
+	h2 uint64 // Unfinalized running hash part 2.
+}
+
+func New128() Hash128 {
+	d := new(digest128)
+	d.bmixer = d
+	d.Reset()
+	return d
+}
+
+func (d *digest128) Size() int { return 16 }
+
+func (d *digest128) reset() { d.h1, d.h2 = 0, 0 }
+
+func (d *digest128) Sum(b []byte) []byte {
+	h1, h2 := d.h1, d.h2
+	return append(b,
+		byte(h1>>56), byte(h1>>48), byte(h1>>40), byte(h1>>32),
+		byte(h1>>24), byte(h1>>16), byte(h1>>8), byte(h1),
+
+		byte(h2>>56), byte(h2>>48), byte(h2>>40), byte(h2>>32),
+		byte(h2>>24), byte(h2>>16), byte(h2>>8), byte(h2),
+	)
+}
+
+func (d *digest128) bmix(p []byte) (tail []byte) {
+	h1, h2 := d.h1, d.h2
+
+	nblocks := len(p) / 16
+	for i := 0; i < nblocks; i++ {
+		t := (*[2]uint64)(unsafe.Pointer(&p[i*16]))
+		k1, k2 := t[0], t[1]
+
+		k1 *= c1_128
+		k1 = (k1 << 31) | (k1 >> 33) // rotl64(k1, 31)
+		k1 *= c2_128
+		h1 ^= k1
+
+		h1 = (h1 << 27) | (h1 >> 37) // rotl64(h1, 27)
+		h1 += h2
+		h1 = h1*5 + 0x52dce729
+
+		k2 *= c2_128
+		k2 = (k2 << 33) | (k2 >> 31) // rotl64(k2, 33)
+		k2 *= c1_128
+		h2 ^= k2
+
+		h2 = (h2 << 31) | (h2 >> 33) // rotl64(h2, 31)
+		h2 += h1
+		h2 = h2*5 + 0x38495ab5
+	}
+	d.h1, d.h2 = h1, h2
+	return p[nblocks*d.Size():]
+}
+
+func (d *digest128) Sum128() (h1, h2 uint64) {
+
+	h1, h2 = d.h1, d.h2
+
+	var k1, k2 uint64
+	switch len(d.tail) & 15 {
+	case 15:
+		k2 ^= uint64(d.tail[14]) << 48
+		fallthrough
+	case 14:
+		k2 ^= uint64(d.tail[13]) << 40
+		fallthrough
+	case 13:
+		k2 ^= uint64(d.tail[12]) << 32
+		fallthrough
+	case 12:
+		k2 ^= uint64(d.tail[11]) << 24
+		fallthrough
+	case 11:
+		k2 ^= uint64(d.tail[10]) << 16
+		fallthrough
+	case 10:
+		k2 ^= uint64(d.tail[9]) << 8
+		fallthrough
+	case 9:
+		k2 ^= uint64(d.tail[8]) << 0
+
+		k2 *= c2_128
+		k2 = (k2 << 33) | (k2 >> 31) // rotl64(k2, 33)
+		k2 *= c1_128
+		h2 ^= k2
+
+		fallthrough
+
+	case 8:
+		k1 ^= uint64(d.tail[7]) << 56
+		fallthrough
+	case 7:
+		k1 ^= uint64(d.tail[6]) << 48
+		fallthrough
+	case 6:
+		k1 ^= uint64(d.tail[5]) << 40
+		fallthrough
+	case 5:
+		k1 ^= uint64(d.tail[4]) << 32
+		fallthrough
+	case 4:
+		k1 ^= uint64(d.tail[3]) << 24
+		fallthrough
+	case 3:
+		k1 ^= uint64(d.tail[2]) << 16
+		fallthrough
+	case 2:
+		k1 ^= uint64(d.tail[1]) << 8
+		fallthrough
+	case 1:
+		k1 ^= uint64(d.tail[0]) << 0
+		k1 *= c1_128
+		k1 = (k1 << 31) | (k1 >> 33) // rotl64(k1, 31)
+		k1 *= c2_128
+		h1 ^= k1
+	}
+
+	h1 ^= uint64(d.clen)
+	h2 ^= uint64(d.clen)
+
+	h1 += h2
+	h2 += h1
+
+	h1 = fmix64(h1)
+	h2 = fmix64(h2)
+
+	h1 += h2
+	h2 += h1
+
+	return h1, h2
+}
+
+func fmix64(k uint64) uint64 {
+	k ^= k >> 33
+	k *= 0xff51afd7ed558ccd
+	k ^= k >> 33
+	k *= 0xc4ceb9fe1a85ec53
+	k ^= k >> 33
+	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()
+//     hasher.Write(data)
+//     return hasher.Sum128()
+func Sum128(data []byte) (h1 uint64, h2 uint64) {
+	d := &digest128{h1: 0, h2: 0}
+	d.tail = d.bmix(data)
+	d.clen = len(data)
+	return d.Sum128()
+}

vendor/github.com/gxed/hashland/murmur3/murmur32.go

@@ -0,0 +1,154 @@
+package murmur3
+
+// http://code.google.com/p/guava-libraries/source/browse/guava/src/com/google/common/hash/Murmur3_32HashFunction.java
+
+import (
+	"hash"
+	"unsafe"
+)
+
+// Make sure interfaces are correctly implemented.
+var (
+	_ hash.Hash   = new(digest32)
+	_ hash.Hash32 = new(digest32)
+)
+
+const (
+	c1_32 uint32 = 0xcc9e2d51
+	c2_32 uint32 = 0x1b873593
+)
+
+// digest32 represents a partial evaluation of a 32 bites hash.
+type digest32 struct {
+	digest
+	h1 uint32 // Unfinalized running hash.
+}
+
+func New32() hash.Hash32 {
+	d := new(digest32)
+	d.bmixer = d
+	d.Reset()
+	return d
+}
+
+func (d *digest32) Size() int { return 4 }
+
+func (d *digest32) reset() { d.h1 = 0 }
+
+func (d *digest32) Sum(b []byte) []byte {
+	h := d.h1
+	return append(b, byte(h>>24), byte(h>>16), byte(h>>8), byte(h))
+}
+
+// Digest as many blocks as possible.
+func (d *digest32) bmix(p []byte) (tail []byte) {
+	h1 := d.h1
+
+	nblocks := len(p) / 4
+	for i := 0; i < nblocks; i++ {
+		k1 := *(*uint32)(unsafe.Pointer(&p[i*4]))
+
+		k1 *= c1_32
+		k1 = (k1 << 15) | (k1 >> 17) // rotl32(k1, 15)
+		k1 *= c2_32
+
+		h1 ^= k1
+		h1 = (h1 << 13) | (h1 >> 19) // rotl32(h1, 13)
+		h1 = h1*5 + 0xe6546b64
+	}
+	d.h1 = h1
+	return p[nblocks*d.Size():]
+}
+
+func (d *digest32) Sum32() (h1 uint32) {
+
+	h1 = d.h1
+
+	var k1 uint32
+	switch len(d.tail) & 3 {
+	case 3:
+		k1 ^= uint32(d.tail[2]) << 16
+		fallthrough
+	case 2:
+		k1 ^= uint32(d.tail[1]) << 8
+		fallthrough
+	case 1:
+		k1 ^= uint32(d.tail[0])
+		k1 *= c1_32
+		k1 = (k1 << 15) | (k1 >> 17) // rotl32(k1, 15)
+		k1 *= c2_32
+		h1 ^= k1
+	}
+
+	h1 ^= uint32(d.clen)
+
+	h1 ^= h1 >> 16
+	h1 *= 0x85ebca6b
+	h1 ^= h1 >> 13
+	h1 *= 0xc2b2ae35
+	h1 ^= h1 >> 16
+
+	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()
+//     hasher.Write(data)
+//     return hasher.Sum32()
+func Sum32(data []byte) uint32 {
+
+	var h1 uint32 = 0
+
+	nblocks := len(data) / 4
+	var p uintptr
+	if len(data) > 0 {
+		p = uintptr(unsafe.Pointer(&data[0]))
+	}
+	p1 := p + uintptr(4*nblocks)
+	for ; p < p1; p += 4 {
+		k1 := *(*uint32)(unsafe.Pointer(p))
+
+		k1 *= c1_32
+		k1 = (k1 << 15) | (k1 >> 17) // rotl32(k1, 15)
+		k1 *= c2_32
+
+		h1 ^= k1
+		h1 = (h1 << 13) | (h1 >> 19) // rotl32(h1, 13)
+		h1 = h1*5 + 0xe6546b64
+	}
+
+	tail := data[nblocks*4:]
+
+	var k1 uint32
+	switch len(tail) & 3 {
+	case 3:
+		k1 ^= uint32(tail[2]) << 16
+		fallthrough
+	case 2:
+		k1 ^= uint32(tail[1]) << 8
+		fallthrough
+	case 1:
+		k1 ^= uint32(tail[0])
+		k1 *= c1_32
+		k1 = (k1 << 15) | (k1 >> 17) // rotl32(k1, 15)
+		k1 *= c2_32
+		h1 ^= k1
+	}
+
+	h1 ^= uint32(len(data))
+
+	h1 ^= h1 >> 16
+	h1 *= 0x85ebca6b
+	h1 ^= h1 >> 13
+	h1 *= 0xc2b2ae35
+	h1 ^= h1 >> 16
+
+	return h1
+}

vendor/github.com/gxed/hashland/murmur3/murmur64.go

@@ -0,0 +1,45 @@
+package murmur3
+
+import (
+	"hash"
+)
+
+// Make sure interfaces are correctly implemented.
+var (
+	_ hash.Hash   = new(digest64)
+	_ hash.Hash64 = new(digest64)
+	_ bmixer      = new(digest64)
+)
+
+// digest64 is half a digest128.
+type digest64 digest128
+
+func New64() hash.Hash64 {
+	d := (*digest64)(New128().(*digest128))
+	return d
+}
+
+func (d *digest64) Sum(b []byte) []byte {
+	h1 := d.h1
+	return append(b,
+		byte(h1>>56), byte(h1>>48), byte(h1>>40), byte(h1>>32),
+		byte(h1>>24), byte(h1>>16), byte(h1>>8), byte(h1))
+}
+
+func (d *digest64) Sum64() uint64 {
+	h1, _ := (*digest128)(d).Sum128()
+	return h1
+}
+
+// Sum64 returns the MurmurHash3 sum of data. It is equivalent to the
+// following sequence (without the extra burden and the extra allocation):
+//     hasher := New64()
+//     hasher.Write(data)
+//     return hasher.Sum64()
+func Sum64(data []byte) uint64 {
+	d := &digest128{h1: 0, h2: 0}
+	d.tail = d.bmix(data)
+	d.clen = len(data)
+	h1, _ := d.Sum128()
+	return h1
+}

vendor/github.com/ipfs/go-cid/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Protocol Labs, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/github.com/ipfs/go-cid/Makefile

@@ -0,0 +1,16 @@
+all: deps
+
+gx:
+	go get github.com/whyrusleeping/gx
+	go get github.com/whyrusleeping/gx-go
+
+covertools:
+	go get github.com/mattn/goveralls
+	go get golang.org/x/tools/cmd/cover
+
+deps: gx covertools
+	gx --verbose install --global
+	gx-go rewrite
+
+publish:
+	gx-go rewrite --undo

vendor/github.com/ipfs/go-cid/README.md

@@ -0,0 +1,125 @@
+go-cid
+==================
+
+[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://ipn.io)
+[![](https://img.shields.io/badge/project-IPFS-blue.svg?style=flat-square)](http://ipfs.io/)
+[![](https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23ipfs)
+[![](https://img.shields.io/badge/readme%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
+[![GoDoc](https://godoc.org/github.com/ipfs/go-cid?status.svg)](https://godoc.org/github.com/ipfs/go-cid)
+[![Coverage Status](https://coveralls.io/repos/github/ipfs/go-cid/badge.svg?branch=master)](https://coveralls.io/github/ipfs/go-cid?branch=master)
+[![Travis CI](https://travis-ci.org/ipfs/go-cid.svg?branch=master)](https://travis-ci.org/ipfs/go-cid)
+
+> A package to handle content IDs in Go.
+
+This is an implementation in Go of the [CID spec](https://github.com/ipld/cid).
+It is used in `go-ipfs` and related packages to refer to a typed hunk of data.
+
+
+## Table of Contents
+
+- [Install](#install)
+- [Usage](#usage)
+- [API](#api)
+- [Contribute](#contribute)
+- [License](#license)
+
+## Install
+
+`go-cid` is a standard Go module which can be installed with:
+
+```sh
+go get github.com/ipfs/go-cid
+```
+
+Note that `go-cid` is packaged with Gx, so it is recommended to use Gx to install and use it (see Usage section).
+
+## Usage
+
+### Using Gx and Gx-go
+
+This module is packaged with [Gx](https://github.com/whyrusleeping/gx). In order to use it in your own project it is recommended that you:
+
+```sh
+go get -u github.com/whyrusleeping/gx
+go get -u github.com/whyrusleeping/gx-go
+cd <your-project-repository>
+gx init
+gx import github.com/ipfs/go-cid
+gx install --global
+gx-go --rewrite
+```
+
+Please check [Gx](https://github.com/whyrusleeping/gx) and [Gx-go](https://github.com/whyrusleeping/gx-go) documentation for more information.
+
+### Running tests
+
+Before running tests, please run:
+
+```sh
+make deps
+```
+
+This will make sure that dependencies are rewritten to known working versions.
+
+### Examples
+
+#### Parsing string input from users
+
+```go
+// Create a cid from a marshaled string
+c, err := cid.Decode("zdvgqEMYmNeH5fKciougvQcfzMcNjF3Z1tPouJ8C7pc3pe63k")
+if err != nil {...}
+
+fmt.Println("Got CID: ", c)
+```
+
+#### Creating a CID from scratch
+
+```go
+// Create a cid manually by specifying the 'prefix' parameters
+pref := cid.Prefix{
+	Version: 1,
+	Codec: cid.Raw,
+	MhType: mh.SHA2_256,
+	MhLength: -1, // default length
+}
+
+// And then feed it some data
+c, err := pref.Sum([]byte("Hello World!"))
+if err != nil {...}
+
+fmt.Println("Created CID: ", c)
+```
+
+#### Check if two CIDs match
+
+```go
+// To test if two cid's are equivalent, be sure to use the 'Equals' method:
+if c1.Equals(c2) {
+	fmt.Println("These two refer to the same exact data!")
+}
+```
+
+#### Check if some data matches a given CID
+
+```go
+// To check if some data matches a given cid, 
+// Get your CIDs prefix, and use that to sum the data in question:
+other, err := c.Prefix().Sum(mydata)
+if err != nil {...}
+
+if !c.Equals(other) {
+	fmt.Println("This data is different.")
+}
+
+```
+
+## Contribute
+
+PRs are welcome!
+
+Small note: If editing the Readme, please conform to the [standard-readme](https://github.com/RichardLitt/standard-readme) specification.
+
+## License
+
+MIT © Jeromy Johnson

vendor/github.com/ipfs/go-cid/builder.go

@@ -0,0 +1,74 @@
+package cid
+
+import (
+	mh "github.com/multiformats/go-multihash"
+)
+
+type Builder interface {
+	Sum(data []byte) (Cid, error)
+	GetCodec() uint64
+	WithCodec(uint64) Builder
+}
+
+type V0Builder struct{}
+
+type V1Builder struct {
+	Codec    uint64
+	MhType   uint64
+	MhLength int // MhLength <= 0 means the default length
+}
+
+func (p Prefix) GetCodec() uint64 {
+	return p.Codec
+}
+
+func (p Prefix) WithCodec(c uint64) Builder {
+	if c == p.Codec {
+		return p
+	}
+	p.Codec = c
+	if c != DagProtobuf {
+		p.Version = 1
+	}
+	return p
+}
+
+func (p V0Builder) Sum(data []byte) (Cid, error) {
+	hash, err := mh.Sum(data, mh.SHA2_256, -1)
+	if err != nil {
+		return Undef, err
+	}
+	return NewCidV0(hash), nil
+}
+
+func (p V0Builder) GetCodec() uint64 {
+	return DagProtobuf
+}
+
+func (p V0Builder) WithCodec(c uint64) Builder {
+	if c == DagProtobuf {
+		return p
+	}
+	return V1Builder{Codec: c, MhType: mh.SHA2_256}
+}
+
+func (p V1Builder) Sum(data []byte) (Cid, error) {
+	mhLen := p.MhLength
+	if mhLen <= 0 {
+		mhLen = -1
+	}
+	hash, err := mh.Sum(data, p.MhType, mhLen)
+	if err != nil {
+		return Undef, err
+	}
+	return NewCidV1(p.Codec, hash), nil
+}
+
+func (p V1Builder) GetCodec() uint64 {
+	return p.Codec
+}
+
+func (p V1Builder) WithCodec(c uint64) Builder {
+	p.Codec = c
+	return p
+}

vendor/github.com/ipfs/go-cid/cid.go

@@ -0,0 +1,601 @@
+// Package cid implements the Content-IDentifiers specification
+// (https://github.com/ipld/cid) in Go. CIDs are
+// self-describing content-addressed identifiers useful for
+// distributed information systems. CIDs are used in the IPFS
+// (https://ipfs.io) project ecosystem.
+//
+// CIDs have two major versions. A CIDv0 corresponds to a multihash of type
+// DagProtobuf, is deprecated and exists for compatibility reasons. Usually,
+// CIDv1 should be used.
+//
+// A CIDv1 has four parts:
+//
+//     <cidv1> ::= <multibase-prefix><cid-version><multicodec-packed-content-type><multihash-content-address>
+//
+// As shown above, the CID implementation relies heavily on Multiformats,
+// particularly Multibase
+// (https://github.com/multiformats/go-multibase), Multicodec
+// (https://github.com/multiformats/multicodec) and Multihash
+// implementations (https://github.com/multiformats/go-multihash).
+package cid
+
+import (
+	"bytes"
+	"encoding"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strings"
+
+	mbase "github.com/multiformats/go-multibase"
+	mh "github.com/multiformats/go-multihash"
+)
+
+// UnsupportedVersionString just holds an error message
+const UnsupportedVersionString = "<unsupported cid version>"
+
+var (
+	// ErrVarintBuffSmall means that a buffer passed to the cid parser was not
+	// long enough, or did not contain an invalid cid
+	ErrVarintBuffSmall = errors.New("reading varint: buffer too small")
+
+	// ErrVarintTooBig means that the varint in the given cid was above the
+	// limit of 2^64
+	ErrVarintTooBig = errors.New("reading varint: varint bigger than 64bits" +
+		" and not supported")
+
+	// ErrCidTooShort means that the cid passed to decode was not long
+	// enough to be a valid Cid
+	ErrCidTooShort = errors.New("cid too short")
+
+	// ErrInvalidEncoding means that selected encoding is not supported
+	// by this Cid version
+	ErrInvalidEncoding = errors.New("invalid base encoding")
+)
+
+// These are multicodec-packed content types. The should match
+// the codes described in the authoritative document:
+// https://github.com/multiformats/multicodec/blob/master/table.csv
+const (
+	Raw = 0x55
+
+	DagProtobuf = 0x70
+	DagCBOR     = 0x71
+
+	GitRaw = 0x78
+
+	EthBlock           = 0x90
+	EthBlockList       = 0x91
+	EthTxTrie          = 0x92
+	EthTx              = 0x93
+	EthTxReceiptTrie   = 0x94
+	EthTxReceipt       = 0x95
+	EthStateTrie       = 0x96
+	EthAccountSnapshot = 0x97
+	EthStorageTrie     = 0x98
+	BitcoinBlock       = 0xb0
+	BitcoinTx          = 0xb1
+	ZcashBlock         = 0xc0
+	ZcashTx            = 0xc1
+	DecredBlock        = 0xe0
+	DecredTx           = 0xe1
+	DashBlock          = 0xf0
+	DashTx             = 0xf1
+)
+
+// Codecs maps the name of a codec to its type
+var Codecs = map[string]uint64{
+	"v0":                   DagProtobuf,
+	"raw":                  Raw,
+	"protobuf":             DagProtobuf,
+	"cbor":                 DagCBOR,
+	"git-raw":              GitRaw,
+	"eth-block":            EthBlock,
+	"eth-block-list":       EthBlockList,
+	"eth-tx-trie":          EthTxTrie,
+	"eth-tx":               EthTx,
+	"eth-tx-receipt-trie":  EthTxReceiptTrie,
+	"eth-tx-receipt":       EthTxReceipt,
+	"eth-state-trie":       EthStateTrie,
+	"eth-account-snapshot": EthAccountSnapshot,
+	"eth-storage-trie":     EthStorageTrie,
+	"bitcoin-block":        BitcoinBlock,
+	"bitcoin-tx":           BitcoinTx,
+	"zcash-block":          ZcashBlock,
+	"zcash-tx":             ZcashTx,
+	"decred-block":         DecredBlock,
+	"decred-tx":            DecredTx,
+	"dash-block":           DashBlock,
+	"dash-tx":              DashTx,
+}
+
+// CodecToStr maps the numeric codec to its name
+var CodecToStr = map[uint64]string{
+	Raw:                "raw",
+	DagProtobuf:        "protobuf",
+	DagCBOR:            "cbor",
+	GitRaw:             "git-raw",
+	EthBlock:           "eth-block",
+	EthBlockList:       "eth-block-list",
+	EthTxTrie:          "eth-tx-trie",
+	EthTx:              "eth-tx",
+	EthTxReceiptTrie:   "eth-tx-receipt-trie",
+	EthTxReceipt:       "eth-tx-receipt",
+	EthStateTrie:       "eth-state-trie",
+	EthAccountSnapshot: "eth-account-snapshot",
+	EthStorageTrie:     "eth-storage-trie",
+	BitcoinBlock:       "bitcoin-block",
+	BitcoinTx:          "bitcoin-tx",
+	ZcashBlock:         "zcash-block",
+	ZcashTx:            "zcash-tx",
+	DecredBlock:        "decred-block",
+	DecredTx:           "decred-tx",
+	DashBlock:          "dash-block",
+	DashTx:             "dash-tx",
+}
+
+// NewCidV0 returns a Cid-wrapped multihash.
+// They exist to allow IPFS to work with Cids while keeping
+// compatibility with the plain-multihash format used used in IPFS.
+// NewCidV1 should be used preferentially.
+func NewCidV0(mhash mh.Multihash) Cid {
+	// Need to make sure hash is valid for CidV0 otherwise we will
+	// incorrectly detect it as CidV1 in the Version() method
+	dec, err := mh.Decode(mhash)
+	if err != nil {
+		panic(err)
+	}
+	if dec.Code != mh.SHA2_256 || dec.Length != 32 {
+		panic("invalid hash for cidv0")
+	}
+	return Cid{string(mhash)}
+}
+
+// NewCidV1 returns a new Cid using the given multicodec-packed
+// content type.
+func NewCidV1(codecType uint64, mhash mh.Multihash) Cid {
+	hashlen := len(mhash)
+	// two 8 bytes (max) numbers plus hash
+	buf := make([]byte, 2*binary.MaxVarintLen64+hashlen)
+	n := binary.PutUvarint(buf, 1)
+	n += binary.PutUvarint(buf[n:], codecType)
+	cn := copy(buf[n:], mhash)
+	if cn != hashlen {
+		panic("copy hash length is inconsistent")
+	}
+
+	return Cid{string(buf[:n+hashlen])}
+}
+
+var _ encoding.BinaryMarshaler = Cid{}
+var _ encoding.BinaryUnmarshaler = (*Cid)(nil)
+var _ encoding.TextMarshaler = Cid{}
+var _ encoding.TextUnmarshaler = (*Cid)(nil)
+
+// Cid represents a self-describing content addressed
+// identifier. It is formed by a Version, a Codec (which indicates
+// a multicodec-packed content type) and a Multihash.
+type Cid struct{ str string }
+
+// Undef can be used to represent a nil or undefined Cid, using Cid{}
+// directly is also acceptable.
+var Undef = Cid{}
+
+// Defined returns true if a Cid is defined
+// Calling any other methods on an undefined Cid will result in
+// undefined behavior.
+func (c Cid) Defined() bool {
+	return c.str != ""
+}
+
+// Parse is a short-hand function to perform Decode, Cast etc... on
+// a generic interface{} type.
+func Parse(v interface{}) (Cid, error) {
+	switch v2 := v.(type) {
+	case string:
+		if strings.Contains(v2, "/ipfs/") {
+			return Decode(strings.Split(v2, "/ipfs/")[1])
+		}
+		return Decode(v2)
+	case []byte:
+		return Cast(v2)
+	case mh.Multihash:
+		return NewCidV0(v2), nil
+	case Cid:
+		return v2, nil
+	default:
+		return Undef, fmt.Errorf("can't parse %+v as Cid", v2)
+	}
+}
+
+// Decode parses a Cid-encoded string and returns a Cid object.
+// For CidV1, a Cid-encoded string is primarily a multibase string:
+//
+//     <multibase-type-code><base-encoded-string>
+//
+// The base-encoded string represents a:
+//
+// <version><codec-type><multihash>
+//
+// Decode will also detect and parse CidV0 strings. Strings
+// starting with "Qm" are considered CidV0 and treated directly
+// as B58-encoded multihashes.
+func Decode(v string) (Cid, error) {
+	if len(v) < 2 {
+		return Undef, ErrCidTooShort
+	}
+
+	if len(v) == 46 && v[:2] == "Qm" {
+		hash, err := mh.FromB58String(v)
+		if err != nil {
+			return Undef, err
+		}
+
+		return NewCidV0(hash), nil
+	}
+
+	_, data, err := mbase.Decode(v)
+	if err != nil {
+		return Undef, err
+	}
+
+	return Cast(data)
+}
+
+// Extract the encoding from a Cid.  If Decode on the same string did
+// not return an error neither will this function.
+func ExtractEncoding(v string) (mbase.Encoding, error) {
+	if len(v) < 2 {
+		return -1, ErrCidTooShort
+	}
+
+	if len(v) == 46 && v[:2] == "Qm" {
+		return mbase.Base58BTC, nil
+	}
+
+	encoding := mbase.Encoding(v[0])
+
+	// check encoding is valid
+	_, err := mbase.NewEncoder(encoding)
+	if err != nil {
+		return -1, err
+	}
+
+	return encoding, nil
+}
+
+func uvError(read int) error {
+	switch {
+	case read == 0:
+		return ErrVarintBuffSmall
+	case read < 0:
+		return ErrVarintTooBig
+	default:
+		return nil
+	}
+}
+
+// Cast takes a Cid data slice, parses it and returns a Cid.
+// For CidV1, the data buffer is in the form:
+//
+//     <version><codec-type><multihash>
+//
+// CidV0 are also supported. In particular, data buffers starting
+// with length 34 bytes, which starts with bytes [18,32...] are considered
+// binary multihashes.
+//
+// Please use decode when parsing a regular Cid string, as Cast does not
+// expect multibase-encoded data. Cast accepts the output of Cid.Bytes().
+func Cast(data []byte) (Cid, error) {
+	if len(data) == 34 && data[0] == 18 && data[1] == 32 {
+		h, err := mh.Cast(data)
+		if err != nil {
+			return Undef, err
+		}
+
+		return NewCidV0(h), nil
+	}
+
+	vers, n := binary.Uvarint(data)
+	if err := uvError(n); err != nil {
+		return Undef, err
+	}
+
+	if vers != 1 {
+		return Undef, fmt.Errorf("expected 1 as the cid version number, got: %d", vers)
+	}
+
+	_, cn := binary.Uvarint(data[n:])
+	if err := uvError(cn); err != nil {
+		return Undef, err
+	}
+
+	rest := data[n+cn:]
+	h, err := mh.Cast(rest)
+	if err != nil {
+		return Undef, err
+	}
+
+	return Cid{string(data[0 : n+cn+len(h)])}, nil
+}
+
+// UnmarshalBinary is equivalent to Cast(). It implements the
+// encoding.BinaryUnmarshaler interface.
+func (c *Cid) UnmarshalBinary(data []byte) error {
+	casted, err := Cast(data)
+	if err != nil {
+		return err
+	}
+	c.str = casted.str
+	return nil
+}
+
+// UnmarshalText is equivalent to Decode(). It implements the
+// encoding.TextUnmarshaler interface.
+func (c *Cid) UnmarshalText(text []byte) error {
+	decodedCid, err := Decode(string(text))
+	if err != nil {
+		return err
+	}
+	c.str = decodedCid.str
+	return nil
+}
+
+// Version returns the Cid version.
+func (c Cid) Version() uint64 {
+	if len(c.str) == 34 && c.str[0] == 18 && c.str[1] == 32 {
+		return 0
+	}
+	return 1
+}
+
+// Type returns the multicodec-packed content type of a Cid.
+func (c Cid) Type() uint64 {
+	if c.Version() == 0 {
+		return DagProtobuf
+	}
+	_, n := uvarint(c.str)
+	codec, _ := uvarint(c.str[n:])
+	return codec
+}
+
+// String returns the default string representation of a
+// Cid. Currently, Base58 is used as the encoding for the
+// multibase string.
+func (c Cid) String() string {
+	switch c.Version() {
+	case 0:
+		return c.Hash().B58String()
+	case 1:
+		mbstr, err := mbase.Encode(mbase.Base58BTC, c.Bytes())
+		if err != nil {
+			panic("should not error with hardcoded mbase: " + err.Error())
+		}
+
+		return mbstr
+	default:
+		panic("not possible to reach this point")
+	}
+}
+
+// String returns the string representation of a Cid
+// encoded is selected base
+func (c Cid) StringOfBase(base mbase.Encoding) (string, error) {
+	switch c.Version() {
+	case 0:
+		if base != mbase.Base58BTC {
+			return "", ErrInvalidEncoding
+		}
+		return c.Hash().B58String(), nil
+	case 1:
+		return mbase.Encode(base, c.Bytes())
+	default:
+		panic("not possible to reach this point")
+	}
+}
+
+// Encode return the string representation of a Cid in a given base
+// when applicable.  Version 0 Cid's are always in Base58 as they do
+// not take a multibase prefix.
+func (c Cid) Encode(base mbase.Encoder) string {
+	switch c.Version() {
+	case 0:
+		return c.Hash().B58String()
+	case 1:
+		return base.Encode(c.Bytes())
+	default:
+		panic("not possible to reach this point")
+	}
+}
+
+// Hash returns the multihash contained by a Cid.
+func (c Cid) Hash() mh.Multihash {
+	bytes := c.Bytes()
+
+	if c.Version() == 0 {
+		return mh.Multihash(bytes)
+	}
+
+	// skip version length
+	_, n1 := binary.Uvarint(bytes)
+	// skip codec length
+	_, n2 := binary.Uvarint(bytes[n1:])
+
+	return mh.Multihash(bytes[n1+n2:])
+}
+
+// Bytes returns the byte representation of a Cid.
+// The output of bytes can be parsed back into a Cid
+// with Cast().
+func (c Cid) Bytes() []byte {
+	return []byte(c.str)
+}
+
+// MarshalBinary is equivalent to Bytes(). It implements the
+// encoding.BinaryMarshaler interface.
+func (c Cid) MarshalBinary() ([]byte, error) {
+	return c.Bytes(), nil
+}
+
+// MarshalText is equivalent to String(). It implements the
+// encoding.TextMarshaler interface.
+func (c Cid) MarshalText() ([]byte, error) {
+	return []byte(c.String()), nil
+}
+
+// Equals checks that two Cids are the same.
+// In order for two Cids to be considered equal, the
+// Version, the Codec and the Multihash must match.
+func (c Cid) Equals(o Cid) bool {
+	return c == o
+}
+
+// UnmarshalJSON parses the JSON representation of a Cid.
+func (c *Cid) UnmarshalJSON(b []byte) error {
+	if len(b) < 2 {
+		return fmt.Errorf("invalid cid json blob")
+	}
+	obj := struct {
+		CidTarget string `json:"/"`
+	}{}
+	objptr := &obj
+	err := json.Unmarshal(b, &objptr)
+	if err != nil {
+		return err
+	}
+	if objptr == nil {
+		*c = Cid{}
+		return nil
+	}
+
+	if obj.CidTarget == "" {
+		return fmt.Errorf("cid was incorrectly formatted")
+	}
+
+	out, err := Decode(obj.CidTarget)
+	if err != nil {
+		return err
+	}
+
+	*c = out
+
+	return nil
+}
+
+// MarshalJSON procudes a JSON representation of a Cid, which looks as follows:
+//
+//    { "/": "<cid-string>" }
+//
+// Note that this formatting comes from the IPLD specification
+// (https://github.com/ipld/specs/tree/master/ipld)
+func (c Cid) MarshalJSON() ([]byte, error) {
+	if !c.Defined() {
+		return []byte("null"), nil
+	}
+	return []byte(fmt.Sprintf("{\"/\":\"%s\"}", c.String())), nil
+}
+
+// KeyString returns the binary representation of the Cid as a string
+func (c Cid) KeyString() string {
+	return c.str
+}
+
+// Loggable returns a Loggable (as defined by
+// https://godoc.org/github.com/ipfs/go-log).
+func (c Cid) Loggable() map[string]interface{} {
+	return map[string]interface{}{
+		"cid": c,
+	}
+}
+
+// Prefix builds and returns a Prefix out of a Cid.
+func (c Cid) Prefix() Prefix {
+	dec, _ := mh.Decode(c.Hash()) // assuming we got a valid multiaddr, this will not error
+	return Prefix{
+		MhType:   dec.Code,
+		MhLength: dec.Length,
+		Version:  c.Version(),
+		Codec:    c.Type(),
+	}
+}
+
+// Prefix represents all the metadata of a Cid,
+// that is, the Version, the Codec, the Multihash type
+// and the Multihash length. It does not contains
+// any actual content information.
+// NOTE: The use -1 in MhLength to mean default length is deprecated,
+//   use the V0Builder or V1Builder structures instead
+type Prefix struct {
+	Version  uint64
+	Codec    uint64
+	MhType   uint64
+	MhLength int
+}
+
+// Sum uses the information in a prefix to perform a multihash.Sum()
+// and return a newly constructed Cid with the resulting multihash.
+func (p Prefix) Sum(data []byte) (Cid, error) {
+	length := p.MhLength
+	if p.MhType == mh.ID {
+		length = -1
+	}
+
+	hash, err := mh.Sum(data, p.MhType, length)
+	if err != nil {
+		return Undef, err
+	}
+
+	switch p.Version {
+	case 0:
+		return NewCidV0(hash), nil
+	case 1:
+		return NewCidV1(p.Codec, hash), nil
+	default:
+		return Undef, fmt.Errorf("invalid cid version")
+	}
+}
+
+// Bytes returns a byte representation of a Prefix. It looks like:
+//
+//     <version><codec><mh-type><mh-length>
+func (p Prefix) Bytes() []byte {
+	buf := make([]byte, 4*binary.MaxVarintLen64)
+	n := binary.PutUvarint(buf, p.Version)
+	n += binary.PutUvarint(buf[n:], p.Codec)
+	n += binary.PutUvarint(buf[n:], uint64(p.MhType))
+	n += binary.PutUvarint(buf[n:], uint64(p.MhLength))
+	return buf[:n]
+}
+
+// PrefixFromBytes parses a Prefix-byte representation onto a
+// Prefix.
+func PrefixFromBytes(buf []byte) (Prefix, error) {
+	r := bytes.NewReader(buf)
+	vers, err := binary.ReadUvarint(r)
+	if err != nil {
+		return Prefix{}, err
+	}
+
+	codec, err := binary.ReadUvarint(r)
+	if err != nil {
+		return Prefix{}, err
+	}
+
+	mhtype, err := binary.ReadUvarint(r)
+	if err != nil {
+		return Prefix{}, err
+	}
+
+	mhlen, err := binary.ReadUvarint(r)
+	if err != nil {
+		return Prefix{}, err
+	}
+
+	return Prefix{
+		Version:  vers,
+		Codec:    codec,
+		MhType:   mhtype,
+		MhLength: int(mhlen),
+	}, nil
+}

vendor/github.com/ipfs/go-cid/cid_fuzz.go

@@ -0,0 +1,37 @@
+// +build gofuzz
+
+package cid
+
+func Fuzz(data []byte) int {
+	cid, err := Cast(data)
+
+	if err != nil {
+		return 0
+	}
+
+	_ = cid.Bytes()
+	_ = cid.String()
+	p := cid.Prefix()
+	_ = p.Bytes()
+
+	if !cid.Equals(cid) {
+		panic("inequality")
+	}
+
+	// json loop
+	json, err := cid.MarshalJSON()
+	if err != nil {
+		panic(err.Error())
+	}
+	cid2 := Cid{}
+	err = cid2.UnmarshalJSON(json)
+	if err != nil {
+		panic(err.Error())
+	}
+
+	if !cid.Equals(cid2) {
+		panic("json loop not equal")
+	}
+
+	return 1
+}

vendor/github.com/ipfs/go-cid/codecov.yml

@@ -0,0 +1,3 @@
+coverage:
+  range: "50...100"
+comment: off

vendor/github.com/ipfs/go-cid/deprecated.go

@@ -0,0 +1,28 @@
+package cid
+
+import (
+	mh "github.com/multiformats/go-multihash"
+)
+
+// NewPrefixV0 returns a CIDv0 prefix with the specified multihash type.
+// DEPRECATED: Use V0Builder
+func NewPrefixV0(mhType uint64) Prefix {
+	return Prefix{
+		MhType:   mhType,
+		MhLength: mh.DefaultLengths[mhType],
+		Version:  0,
+		Codec:    DagProtobuf,
+	}
+}
+
+// NewPrefixV1 returns a CIDv1 prefix with the specified codec and multihash
+// type.
+// DEPRECATED: Use V1Builder
+func NewPrefixV1(codecType uint64, mhType uint64) Prefix {
+	return Prefix{
+		MhType:   mhType,
+		MhLength: mh.DefaultLengths[mhType],
+		Version:  1,
+		Codec:    codecType,
+	}
+}

vendor/github.com/ipfs/go-cid/go.mod

@@ -0,0 +1,6 @@
+module github.com/ipfs/go-cid
+
+require (
+	github.com/multiformats/go-multibase v0.0.1
+	github.com/multiformats/go-multihash v0.0.1
+)

vendor/github.com/ipfs/go-cid/go.sum

@@ -0,0 +1,20 @@
+github.com/gxed/hashland/keccakpg v0.0.1 h1:wrk3uMNaMxbXiHibbPO4S0ymqJMm41WiudyFSs7UnsU=
+github.com/gxed/hashland/keccakpg v0.0.1/go.mod h1:kRzw3HkwxFU1mpmPP8v1WyQzwdGfmKFJ6tItnhQ67kU=
+github.com/gxed/hashland/murmur3 v0.0.1 h1:SheiaIt0sda5K+8FLz952/1iWS9zrnKsEJaOJu4ZbSc=
+github.com/gxed/hashland/murmur3 v0.0.1/go.mod h1:KjXop02n4/ckmZSnY2+HKcLud/tcmvhST0bie/0lS48=
+github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1 h1:lYpkrQH5ajf0OXOcUbGjvZxxijuBwbbmlSxLiuofa+g=
+github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1/go.mod h1:pD8RvIylQ358TN4wwqatJ8rNavkEINozVn9DtGI3dfQ=
+github.com/minio/sha256-simd v0.0.0-20190131020904-2d45a736cd16 h1:5W7KhL8HVF3XCFOweFD3BNESdnO8ewyYTFT2R+/b8FQ=
+github.com/minio/sha256-simd v0.0.0-20190131020904-2d45a736cd16/go.mod h1:2FMWW+8GMoPweT6+pI63m9YE3Lmw4J71hV56Chs1E/U=
+github.com/mr-tron/base58 v1.1.0 h1:Y51FGVJ91WBqCEabAi5OPUz38eAx8DakuAm5svLcsfQ=
+github.com/mr-tron/base58 v1.1.0/go.mod h1:xcD2VGqlgYjBdcBLw+TuYLr8afG+Hj8g2eTVqeSzSU8=
+github.com/multiformats/go-base32 v0.0.3 h1:tw5+NhuwaOjJCC5Pp82QuXbrmLzWg7uxlMFp8Nq/kkI=
+github.com/multiformats/go-base32 v0.0.3/go.mod h1:pLiuGC8y0QR3Ue4Zug5UzK9LjgbkL8NSQj0zQ5Nz/AA=
+github.com/multiformats/go-multibase v0.0.1 h1:PN9/v21eLywrFWdFNsFKaU04kLJzuYzmrJR+ubhT9qA=
+github.com/multiformats/go-multibase v0.0.1/go.mod h1:bja2MqRZ3ggyXtZSEDKpl0uO/gviWFaSteVbWT51qgs=
+github.com/multiformats/go-multihash v0.0.1 h1:HHwN1K12I+XllBCrqKnhX949Orn4oawPkegHMu2vDqQ=
+github.com/multiformats/go-multihash v0.0.1/go.mod h1:w/5tugSrLEbWqlcgJabL3oHFKTwfvkofsjW2Qa1ct4U=
+golang.org/x/crypto v0.0.0-20190211182817-74369b46fc67 h1:ng3VDlRp5/DHpSWl02R4rM9I+8M2rhmsuLwAMmkLQWE=
+golang.org/x/crypto v0.0.0-20190211182817-74369b46fc67/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/sys v0.0.0-20190219092855-153ac476189d h1:Z0Ahzd7HltpJtjAHHxX8QFP3j1yYgiuvjbjRzDj/KH0=
+golang.org/x/sys v0.0.0-20190219092855-153ac476189d/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=

vendor/github.com/ipfs/go-cid/package.json

@@ -0,0 +1,30 @@
+{
+  "author": "whyrusleeping",
+  "bugs": {
+    "url": "https://github.com/ipfs/go-cid"
+  },
+  "gx": {
+    "dvcsimport": "github.com/ipfs/go-cid"
+  },
+  "gxDependencies": [
+    {
+      "author": "whyrusleeping",
+      "hash": "QmerPMzPk1mJVowm8KgmoknWa4yCYvvugMPsgWmDNUvDLW",
+      "name": "go-multihash",
+      "version": "1.0.9"
+    },
+    {
+      "author": "whyrusleeping",
+      "hash": "QmekxXDhCxCJRNuzmHreuaT3BsuJcsjcXWNrtV9C8DRHtd",
+      "name": "go-multibase",
+      "version": "0.3.0"
+    }
+  ],
+  "gxVersion": "0.8.0",
+  "language": "go",
+  "license": "MIT",
+  "name": "go-cid",
+  "releaseCmd": "git commit -a -m \"gx publish $VERSION\"",
+  "version": "0.9.3"
+}
+

vendor/github.com/ipfs/go-cid/set.go

@@ -0,0 +1,65 @@
+package cid
+
+// Set is a implementation of a set of Cids, that is, a structure
+// to which holds a single copy of every Cids that is added to it.
+type Set struct {
+	set map[Cid]struct{}
+}
+
+// NewSet initializes and returns a new Set.
+func NewSet() *Set {
+	return &Set{set: make(map[Cid]struct{})}
+}
+
+// Add puts a Cid in the Set.
+func (s *Set) Add(c Cid) {
+	s.set[c] = struct{}{}
+}
+
+// Has returns if the Set contains a given Cid.
+func (s *Set) Has(c Cid) bool {
+	_, ok := s.set[c]
+	return ok
+}
+
+// Remove deletes a Cid from the Set.
+func (s *Set) Remove(c Cid) {
+	delete(s.set, c)
+}
+
+// Len returns how many elements the Set has.
+func (s *Set) Len() int {
+	return len(s.set)
+}
+
+// Keys returns the Cids in the set.
+func (s *Set) Keys() []Cid {
+	out := make([]Cid, 0, len(s.set))
+	for k := range s.set {
+		out = append(out, k)
+	}
+	return out
+}
+
+// Visit adds a Cid to the set only if it is
+// not in it already.
+func (s *Set) Visit(c Cid) bool {
+	if !s.Has(c) {
+		s.Add(c)
+		return true
+	}
+
+	return false
+}
+
+// ForEach allows to run a custom function on each
+// Cid in the set.
+func (s *Set) ForEach(f func(c Cid) error) error {
+	for c := range s.set {
+		err := f(c)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

vendor/github.com/ipfs/go-cid/varint.go

@@ -0,0 +1,34 @@
+package cid
+
+// Version of varint function that work with a string rather than
+// []byte to avoid unnecessary allocation
+
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license as given at https://golang.org/LICENSE
+
+// uvarint decodes a uint64 from buf and returns that value and the
+// number of characters read (> 0). If an error occurred, the value is 0
+// and the number of bytes n is <= 0 meaning:
+//
+// 	n == 0: buf too small
+// 	n  < 0: value larger than 64 bits (overflow)
+// 	        and -n is the number of bytes read
+//
+func uvarint(buf string) (uint64, int) {
+	var x uint64
+	var s uint
+	// we have a binary string so we can't use a range loope
+	for i := 0; i < len(buf); i++ {
+		b := buf[i]
+		if b < 0x80 {
+			if i > 9 || i == 9 && b > 1 {
+				return 0, -(i + 1) // overflow
+			}
+			return x | uint64(b)<<s, i + 1
+		}
+		x |= uint64(b&0x7f) << s
+		s += 7
+	}
+	return 0, 0
+}

vendor/github.com/minio/blake2b-simd/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

vendor/github.com/minio/blake2b-simd/README.md

@@ -0,0 +1,144 @@
+BLAKE2b-SIMD
+============
+
+Pure Go implementation of BLAKE2b using SIMD optimizations.
+
+Introduction
+------------
+
+This package was initially based on the pure go [BLAKE2b](https://github.com/dchest/blake2b) implementation of Dmitry Chestnykh and merged with the (`cgo` dependent) AVX optimized [BLAKE2](https://github.com/codahale/blake2) implementation (which in turn is based on the [official implementation](https://github.com/BLAKE2/BLAKE2). It does so by using [Go's Assembler](https://golang.org/doc/asm) for amd64 architectures with a golang only fallback for other architectures.
+
+In addition to AVX there is also support for AVX2 as well as SSE. Best performance is obtained with AVX2 which gives roughly a **4X** performance increase approaching hashing speeds of **1GB/sec** on a single core.
+
+Benchmarks
+----------
+
+This is a summary of the performance improvements. Full details are shown below.
+
+| Technology |  128K |
+| ---------- |:-----:|
+| AVX2       | 3.94x |
+| AVX        | 3.28x |
+| SSE        | 2.85x |
+
+asm2plan9s
+----------
+
+In order to be able to work more easily with AVX2/AVX instructions, a separate tool was developed to convert AVX2/AVX instructions into the corresponding BYTE sequence as accepted by Go assembly. See [asm2plan9s](https://github.com/minio/asm2plan9s) for more information.
+
+bt2sum
+------
+
+[bt2sum](https://github.com/s3git/bt2sum) is a utility that takes advantages of the BLAKE2b SIMD optimizations to compute check sums using the BLAKE2 Tree hashing mode in so called 'unlimited fanout' mode.
+
+Technical details
+-----------------
+
+BLAKE2b is a hashing algorithm that operates on 64-bit integer values. The AVX2 version uses the 256-bit wide YMM registers in order to essentially process four operations in parallel. AVX and SSE operate on 128-bit values simultaneously (two operations in parallel). Below are excerpts from `compressAvx2_amd64.s`, `compressAvx_amd64.s`, and `compress_generic.go` respectively.
+
+```
+    VPADDQ  YMM0,YMM0,YMM1   /* v0 += v4, v1 += v5, v2 += v6, v3 += v7 */
+```
+
+```
+    VPADDQ  XMM0,XMM0,XMM2   /* v0 += v4, v1 += v5 */
+    VPADDQ  XMM1,XMM1,XMM3   /* v2 += v6, v3 += v7 */
+```
+
+```
+    v0 += v4
+    v1 += v5
+    v2 += v6
+    v3 += v7
+```
+
+Detailed benchmarks
+-------------------
+
+Example performance metrics were generated on  Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz - 6 physical cores, 12 logical cores running Ubuntu GNU/Linux with kernel version 4.4.0-24-generic (vanilla with no optimizations).
+
+### AVX2
+
+```
+$ benchcmp go.txt avx2.txt
+benchmark                old ns/op     new ns/op     delta
+BenchmarkHash64-12       1481          849           -42.67%
+BenchmarkHash128-12      1428          746           -47.76%
+BenchmarkHash1K-12       6379          2227          -65.09%
+BenchmarkHash8K-12       37219         11714         -68.53%
+BenchmarkHash32K-12      140716        35935         -74.46%
+BenchmarkHash128K-12     561656        142634        -74.60%
+
+benchmark                old MB/s     new MB/s     speedup
+BenchmarkHash64-12       43.20        75.37        1.74x
+BenchmarkHash128-12      89.64        171.35       1.91x
+BenchmarkHash1K-12       160.52       459.69       2.86x
+BenchmarkHash8K-12       220.10       699.32       3.18x
+BenchmarkHash32K-12      232.87       911.85       3.92x
+BenchmarkHash128K-12     233.37       918.93       3.94x
+```
+
+### AVX2: Comparison to other hashing techniques
+
+```
+$ go test -bench=Comparison
+BenchmarkComparisonMD5-12    	    1000	   1726121 ns/op	 607.48 MB/s
+BenchmarkComparisonSHA1-12   	     500	   2005164 ns/op	 522.94 MB/s
+BenchmarkComparisonSHA256-12 	     300	   5531036 ns/op	 189.58 MB/s
+BenchmarkComparisonSHA512-12 	     500	   3423030 ns/op	 306.33 MB/s
+BenchmarkComparisonBlake2B-12	    1000	   1232690 ns/op	 850.64 MB/s
+```
+
+Benchmarks below were generated on a MacBook Pro with a 2.7 GHz Intel Core i7.
+
+### AVX
+
+```
+$ benchcmp go.txt  avx.txt 
+benchmark               old ns/op     new ns/op     delta
+BenchmarkHash64-8       813           458           -43.67%
+BenchmarkHash128-8      766           401           -47.65%
+BenchmarkHash1K-8       4881          1763          -63.88%
+BenchmarkHash8K-8       36127         12273         -66.03%
+BenchmarkHash32K-8      140582        43155         -69.30%
+BenchmarkHash128K-8     567850        173246        -69.49%
+
+benchmark               old MB/s     new MB/s     speedup
+BenchmarkHash64-8       78.63        139.57       1.78x
+BenchmarkHash128-8      166.98       318.73       1.91x
+BenchmarkHash1K-8       209.76       580.68       2.77x
+BenchmarkHash8K-8       226.76       667.46       2.94x
+BenchmarkHash32K-8      233.09       759.29       3.26x
+BenchmarkHash128K-8     230.82       756.56       3.28x
+```
+
+### SSE
+
+```
+$ benchcmp go.txt sse.txt 
+benchmark               old ns/op     new ns/op     delta
+BenchmarkHash64-8       813           478           -41.21%
+BenchmarkHash128-8      766           411           -46.34%
+BenchmarkHash1K-8       4881          1870          -61.69%
+BenchmarkHash8K-8       36127         12427         -65.60%
+BenchmarkHash32K-8      140582        49512         -64.78%
+BenchmarkHash128K-8     567850        199040        -64.95%
+
+benchmark               old MB/s     new MB/s     speedup
+BenchmarkHash64-8       78.63        133.78       1.70x
+BenchmarkHash128-8      166.98       311.23       1.86x
+BenchmarkHash1K-8       209.76       547.37       2.61x
+BenchmarkHash8K-8       226.76       659.20       2.91x
+BenchmarkHash32K-8      233.09       661.81       2.84x
+BenchmarkHash128K-8     230.82       658.52       2.85x
+```
+
+License
+-------
+
+Released under the Apache License v2.0. You can find the complete text in the file LICENSE.
+
+Contributing
+------------
+
+Contributions are welcome, please send PRs for any enhancements.

vendor/github.com/minio/blake2b-simd/appveyor.yml

@@ -0,0 +1,32 @@
+# version format
+version: "{build}"
+
+# Operating system (build VM template)
+os: Windows Server 2012 R2
+
+# Platform.
+platform: x64
+
+clone_folder: c:\gopath\src\github.com\minio\blake2b-simd
+
+# environment variables
+environment:
+  GOPATH: c:\gopath
+  GO15VENDOREXPERIMENT: 1
+
+# scripts that run after cloning repository
+install:
+  - set PATH=%GOPATH%\bin;c:\go\bin;%PATH%
+  - go version
+  - go env
+
+# to run your custom scripts instead of automatic MSBuild
+build_script:
+  - go test .
+  - go test -race .
+
+# to disable automatic tests
+test: off
+
+# to disable deployment
+deploy: off

vendor/github.com/minio/blake2b-simd/blake2b.go

@@ -0,0 +1,301 @@
+// Written in 2012 by Dmitry Chestnykh.
+//
+// To the extent possible under law, the author have dedicated all copyright
+// and related and neighboring rights to this software to the public domain
+// worldwide. This software is distributed without any warranty.
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+// Package blake2b implements BLAKE2b cryptographic hash function.
+package blake2b
+
+import (
+	"encoding/binary"
+	"errors"
+	"hash"
+)
+
+const (
+	BlockSize  = 128 // block size of algorithm
+	Size       = 64  // maximum digest size
+	SaltSize   = 16  // maximum salt size
+	PersonSize = 16  // maximum personalization string size
+	KeySize    = 64  // maximum size of key
+)
+
+type digest struct {
+	h  [8]uint64       // current chain value
+	t  [2]uint64       // message bytes counter
+	f  [2]uint64       // finalization flags
+	x  [BlockSize]byte // buffer for data not yet compressed
+	nx int             // number of bytes in buffer
+
+	ih         [8]uint64       // initial chain value (after config)
+	paddedKey  [BlockSize]byte // copy of key, padded with zeros
+	isKeyed    bool            // indicates whether hash was keyed
+	size       uint8           // digest size in bytes
+	isLastNode bool            // indicates processing of the last node in tree hashing
+}
+
+// Initialization values.
+var iv = [8]uint64{
+	0x6a09e667f3bcc908, 0xbb67ae8584caa73b,
+	0x3c6ef372fe94f82b, 0xa54ff53a5f1d36f1,
+	0x510e527fade682d1, 0x9b05688c2b3e6c1f,
+	0x1f83d9abfb41bd6b, 0x5be0cd19137e2179,
+}
+
+// Config is used to configure hash function parameters and keying.
+// All parameters are optional.
+type Config struct {
+	Size   uint8  // digest size (if zero, default size of 64 bytes is used)
+	Key    []byte // key for prefix-MAC
+	Salt   []byte // salt (if < 16 bytes, padded with zeros)
+	Person []byte // personalization (if < 16 bytes, padded with zeros)
+	Tree   *Tree  // parameters for tree hashing
+}
+
+// Tree represents parameters for tree hashing.
+type Tree struct {
+	Fanout        uint8  // fanout
+	MaxDepth      uint8  // maximal depth
+	LeafSize      uint32 // leaf maximal byte length (0 for unlimited)
+	NodeOffset    uint64 // node offset (0 for first, leftmost or leaf)
+	NodeDepth     uint8  // node depth (0 for leaves)
+	InnerHashSize uint8  // inner hash byte length
+	IsLastNode    bool   // indicates processing of the last node of layer
+}
+
+var (
+	defaultConfig = &Config{Size: Size}
+	config256     = &Config{Size: 32}
+)
+
+func verifyConfig(c *Config) error {
+	if c.Size > Size {
+		return errors.New("digest size is too large")
+	}
+	if len(c.Key) > KeySize {
+		return errors.New("key is too large")
+	}
+	if len(c.Salt) > SaltSize {
+		// Smaller salt is okay: it will be padded with zeros.
+		return errors.New("salt is too large")
+	}
+	if len(c.Person) > PersonSize {
+		// Smaller personalization is okay: it will be padded with zeros.
+		return errors.New("personalization is too large")
+	}
+	if c.Tree != nil {
+		if c.Tree.Fanout == 1 {
+			return errors.New("fanout of 1 is not allowed in tree mode")
+		}
+		if c.Tree.MaxDepth < 2 {
+			return errors.New("incorrect tree depth")
+		}
+		if c.Tree.InnerHashSize < 1 || c.Tree.InnerHashSize > Size {
+			return errors.New("incorrect tree inner hash size")
+		}
+	}
+	return nil
+}
+
+// New returns a new hash.Hash configured with the given Config.
+// Config can be nil, in which case the default one is used, calculating 64-byte digest.
+// Returns non-nil error if Config contains invalid parameters.
+func New(c *Config) (hash.Hash, error) {
+	if c == nil {
+		c = defaultConfig
+	} else {
+		if c.Size == 0 {
+			// Set default size if it's zero.
+			c.Size = Size
+		}
+		if err := verifyConfig(c); err != nil {
+			return nil, err
+		}
+	}
+	d := new(digest)
+	d.initialize(c)
+	return d, nil
+}
+
+// initialize initializes digest with the given
+// config, which must be non-nil and verified.
+func (d *digest) initialize(c *Config) {
+	// Create parameter block.
+	var p [BlockSize]byte
+	p[0] = c.Size
+	p[1] = uint8(len(c.Key))
+	if c.Salt != nil {
+		copy(p[32:], c.Salt)
+	}
+	if c.Person != nil {
+		copy(p[48:], c.Person)
+	}
+	if c.Tree != nil {
+		p[2] = c.Tree.Fanout
+		p[3] = c.Tree.MaxDepth
+		binary.LittleEndian.PutUint32(p[4:], c.Tree.LeafSize)
+		binary.LittleEndian.PutUint64(p[8:], c.Tree.NodeOffset)
+		p[16] = c.Tree.NodeDepth
+		p[17] = c.Tree.InnerHashSize
+	} else {
+		p[2] = 1
+		p[3] = 1
+	}
+
+	// Initialize.
+	d.size = c.Size
+	for i := 0; i < 8; i++ {
+		d.h[i] = iv[i] ^ binary.LittleEndian.Uint64(p[i*8:])
+	}
+	if c.Tree != nil && c.Tree.IsLastNode {
+		d.isLastNode = true
+	}
+
+	// Process key.
+	if c.Key != nil {
+		copy(d.paddedKey[:], c.Key)
+		d.Write(d.paddedKey[:])
+		d.isKeyed = true
+	}
+	// Save a copy of initialized state.
+	copy(d.ih[:], d.h[:])
+}
+
+// New512 returns a new hash.Hash computing the BLAKE2b 64-byte checksum.
+func New512() hash.Hash {
+	d := new(digest)
+	d.initialize(defaultConfig)
+	return d
+}
+
+// New256 returns a new hash.Hash computing the BLAKE2b 32-byte checksum.
+func New256() hash.Hash {
+	d := new(digest)
+	d.initialize(config256)
+	return d
+}
+
+// NewMAC returns a new hash.Hash computing BLAKE2b prefix-
+// Message Authentication Code of the given size in bytes
+// (up to 64) with the given key (up to 64 bytes in length).
+func NewMAC(outBytes uint8, key []byte) hash.Hash {
+	d, err := New(&Config{Size: outBytes, Key: key})
+	if err != nil {
+		panic(err.Error())
+	}
+	return d
+}
+
+// Reset resets the state of digest to the initial state
+// after configuration and keying.
+func (d *digest) Reset() {
+	copy(d.h[:], d.ih[:])
+	d.t[0] = 0
+	d.t[1] = 0
+	d.f[0] = 0
+	d.f[1] = 0
+	d.nx = 0
+	if d.isKeyed {
+		d.Write(d.paddedKey[:])
+	}
+}
+
+// Size returns the digest size in bytes.
+func (d *digest) Size() int { return int(d.size) }
+
+// BlockSize returns the algorithm block size in bytes.
+func (d *digest) BlockSize() int { return BlockSize }
+
+func (d *digest) Write(p []byte) (nn int, err error) {
+	nn = len(p)
+	left := BlockSize - d.nx
+	if len(p) > left {
+		// Process buffer.
+		copy(d.x[d.nx:], p[:left])
+		p = p[left:]
+		compress(d, d.x[:])
+		d.nx = 0
+	}
+	// Process full blocks except for the last one.
+	if len(p) > BlockSize {
+		n := len(p) &^ (BlockSize - 1)
+		if n == len(p) {
+			n -= BlockSize
+		}
+		compress(d, p[:n])
+		p = p[n:]
+	}
+	// Fill buffer.
+	d.nx += copy(d.x[d.nx:], p)
+	return
+}
+
+// Sum returns the calculated checksum.
+func (d *digest) Sum(in []byte) []byte {
+	// Make a copy of d so that caller can keep writing and summing.
+	d0 := *d
+	hash := d0.checkSum()
+	return append(in, hash[:d0.size]...)
+}
+
+func (d *digest) checkSum() [Size]byte {
+	// Do not create unnecessary copies of the key.
+	if d.isKeyed {
+		for i := 0; i < len(d.paddedKey); i++ {
+			d.paddedKey[i] = 0
+		}
+	}
+
+	dec := BlockSize - uint64(d.nx)
+	if d.t[0] < dec {
+		d.t[1]--
+	}
+	d.t[0] -= dec
+
+	// Pad buffer with zeros.
+	for i := d.nx; i < len(d.x); i++ {
+		d.x[i] = 0
+	}
+	// Set last block flag.
+	d.f[0] = 0xffffffffffffffff
+	if d.isLastNode {
+		d.f[1] = 0xffffffffffffffff
+	}
+	// Compress last block.
+	compress(d, d.x[:])
+
+	var out [Size]byte
+	j := 0
+	for _, s := range d.h[:(d.size-1)/8+1] {
+		out[j+0] = byte(s >> 0)
+		out[j+1] = byte(s >> 8)
+		out[j+2] = byte(s >> 16)
+		out[j+3] = byte(s >> 24)
+		out[j+4] = byte(s >> 32)
+		out[j+5] = byte(s >> 40)
+		out[j+6] = byte(s >> 48)
+		out[j+7] = byte(s >> 56)
+		j += 8
+	}
+	return out
+}
+
+// Sum512 returns a 64-byte BLAKE2b hash of data.
+func Sum512(data []byte) [64]byte {
+	var d digest
+	d.initialize(defaultConfig)
+	d.Write(data)
+	return d.checkSum()
+}
+
+// Sum256 returns a 32-byte BLAKE2b hash of data.
+func Sum256(data []byte) (out [32]byte) {
+	var d digest
+	d.initialize(config256)
+	d.Write(data)
+	sum := d.checkSum()
+	copy(out[:], sum[:32])
+	return
+}

vendor/github.com/minio/blake2b-simd/compressAvx2_amd64.go

@@ -0,0 +1,47 @@
+//+build !noasm
+//+build !appengine
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package blake2b
+
+//go:noescape
+func compressAVX2Loop(p []uint8, in, iv, t, f, shffle, out []uint64)
+
+func compressAVX2(d *digest, p []uint8) {
+	var (
+		in     [8]uint64
+		out    [8]uint64
+		shffle [8]uint64
+	)
+
+	// vector for PSHUFB instruction
+	shffle[0] = 0x0201000706050403
+	shffle[1] = 0x0a09080f0e0d0c0b
+	shffle[2] = 0x0201000706050403
+	shffle[3] = 0x0a09080f0e0d0c0b
+	shffle[4] = 0x0100070605040302
+	shffle[5] = 0x09080f0e0d0c0b0a
+	shffle[6] = 0x0100070605040302
+	shffle[7] = 0x09080f0e0d0c0b0a
+
+	in[0], in[1], in[2], in[3], in[4], in[5], in[6], in[7] = d.h[0], d.h[1], d.h[2], d.h[3], d.h[4], d.h[5], d.h[6], d.h[7]
+
+	compressAVX2Loop(p, in[:], iv[:], d.t[:], d.f[:], shffle[:], out[:])
+
+	d.h[0], d.h[1], d.h[2], d.h[3], d.h[4], d.h[5], d.h[6], d.h[7] = out[0], out[1], out[2], out[3], out[4], out[5], out[6], out[7]
+}

vendor/github.com/minio/blake2b-simd/compressAvx2_amd64.s

@@ -0,0 +1,671 @@
+//+build !noasm !appengine
+
+//
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+//
+// Based on AVX2 implementation from https://github.com/sneves/blake2-avx2/blob/master/blake2b-common.h
+//
+// Use github.com/fwessels/asm2plan9s on this file to assemble instructions to their Plan9 equivalent
+//
+// Assembly code below essentially follows the ROUND macro (see blake2b-round.h) which is defined as:
+//   #define ROUND(r) \
+//     LOAD_MSG_ ##r ##_1(b0, b1); \
+//     G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     LOAD_MSG_ ##r ##_2(b0, b1); \
+//     G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     DIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h); \
+//     LOAD_MSG_ ##r ##_3(b0, b1); \
+//     G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     LOAD_MSG_ ##r ##_4(b0, b1); \
+//     G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     UNDIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h);
+//
+// as well as the go equivalent in https://github.com/dchest/blake2b/blob/master/block.go
+//
+// As in the macro, G1/G2 in the 1st and 2nd half are identical (so literal copy of assembly)
+//
+// Rounds are also the same, except for the loading of the message (and rounds 1 & 11 and
+// rounds 2 & 12 are identical)
+//
+
+#define G1 \
+    \ // G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1);
+    BYTE $0xc5; BYTE $0xfd; BYTE $0xd4; BYTE $0xc4             \ // VPADDQ  YMM0,YMM0,YMM4   /* v0 += m[0], v1 += m[2], v2 += m[4], v3 += m[6] */
+    BYTE $0xc5; BYTE $0xfd; BYTE $0xd4; BYTE $0xc1             \ // VPADDQ  YMM0,YMM0,YMM1   /* v0 += v4, v1 += v5, v2 += v6, v3 += v7 */
+    BYTE $0xc5; BYTE $0xe5; BYTE $0xef; BYTE $0xd8             \ // VPXOR   YMM3,YMM3,YMM0   /* v12 ^= v0, v13 ^= v1, v14 ^= v2, v15 ^= v3 */
+    BYTE $0xc5; BYTE $0xfd; BYTE $0x70; BYTE $0xdb; BYTE $0xb1 \ // VPSHUFD YMM3,YMM3,0xb1   /* v12 = v12<<(64-32) | v12>>32, v13 = */
+    BYTE $0xc5; BYTE $0xed; BYTE $0xd4; BYTE $0xd3             \ // VPADDQ  YMM2,YMM2,YMM3   /* v8 += v12, v9 += v13, v10 += v14, v11 += v15 */
+    BYTE $0xc5; BYTE $0xf5; BYTE $0xef; BYTE $0xca             \ // VPXOR   YMM1,YMM1,YMM2   /* v4 ^= v8, v5 ^= v9, v6 ^= v10, v7 ^= v11 */
+    BYTE $0xc4; BYTE $0xe2; BYTE $0x75; BYTE $0x00; BYTE $0xce   // VPSHUFB YMM1,YMM1,YMM6   /* v4 = v4<<(64-24) | v4>>24, ..., ..., v7 = v7<<(64-24) | v7>>24 */
+
+#define G2 \
+    BYTE $0xc5; BYTE $0xfd; BYTE $0xd4; BYTE $0xc5             \ // VPADDQ  YMM0,YMM0,YMM5   /* v0 += m[1], v1 += m[3], v2 += m[5], v3 += m[7] */
+    BYTE $0xc5; BYTE $0xfd; BYTE $0xd4; BYTE $0xc1             \ // VPADDQ  YMM0,YMM0,YMM1   /* v0 += v4, v1 += v5, v2 += v6, v3 += v7 */
+    BYTE $0xc5; BYTE $0xe5; BYTE $0xef; BYTE $0xd8             \ // VPXOR   YMM3,YMM3,YMM0   /* v12 ^= v0, v13 ^= v1, v14 ^= v2, v15 ^= v3 */
+    BYTE $0xc4; BYTE $0xe2; BYTE $0x65; BYTE $0x00; BYTE $0xdf \ // VPSHUFB YMM3,YMM3,YMM7   /* v12 = v12<<(64-16) | v12>>16, ..., ..., v15 = v15<<(64-16) | v15>>16 */
+    BYTE $0xc5; BYTE $0xed; BYTE $0xd4; BYTE $0xd3             \ // VPADDQ  YMM2,YMM2,YMM3   /* v8 += v12, v9 += v13, v10 += v14, v11 += v15 */
+    BYTE $0xc5; BYTE $0xf5; BYTE $0xef; BYTE $0xca             \ // VPXOR   YMM1,YMM1,YMM2   /* v4 ^= v8, v5 ^= v9, v6 ^= v10, v7 ^= v11 */
+    BYTE $0xc5; BYTE $0x75; BYTE $0xd4; BYTE $0xf9             \ // VPADDQ  YMM15,YMM1,YMM1  /* temp reg = reg*2   */
+    BYTE $0xc5; BYTE $0xf5; BYTE $0x73; BYTE $0xd1; BYTE $0x3f \ // VPSRLQ  YMM1,YMM1,0x3f   /*      reg = reg>>63 */
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x75; BYTE $0xef; BYTE $0xcf   // VPXOR   YMM1,YMM1,YMM15  /* ORed together: v4 = v4<<(64-63) | v4>>63, v5 = v5<<(64-63) | v5>>63 */
+
+#define DIAGONALIZE \
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xdb \ // VPERMQ YMM3, YMM3, 0x93
+                BYTE $0x93                                     \
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xd2 \ // VPERMQ YMM2, YMM2, 0x4e
+                BYTE $0x4e                                     \
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xc9 \ // VPERMQ YMM1, YMM1, 0x39
+                BYTE $0x39                                     \
+    // DO NOT DELETE -- macro delimiter (previous line extended)
+
+#define UNDIAGONALIZE \
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xdb \ // VPERMQ YMM3, YMM3, 0x39
+                BYTE $0x39                                     \
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xd2 \ // VPERMQ YMM2, YMM2, 0x4e
+                BYTE $0x4e                                     \
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xc9 \ // VPERMQ YMM1, YMM1, 0x93
+                BYTE $0x93                                     \
+    // DO NOT DELETE -- macro delimiter (previous line extended)
+
+#define LOAD_SHUFFLE \
+    MOVQ   shffle+120(FP), SI \ // SI: &shuffle
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x6f; BYTE $0x36             \ // VMOVDQU YMM6, [rsi]
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x6f; BYTE $0x7e; BYTE $0x20   // VMOVDQU YMM7, 32[rsi]
+
+// func compressAVX2Loop(compressSSE(p []uint8, in, iv, t, f, shffle, out []uint64)
+TEXT ·compressAVX2Loop(SB), 7, $0
+
+    // REGISTER USE
+    //  Y0 - Y3: v0 - v15
+    //  Y4 - Y5: m[0] - m[7]
+    //  Y6 - Y7: shuffle value
+    //  Y8 - Y9: temp registers
+    // Y10 -Y13: copy of full message
+    //      Y15: temp register
+
+    // Load digest
+    MOVQ   in+24(FP),  SI     // SI: &in
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x6f; BYTE $0x06               // VMOVDQU YMM0, [rsi]
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x6f; BYTE $0x4e; BYTE $0x20   // VMOVDQU YMM1, 32[rsi]
+
+    // Already store digest into &out (so we can reload it later generically)
+    MOVQ  out+144(FP), SI     // SI: &out
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x7f; BYTE $0x06               // VMOVDQU [rsi], YMM0
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x7f; BYTE $0x4e; BYTE $0x20   // VMOVDQU 32[rsi], YMM1
+
+    // Initialize message pointer and loop counter
+    MOVQ   message+0(FP), DX  // DX: &p (message)
+    MOVQ   message_len+8(FP), R8 // R8: len(message)
+    SHRQ   $7, R8             // len(message) / 128
+    CMPQ   R8, $0
+    JEQ    complete
+
+loop:
+    // Increment counter
+    MOVQ t+72(FP), SI         // SI: &t
+    MOVQ   0(SI), R9          //
+    ADDQ   $128, R9           //                       /* d.t[0] += BlockSize */
+    MOVQ   R9, 0(SI)          //
+    CMPQ   R9, $128           //                       /* if d.t[0] < BlockSize { */
+    JGE    noincr             //
+    MOVQ   8(SI), R9          //
+    ADDQ   $1, R9             //                       /*     d.t[1]++ */
+    MOVQ   R9, 8(SI)          //
+noincr:                       //                       /* } */
+
+    // Load initialization vector
+    MOVQ iv+48(FP), SI        // SI: &iv
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x6f; BYTE $0x16               // VMOVDQU YMM2, [rsi]
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x6f; BYTE $0x5e; BYTE $0x20   // VMOVDQU YMM3, 32[rsi]
+    MOVQ t+72(FP), SI         // SI: &t
+    BYTE $0xc4; BYTE $0x63; BYTE $0x3d; BYTE $0x38; BYTE $0x06   // VINSERTI128 YMM8, YMM8, [rsi], 0  /* Y8 = t[0]+t[1] */
+                BYTE $0x00
+    MOVQ t+96(FP), SI         // SI: &f
+    BYTE $0xc4; BYTE $0x63; BYTE $0x3d; BYTE $0x38; BYTE $0x06   // VINSERTI128 YMM8, YMM8, [rsi], 1  /* Y8 = t[0]+t[1]+f[0]+f[1] */
+                BYTE $0x01
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x65; BYTE $0xef; BYTE $0xd8   // VPXOR   YMM3,YMM3,YMM8            /* Y3 = Y3 ^ Y8 */
+
+    BYTE $0xc5; BYTE $0x7e; BYTE $0x6f; BYTE $0x12               // VMOVDQU YMM10, [rdx]              /* Y10 =  m[0]+ m[1]+ m[2]+ m[3] */
+    BYTE $0xc5; BYTE $0x7e; BYTE $0x6f; BYTE $0x5a; BYTE $0x20   // VMOVDQU YMM11, 32[rdx]            /* Y11 =  m[4]+ m[5]+ m[6]+ m[7] */
+    BYTE $0xc5; BYTE $0x7e; BYTE $0x6f; BYTE $0x62; BYTE $0x40   // VMOVDQU YMM12, 64[rdx]            /* Y12 =  m[8]+ m[9]+m[10]+m[11] */
+    BYTE $0xc5; BYTE $0x7e; BYTE $0x6f; BYTE $0x6a; BYTE $0x60   // VMOVDQU YMM13, 96[rdx]            /* Y13 = m[12]+m[13]+m[14]+m[15] */
+
+    LOAD_SHUFFLE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   1
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x2d; BYTE $0x6c; BYTE $0xe3   // VPUNPCKLQDQ  YMM4, YMM10, YMM11 /* m[0], m[4], m[2], m[6] */
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x2d; BYTE $0x6d; BYTE $0xeb   // VPUNPCKHQDQ  YMM5, YMM10, YMM11 /* m[1], m[5], m[3], m[7] */
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xe4   // VPERMQ       YMM4, YMM4, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xed   // VPERMQ       YMM5, YMM5, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x1d; BYTE $0x6c; BYTE $0xe5   // VPUNPCKLQDQ  YMM4, YMM12, YMM13 /* m[8], m[12], m[10], m[14] */
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x1d; BYTE $0x6d; BYTE $0xed   // VPUNPCKHQDQ  YMM5, YMM12, YMM13 /* m[9], m[13], m[11], m[15] */
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xe4   // VPERMQ       YMM4, YMM4, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xed   // VPERMQ       YMM5, YMM5, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   2
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xc5   // VPUNPCKLQDQ  YMM8, YMM11, YMM13        /*  m[4],  ____,  ____, m[14] */
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8,  YMM8, 0x03         /* m[14],  m[4],  ____,  ____ */ /* xxxx 0011 = 0x03 */
+                BYTE $0x03
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xcd   // VPUNPCKHQDQ  YMM9, YMM12, YMM13        /*  m[9], m[13],  ____,  ____ */
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4,  YMM8,  YMM9, 0x20  /*  m[9], m[13],  ____,  ____ */ /* 0010 0000 = 0x20 */
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc4   // VPERMQ       YMM8,  YMM12, 0x02        /* m[10],  m[8],  ____,  ____ */ /* xxxx 0010 = 0x02 */
+                BYTE $0x02
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcd   // VPERMQ       YMM9,  YMM13, 0x30        /*  ____,  ____, m[15],  ____ */ /* xx11 xxxx = 0x30 */
+                BYTE $0x30
+    BYTE $0xc4; BYTE $0x41; BYTE $0x35; BYTE $0x6c; BYTE $0xcb   // VPUNPCKLQDQ  YMM9,   YMM9, YMM11       /*  ____,  ____, m[15],  m[6] */
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5,   YMM8, YMM9, 0x30  /*  m[9], m[13], m[15],  m[6] */ /* 0011 0000 = 0x30 */
+                BYTE $0x30
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc2   // VPERMQ       YMM8, YMM10, 0x01         /*  m[1],  m[0],  ____,  ____ */ /* xxxx 0001 = 0x01 */
+                BYTE $0x01
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xcc   // VPUNPCKHQDQ  YMM9, YMM11, YMM12        /*  m[5],  ____,  ____, m[11] */
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9,  YMM9, 0x03         /* m[11],  m[5],  ____,  ____ */ /* xxxx 0011 = 0x03 */
+                BYTE $0x03
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4,  YMM8, YMM9, 0x20   /*  m[1],  m[0], m[11],  m[5] */ /* 0010 0000 = 0x20 */
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc5   // VPUNPCKLQDQ  YMM8, YMM10, YMM13        /*  ___,  m[12],  m[2],  ____ */
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8,  YMM8, 0x09         /* m[12],  m[2],  ____,  ____ */ /* xxxx 1001 = 0x09 */
+                BYTE $0x09
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xca   // VPUNPCKHQDQ  YMM9, YMM11, YMM10        /*  ____,  ____,  m[7],  m[3] */
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5,  YMM8, YMM9, 0x30   /*  m[9], m[13], m[15],  m[6] */ /* 0011 0000 = 0x30 */
+                BYTE $0x30
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   3
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc5   // VPERMQ       YMM8, YMM13, 0x00
+                BYTE $0x00
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xc0   // VPUNPCKHQDQ  YMM8, YMM12, YMM8
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xcd   // VPUNPCKHQDQ  YMM9, YMM11, YMM13
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6c; BYTE $0xc2   // VPUNPCKLQDQ  YMM8, YMM12, YMM10
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcd   // VPERMQ       YMM9, YMM13, 0x55
+                BYTE $0x55
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM10, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x30
+                BYTE $0x30
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc2   // VPERMQ       YMM8, YMM10, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6c; BYTE $0xc0   // VPUNPCKLQDQ  YMM8, YMM12, YMM8
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xcc   // VPUNPCKHQDQ  YMM9, YMM11, YMM12
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xc3   // VPUNPCKLQDQ  YMM8, YMM13, YMM11
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcb   // VPERMQ       YMM9, YMM11, 0x00
+                BYTE $0x00
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6d; BYTE $0xc9   // VPUNPCKHQDQ  YMM9, YMM10, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   4
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xc2   // VPUNPCKHQDQ  YMM8, YMM11, YMM10
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6d; BYTE $0xcc   // VPUNPCKHQDQ  YMM9, YMM13, YMM12
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xc2   // VPUNPCKHQDQ  YMM8, YMM12, YMM10
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcd   // VPERMQ       YMM9, YMM13, 0x08
+                BYTE $0x08
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x20
+                BYTE $0x20
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc3   // VPERMQ       YMM8, YMM11, 0x55
+                BYTE $0x55
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc0   // VPUNPCKLQDQ  YMM8, YMM10, YMM8
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcd   // VPERMQ       YMM9, YMM13, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM11, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xc4   // VPUNPCKLQDQ  YMM8, YMM11, YMM12
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xcc   // VPUNPCKLQDQ  YMM9, YMM10, YMM12
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   5
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xc3   // VPUNPCKHQDQ  YMM8, YMM12, YMM11
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xcc   // VPUNPCKLQDQ  YMM9, YMM10, YMM12
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x30
+                BYTE $0x30
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc3   // VPERMQ       YMM8, YMM11, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc0   // VPUNPCKLQDQ  YMM8, YMM10, YMM8
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcd   // VPERMQ       YMM9, YMM13, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM11, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x20
+                BYTE $0x20
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc4   // VPERMQ       YMM8, YMM12, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xc0   // VPUNPCKLQDQ  YMM8, YMM13, YMM8
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xca   // VPERMQ       YMM9, YMM10, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM11, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc5   // VPERMQ       YMM8, YMM13, 0x00
+                BYTE $0x00
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6d; BYTE $0xc0   // VPUNPCKHQDQ  YMM8, YMM10, YMM8
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcd   // VPERMQ       YMM9, YMM13, 0x55
+                BYTE $0x55
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM12, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x20
+                BYTE $0x20
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   6
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc3   // VPUNPCKLQDQ  YMM8, YMM10, YMM11
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xcc   // VPUNPCKLQDQ  YMM9, YMM10, YMM12
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xc4   // VPUNPCKLQDQ  YMM8, YMM13, YMM12
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xca   // VPUNPCKHQDQ  YMM9, YMM12, YMM10
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x30
+                BYTE $0x30
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc3   // VPERMQ       YMM8, YMM11, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6d; BYTE $0xca   // VPUNPCKHQDQ  YMM9, YMM13, YMM10
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x30
+                BYTE $0x30
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6d; BYTE $0xc3   // VPUNPCKHQDQ  YMM8, YMM13, YMM11
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcc   // VPERMQ       YMM9, YMM12, 0x55
+                BYTE $0x55
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM13, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x30
+                BYTE $0x30
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   7
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc2   // VPERMQ       YMM8, YMM10, 0x55
+                BYTE $0x55
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xc0   // VPUNPCKLQDQ  YMM8, YMM13, YMM8
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xcb   // VPUNPCKLQDQ  YMM9, YMM13, YMM11
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x30
+                BYTE $0x30
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xc5   // VPUNPCKHQDQ  YMM8, YMM11, YMM13
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcc   // VPERMQ       YMM9, YMM12, 0xaa
+                BYTE $0xaa
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6d; BYTE $0xc9   // VPUNPCKHQDQ  YMM9, YMM13, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x20
+                BYTE $0x20
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc3   // VPUNPCKLQDQ  YMM8, YMM10, YMM11
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcc   // VPERMQ       YMM9, YMM12, 0x01
+                BYTE $0x01
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x20
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xc2   // VPUNPCKHQDQ  YMM8, YMM11, YMM10
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcc   // VPERMQ       YMM9, YMM12, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM10, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   8
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6d; BYTE $0xc3   // VPUNPCKHQDQ  YMM8, YMM13, YMM11
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xca   // VPERMQ       YMM9, YMM10, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM13, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x20
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc5   // VPERMQ       YMM8, YMM13, 0xaa
+                BYTE $0xaa
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xc0   // VPUNPCKHQDQ  YMM8, YMM12, YMM8
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6d; BYTE $0xcc   // VPUNPCKHQDQ  YMM9, YMM10, YMM12
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xc5   // VPUNPCKHQDQ  YMM8, YMM11, YMM13
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6c; BYTE $0xca   // VPUNPCKLQDQ  YMM9, YMM12, YMM10
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x20
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc3   // VPUNPCKLQDQ  YMM8, YMM10, YMM11
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xcc   // VPUNPCKLQDQ  YMM9, YMM11, YMM12
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x30
+                BYTE $0x30
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   9
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xc5   // VPUNPCKLQDQ  YMM8, YMM11, YMM13
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xca   // VPERMQ       YMM9, YMM10, 0x00
+                BYTE $0x00
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xc9   // VPUNPCKHQDQ  YMM9, YMM12, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6d; BYTE $0xc4   // VPUNPCKHQDQ  YMM8, YMM13, YMM12
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcc   // VPERMQ       YMM9, YMM12, 0x00
+                BYTE $0x00
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6d; BYTE $0xc9   // VPUNPCKHQDQ  YMM9, YMM10, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcc   // VPERMQ       YMM9, YMM12, 0xaa
+                BYTE $0xaa
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6d; BYTE $0xc9   // VPUNPCKHQDQ  YMM9, YMM10, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x15; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM13, YMM9, 0x20
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc3   // VPERMQ       YMM8, YMM11, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc0   // VPUNPCKLQDQ  YMM8, YMM10, YMM8
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcb   // VPERMQ       YMM9, YMM11, 0x04
+                BYTE $0x04
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   10
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc4   // VPERMQ       YMM8, YMM12, 0x20
+                BYTE $0x20
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xca   // VPUNPCKHQDQ  YMM9, YMM11, YMM10
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc3   // VPUNPCKLQDQ  YMM8, YMM10, YMM11
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcb   // VPERMQ       YMM9, YMM11, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6d; BYTE $0xc4   // VPUNPCKHQDQ  YMM8, YMM13, YMM12
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6d; BYTE $0xcd   // VPUNPCKHQDQ  YMM9, YMM10, YMM13
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc5   // VPERMQ       YMM8, YMM13, 0xaa
+                BYTE $0xaa
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xc0   // VPUNPCKHQDQ  YMM8, YMM12, YMM8
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xca   // VPUNPCKLQDQ  YMM9, YMM13, YMM10
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x21
+                BYTE $0x21
+                                                                 
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   1 1
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x2d; BYTE $0x6c; BYTE $0xe3   // VPUNPCKLQDQ  YMM4, YMM10, YMM11 /* m[0], m[4], m[2], m[6] */
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x2d; BYTE $0x6d; BYTE $0xeb   // VPUNPCKHQDQ  YMM5, YMM10, YMM11 /* m[1], m[5], m[3], m[7] */
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xe4   // VPERMQ       YMM4, YMM4, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xed   // VPERMQ       YMM5, YMM5, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x1d; BYTE $0x6c; BYTE $0xe5   // VPUNPCKLQDQ  YMM4, YMM12, YMM13 /* m[8], m[12], m[10], m[14] */
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x1d; BYTE $0x6d; BYTE $0xed   // VPUNPCKHQDQ  YMM5, YMM12, YMM13 /* m[9], m[13], m[11], m[15] */
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xe4   // VPERMQ       YMM4, YMM4, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xed   // VPERMQ       YMM5, YMM5, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   1 2
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xc5   // VPUNPCKLQDQ  YMM8, YMM11, YMM13        /*  m[4],  ____,  ____, m[14] */
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8,  YMM8, 0x03         /* m[14],  m[4],  ____,  ____ */ /* xxxx 0011 = 0x03 */
+                BYTE $0x03
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xcd   // VPUNPCKHQDQ  YMM9, YMM12, YMM13        /*  m[9], m[13],  ____,  ____ */
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4,  YMM8,  YMM9, 0x20  /*  m[9], m[13],  ____,  ____ */ /* 0010 0000 = 0x20 */
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc4   // VPERMQ       YMM8,  YMM12, 0x02        /* m[10],  m[8],  ____,  ____ */ /* xxxx 0010 = 0x02 */
+                BYTE $0x02
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcd   // VPERMQ       YMM9,  YMM13, 0x30        /*  ____,  ____, m[15],  ____ */ /* xx11 xxxx = 0x30 */
+                BYTE $0x30
+    BYTE $0xc4; BYTE $0x41; BYTE $0x35; BYTE $0x6c; BYTE $0xcb   // VPUNPCKLQDQ  YMM9,   YMM9, YMM11       /*  ____,  ____, m[15],  m[6] */
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5,   YMM8, YMM9, 0x30  /*  m[9], m[13], m[15],  m[6] */ /* 0011 0000 = 0x30 */
+                BYTE $0x30
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc2   // VPERMQ       YMM8, YMM10, 0x01         /*  m[1],  m[0],  ____,  ____ */ /* xxxx 0001 = 0x01 */
+                BYTE $0x01
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xcc   // VPUNPCKHQDQ  YMM9, YMM11, YMM12        /*  m[5],  ____,  ____, m[11] */
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9,  YMM9, 0x03         /* m[11],  m[5],  ____,  ____ */ /* xxxx 0011 = 0x03 */
+                BYTE $0x03
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4,  YMM8, YMM9, 0x20   /*  m[1],  m[0], m[11],  m[5] */ /* 0010 0000 = 0x20 */
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc5   // VPUNPCKLQDQ  YMM8, YMM10, YMM13        /*  ___,  m[12],  m[2],  ____ */
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8,  YMM8, 0x09         /* m[12],  m[2],  ____,  ____ */ /* xxxx 1001 = 0x09 */
+                BYTE $0x09
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xca   // VPUNPCKHQDQ  YMM9, YMM11, YMM10        /*  ____,  ____,  m[7],  m[3] */
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5,  YMM8, YMM9, 0x30   /*  m[9], m[13], m[15],  m[6] */ /* 0011 0000 = 0x30 */
+                BYTE $0x30
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    // Reload digest (most current value store in &out)
+    MOVQ  out+144(FP),  SI    // SI: &in
+    BYTE $0xc5; BYTE $0x7e; BYTE $0x6f; BYTE $0x26               // VMOVDQU YMM12, [rsi]
+    BYTE $0xc5; BYTE $0x7e; BYTE $0x6f; BYTE $0x6e; BYTE $0x20   // VMOVDQU YMM13, 32[rsi]
+
+    BYTE $0xc5; BYTE $0xfd; BYTE $0xef; BYTE $0xc2               // VPXOR   YMM0,YMM0,YMM2   /* X0 = X0 ^ X4,  X1 = X1 ^ X5 */
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x7d; BYTE $0xef; BYTE $0xc4   // VPXOR   YMM0,YMM0,YMM12  /* X0 = X0 ^ X12, X1 = X1 ^ X13 */
+    BYTE $0xc5; BYTE $0xf5; BYTE $0xef; BYTE $0xcb               // VPXOR   YMM1,YMM1,YMM3   /* X2 = X2 ^ X6,  X3 = X3 ^ X7 */
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x75; BYTE $0xef; BYTE $0xcd   // VPXOR   YMM1,YMM1,YMM13  /* X2 = X2 ^ X14, X3 = X3 ^ X15 */
+
+    // Store digest into &out
+    MOVQ  out+144(FP), SI     // SI: &out
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x7f; BYTE $0x06               // VMOVDQU [rsi], YMM0
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x7f; BYTE $0x4e; BYTE $0x20   // VMOVDQU 32[rsi], YMM1
+
+    // Increment message pointer and check if there's more to do
+    ADDQ   $128, DX           // message += 128
+    SUBQ   $1, R8
+    JNZ    loop
+
+complete:
+    BYTE $0xc5; BYTE $0xf8; BYTE $0x77                           // VZEROUPPER  /* Prevent further context switches */
+    RET
+

vendor/github.com/minio/blake2b-simd/compressAvx_amd64.go

@@ -0,0 +1,41 @@
+//+build !noasm
+//+build !appengine
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package blake2b
+
+//go:noescape
+func blockAVXLoop(p []uint8, in, iv, t, f, shffle, out []uint64)
+
+func compressAVX(d *digest, p []uint8) {
+	var (
+		in     [8]uint64
+		out    [8]uint64
+		shffle [2]uint64
+	)
+
+	// vector for PSHUFB instruction
+	shffle[0] = 0x0201000706050403
+	shffle[1] = 0x0a09080f0e0d0c0b
+
+	in[0], in[1], in[2], in[3], in[4], in[5], in[6], in[7] = d.h[0], d.h[1], d.h[2], d.h[3], d.h[4], d.h[5], d.h[6], d.h[7]
+
+	blockAVXLoop(p, in[:], iv[:], d.t[:], d.f[:], shffle[:], out[:])
+
+	d.h[0], d.h[1], d.h[2], d.h[3], d.h[4], d.h[5], d.h[6], d.h[7] = out[0], out[1], out[2], out[3], out[4], out[5], out[6], out[7]
+}

vendor/github.com/minio/blake2b-simd/compressAvx_amd64.s

@@ -0,0 +1,682 @@
+//+build !noasm !appengine
+
+//
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+//
+// Based on SSE implementation from https://github.com/BLAKE2/BLAKE2/blob/master/sse/blake2b.c
+//
+// Use github.com/fwessels/asm2plan9s on this file to assemble instructions to their Plan9 equivalent
+//
+// Assembly code below essentially follows the ROUND macro (see blake2b-round.h) which is defined as:
+//   #define ROUND(r) \
+//     LOAD_MSG_ ##r ##_1(b0, b1); \
+//     G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     LOAD_MSG_ ##r ##_2(b0, b1); \
+//     G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     DIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h); \
+//     LOAD_MSG_ ##r ##_3(b0, b1); \
+//     G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     LOAD_MSG_ ##r ##_4(b0, b1); \
+//     G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     UNDIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h);
+//
+// as well as the go equivalent in https://github.com/dchest/blake2b/blob/master/block.go
+//
+// As in the macro, G1/G2 in the 1st and 2nd half are identical (so literal copy of assembly)
+//
+// Rounds are also the same, except for the loading of the message (and rounds 1 & 11 and
+// rounds 2 & 12 are identical)
+//
+
+#define G1 \
+	\ // G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1);
+	LONG $0xd479c1c4; BYTE $0xc0 \ // VPADDQ  XMM0,XMM0,XMM8   /* v0 += m[0], v1 += m[2] */
+	LONG $0xd471c1c4; BYTE $0xc9 \ // VPADDQ  XMM1,XMM1,XMM9   /* v2 += m[4], v3 += m[6] */
+	LONG $0xc2d4f9c5             \ // VPADDQ  XMM0,XMM0,XMM2   /* v0 += v4, v1 += v5 */
+	LONG $0xcbd4f1c5             \ // VPADDQ  XMM1,XMM1,XMM3   /* v2 += v6, v3 += v7 */
+	LONG $0xf0efc9c5             \ // VPXOR   XMM6,XMM6,XMM0   /* v12 ^= v0, v13 ^= v1 */
+	LONG $0xf9efc1c5             \ // VPXOR   XMM7,XMM7,XMM1   /* v14 ^= v2, v15 ^= v3 */
+	LONG $0xf670f9c5; BYTE $0xb1 \ // VPSHUFD XMM6,XMM6,0xb1   /* v12 = v12<<(64-32) | v12>>32, v13 = v13<<(64-32) | v13>>32 */
+	LONG $0xff70f9c5; BYTE $0xb1 \ // VPSHUFD XMM7,XMM7,0xb1   /* v14 = v14<<(64-32) | v14>>32, v15 = v15<<(64-32) | v15>>32 */
+	LONG $0xe6d4d9c5             \ // VPADDQ  XMM4,XMM4,XMM6   /* v8 += v12, v9 += v13  */
+	LONG $0xefd4d1c5             \ // VPADDQ  XMM5,XMM5,XMM7   /* v10 += v14, v11 += v15 */
+	LONG $0xd4efe9c5             \ // VPXOR   XMM2,XMM2,XMM4   /* v4 ^= v8, v5 ^= v9 */
+	LONG $0xddefe1c5             \ // VPXOR   XMM3,XMM3,XMM5   /* v6 ^= v10, v7 ^= v11 */
+	LONG $0x0069c2c4; BYTE $0xd4 \ // VPSHUFB XMM2,XMM2,XMM12  /* v4 = v4<<(64-24) | v4>>24, v5 = v5<<(64-24) | v5>>24 */
+	LONG $0x0061c2c4; BYTE $0xdc   // VPSHUFB XMM3,XMM3,XMM12  /* v6 = v6<<(64-24) | v6>>24, v7 = v7<<(64-24) | v7>>24 */
+
+#define G2 \
+	\ // G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1);
+	LONG $0xd479c1c4; BYTE $0xc2 \ // VPADDQ  XMM0,XMM0,XMM10  /* v0 += m[1], v1 += m[3] */
+	LONG $0xd471c1c4; BYTE $0xcb \ // VPADDQ  XMM1,XMM1,XMM11  /* v2 += m[5], v3 += m[7] */
+	LONG $0xc2d4f9c5             \ // VPADDQ  XMM0,XMM0,XMM2   /* v0 += v4, v1 += v5 */
+	LONG $0xcbd4f1c5             \ // VPADDQ  XMM1,XMM1,XMM3   /* v2 += v6, v3 += v7 */
+	LONG $0xf0efc9c5             \ // VPXOR   XMM6,XMM6,XMM0   /* v12 ^= v0, v13 ^= v1 */
+	LONG $0xf9efc1c5             \ // VPXOR   XMM7,XMM7,XMM1   /* v14 ^= v2, v15 ^= v3 */
+	LONG $0xf670fbc5; BYTE $0x39 \ // VPSHUFLW XMM6,XMM6,0x39  /* combined with next ... */
+	LONG $0xf670fac5; BYTE $0x39 \ // VPSHUFHW XMM6,XMM6,0x39  /* v12 = v12<<(64-16) | v12>>16, v13 = v13<<(64-16) | v13>>16 */
+	LONG $0xff70fbc5; BYTE $0x39 \ // VPSHUFLW XMM7,XMM7,0x39  /* combined with next ... */
+	LONG $0xff70fac5; BYTE $0x39 \ // VPSHUFHW XMM7,XMM7,0x39  /* v14 = v14<<(64-16) | v14>>16, v15 = v15<<(64-16) | v15>>16 */
+	LONG $0xe6d4d9c5             \ // VPADDQ  XMM4,XMM4,XMM6   /* v8 += v12, v9 += v13 */
+	LONG $0xefd4d1c5             \ // VPADDQ  XMM5,XMM5,XMM7   /* v10 += v14, v11 += v15 */
+	LONG $0xd4efe9c5             \ // VPXOR   XMM2,XMM2,XMM4   /* v4 ^= v8, v5 ^= v9 */
+	LONG $0xddefe1c5             \ // VPXOR   XMM3,XMM3,XMM5   /* v6 ^= v10, v7 ^= v11 */
+	LONG $0xfad469c5             \ // VPADDQ  XMM15,XMM2,XMM2  /* temp reg = reg*2   */
+	LONG $0xd273e9c5; BYTE $0x3f \ // VPSRLQ  XMM2,XMM2,0x3f   /*      reg = reg>>63 */
+	LONG $0xef69c1c4; BYTE $0xd7 \ // VPXOR   XMM2,XMM2,XMM15  /* ORed together: v4 = v4<<(64-63) | v4>>63, v5 = v5<<(64-63) | v5>>63 */
+	LONG $0xfbd461c5             \ // VPADDQ XMM15,XMM3,XMM3   /* temp reg = reg*2   */
+	LONG $0xd373e1c5; BYTE $0x3f \ // VPSRLQ XMM3,XMM3,0x3f    /*      reg = reg>>63 */
+	LONG $0xef61c1c4; BYTE $0xdf   // VPXOR  XMM3,XMM3,XMM15   /* ORed together: v6 = v6<<(64-63) | v6>>63, v7 = v7<<(64-63) | v7>>63 */
+
+#define DIAGONALIZE \
+	\ // DIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h);
+	MOVOU X6, X13                \                                     /* t0 = row4l;\                                                            */
+	MOVOU X2, X14                \                                     /* t1 = row2l;\                                                            */
+	MOVOU X4, X6                 \                                     /* row4l = row3l;\                                                         */
+	MOVOU X5, X4                 \                                     /* row3l = row3h;\                                                         */
+	MOVOU X6, X5                 \                                     /* row3h = row4l;\                                                         */
+	LONG $0x6c1141c4; BYTE $0xfd \ // VPUNPCKLQDQ XMM15, XMM13, XMM13  /*                                    _mm_unpacklo_epi64(t0, t0)           */
+	LONG $0x6d41c1c4; BYTE $0xf7 \ // VPUNPCKHQDQ  XMM6,  XMM7, XMM15  /*  row4l = _mm_unpackhi_epi64(row4h,                           ); \       */
+	LONG $0xff6c41c5             \ // VPUNPCKLQDQ XMM15,  XMM7,  XMM7  /*                                 _mm_unpacklo_epi64(row4h, row4h)        */
+	LONG $0x6d11c1c4; BYTE $0xff \ // VPUNPCKHQDQ  XMM7, XMM13, XMM15  /*  row4h = _mm_unpackhi_epi64(t0,                                 ); \    */
+	LONG $0xfb6c61c5             \ // VPUNPCKLQDQ XMM15,  XMM3,  XMM3  /*                                    _mm_unpacklo_epi64(row2h, row2h)     */
+	LONG $0x6d69c1c4; BYTE $0xd7 \ // VPUNPCKHQDQ  XMM2,  XMM2, XMM15  /*  row2l = _mm_unpackhi_epi64(row2l,                                 ); \ */
+	LONG $0x6c0941c4; BYTE $0xfe \ // VPUNPCKLQDQ XMM15, XMM14, XMM14  /*                                    _mm_unpacklo_epi64(t1, t1)           */
+	LONG $0x6d61c1c4; BYTE $0xdf   // VPUNPCKHQDQ  XMM3,  XMM3, XMM15  /*  row2h = _mm_unpackhi_epi64(row2h,                           )          */
+
+#define UNDIAGONALIZE \
+	\ // UNDIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h);
+	MOVOU X4, X13                \                                     /* t0 = row3l;\                                                            */
+	MOVOU X5, X4                 \                                     /* row3l = row3h;\                                                         */
+	MOVOU X13, X5                \                                     /* row3h = t0;\                                                            */
+	MOVOU X2, X13                \                                     /* t0 = row2l;\                                                            */
+	MOVOU X6, X14                \                                     /* t1 = row4l;\                                                            */
+	LONG $0xfa6c69c5             \ // VPUNPCKLQDQ XMM15,  XMM2,  XMM2  /*                                    _mm_unpacklo_epi64(row2l, row2l)     */
+	LONG $0x6d61c1c4; BYTE $0xd7 \ // VPUNPCKHQDQ  XMM2,  XMM3, XMM15  /*  row2l = _mm_unpackhi_epi64(row2h,                                 ); \ */
+	LONG $0xfb6c61c5             \ // VPUNPCKLQDQ XMM15,  XMM3,  XMM3  /*                                 _mm_unpacklo_epi64(row2h, row2h)        */
+	LONG $0x6d11c1c4; BYTE $0xdf \ // VPUNPCKHQDQ  XMM3, XMM13, XMM15  /*  row2h = _mm_unpackhi_epi64(t0,                                 ); \    */
+	LONG $0xff6c41c5             \ // VPUNPCKLQDQ XMM15,  XMM7,  XMM7  /*                                    _mm_unpacklo_epi64(row4h, row4h)     */
+	LONG $0x6d49c1c4; BYTE $0xf7 \ // VPUNPCKHQDQ  XMM6,  XMM6, XMM15  /*  row4l = _mm_unpackhi_epi64(row4l,                                 ); \ */
+	LONG $0x6c0941c4; BYTE $0xfe \ // VPUNPCKLQDQ XMM15, XMM14, XMM14  /*                                    _mm_unpacklo_epi64(t1, t1)           */
+	LONG $0x6d41c1c4; BYTE $0xff   // VPUNPCKHQDQ  XMM7,  XMM7, XMM15  /*  row4h = _mm_unpackhi_epi64(row4h,                           )          */
+
+#define LOAD_SHUFFLE \
+	\ // Load shuffle value
+	MOVQ  shffle+120(FP), SI \ // SI: &shuffle
+	MOVOU 0(SI), X12           // X12 = 03040506 07000102 0b0c0d0e 0f08090a
+
+// func blockAVXLoop(p []uint8, in, iv, t, f, shffle, out []uint64)
+TEXT ·blockAVXLoop(SB), 7, $0
+	// REGISTER USE
+	//        R8: loop counter
+	//        DX: message pointer
+	//        SI: temp pointer for loading
+	//  X0 -  X7: v0 - v15
+	//  X8 - X11: m[0] - m[7]
+	//       X12: shuffle value
+	// X13 - X15: temp registers
+
+	// Load digest
+	MOVQ  in+24(FP), SI // SI: &in
+	MOVOU 0(SI), X0     // X0 = in[0]+in[1]      /* row1l = LOAD( &S->h[0] ); */
+	MOVOU 16(SI), X1    // X1 = in[2]+in[3]      /* row1h = LOAD( &S->h[2] ); */
+	MOVOU 32(SI), X2    // X2 = in[4]+in[5]      /* row2l = LOAD( &S->h[4] ); */
+	MOVOU 48(SI), X3    // X3 = in[6]+in[7]      /* row2h = LOAD( &S->h[6] ); */
+
+	// Already store digest into &out (so we can reload it later generically)
+	MOVQ  out+144(FP), SI // SI: &out
+	MOVOU X0, 0(SI)       // out[0]+out[1] = X0
+	MOVOU X1, 16(SI)      // out[2]+out[3] = X1
+	MOVOU X2, 32(SI)      // out[4]+out[5] = X2
+	MOVOU X3, 48(SI)      // out[6]+out[7] = X3
+
+	// Initialize message pointer and loop counter
+	MOVQ message+0(FP), DX     // DX: &p (message)
+	MOVQ message_len+8(FP), R8 // R8: len(message)
+	SHRQ $7, R8                // len(message) / 128
+	CMPQ R8, $0
+	JEQ  complete
+
+loop:
+	// Increment counter
+	MOVQ t+72(FP), SI // SI: &t
+	MOVQ 0(SI), R9
+	ADDQ $128, R9     // /* d.t[0] += BlockSize */
+	MOVQ R9, 0(SI)
+	CMPQ R9, $128     // /* if d.t[0] < BlockSize { */
+	JGE  noincr
+	MOVQ 8(SI), R9
+	ADDQ $1, R9       // /*     d.t[1]++ */
+	MOVQ R9, 8(SI)
+noincr:               // /* } */
+
+	// Load initialization vector
+	MOVQ  iv+48(FP), SI // SI: &iv
+	MOVOU 0(SI), X4     // X4 = iv[0]+iv[1]      /* row3l = LOAD( &blake2b_IV[0] );                                    */
+	MOVOU 16(SI), X5    // X5 = iv[2]+iv[3]      /* row3h = LOAD( &blake2b_IV[2] );                                    */
+	MOVOU 32(SI), X6    // X6 = iv[4]+iv[5]      /*                        LOAD( &blake2b_IV[4] )                      */
+	MOVOU 48(SI), X7    // X7 = iv[6]+iv[7]      /*                        LOAD( &blake2b_IV[6] )                      */
+	MOVQ  t+72(FP), SI  // SI: &t
+	MOVOU 0(SI), X8     // X8 = t[0]+t[1]        /*                                                LOAD( &S->t[0] )    */
+	PXOR  X8, X6        // X6 = X6 ^ X8          /* row4l = _mm_xor_si128(                       ,                  ); */
+	MOVQ  t+96(FP), SI  // SI: &f
+	MOVOU 0(SI), X8     // X8 = f[0]+f[1]        /*                                                LOAD( &S->f[0] )    */
+	PXOR  X8, X7        // X7 = X7 ^ X8          /* row4h = _mm_xor_si128(                       ,                  ); */
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   1
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12             // X12 = m[0]+m[1]
+	MOVOU 16(DX), X13            // X13 = m[2]+m[3]
+	MOVOU 32(DX), X14            // X14 = m[4]+m[5]
+	MOVOU 48(DX), X15            // X15 = m[6]+m[7]
+	LONG $0x6c1941c4; BYTE $0xc5 // VPUNPCKLQDQ  XMM8, XMM12, XMM13  /* m[0], m[2] */
+	LONG $0x6c0941c4; BYTE $0xcf // VPUNPCKLQDQ  XMM9, XMM14, XMM15  /* m[4], m[6] */
+	LONG $0x6d1941c4; BYTE $0xd5 // VPUNPCKHQDQ XMM10, XMM12, XMM13  /* m[1], m[3] */
+	LONG $0x6d0941c4; BYTE $0xdf // VPUNPCKHQDQ XMM11, XMM14, XMM15  /* m[5], m[7] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 64(DX), X12            // X12 =  m[8]+ m[9]
+	MOVOU 80(DX), X13            // X13 = m[10]+m[11]
+	MOVOU 96(DX), X14            // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+	LONG $0x6c1941c4; BYTE $0xc5 // VPUNPCKLQDQ  XMM8, XMM12, XMM13  /*  m[8],m[10] */
+	LONG $0x6c0941c4; BYTE $0xcf // VPUNPCKLQDQ  XMM9, XMM14, XMM15  /* m[12],m[14] */
+	LONG $0x6d1941c4; BYTE $0xd5 // VPUNPCKHQDQ XMM10, XMM12, XMM13  /*  m[9],m[11] */
+	LONG $0x6d0941c4; BYTE $0xdf // VPUNPCKHQDQ XMM11, XMM14, XMM15  /* m[13],m[15] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   2
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 112(DX), X12             // X12 = m[14]+m[15]
+	MOVOU 32(DX), X13              // X13 =  m[4]+ m[5]
+	MOVOU 64(DX), X14              // X14 =  m[8]+ m[9]
+	MOVOU 96(DX), X15              // X15 = m[12]+m[13]
+	LONG $0x6c1941c4; BYTE $0xc5   // VPUNPCKLQDQ  XMM8, XMM12, XMM13  /* m[14],  m[4] */
+	LONG $0x6d0941c4; BYTE $0xcf   // VPUNPCKHQDQ  XMM9, XMM14, XMM15  /*  m[9], m[13] */
+	MOVOU 80(DX), X13              // X13 = m[10]+m[11]
+	MOVOU 48(DX), X15              // X15 =  m[6]+ m[7]
+	LONG $0x6c1141c4; BYTE $0xd6   // VPUNPCKLQDQ XMM10, XMM13, XMM14  /* m[10],  m[8] */
+	LONG $0x0f0143c4; WORD $0x08dc // VPALIGNR    XMM11, XMM15, XMM12, 0x8  /* m[15],  m[6] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+	MOVOU 32(DX), X13              // X13 =  m[4]+ m[5]
+	MOVOU 80(DX), X14              // X14 = m[10]+m[11]
+	LONG $0x0f1943c4; WORD $0x08c4 // VPALIGNR     XMM8, XMM12, XMM12, 0x8  /*  m[1],  m[0] */
+	LONG $0x6d0941c4; BYTE $0xcd   // VPUNPCKHQDQ  XMM9, XMM14, XMM13  /* m[11], m[5] */
+	MOVOU 16(DX), X12              // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X13              // X13 =  m[6]+ m[7]
+	MOVOU 96(DX), X14              // X14 = m[12]+m[13]
+	LONG $0x6c0941c4; BYTE $0xd4   // VPUNPCKLQDQ XMM10, XMM14, XMM12  /* m[12], m[2] */
+	LONG $0x6d1141c4; BYTE $0xdc   // VPUNPCKHQDQ XMM11, XMM13, XMM12  /*  m[7], m[3] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   3
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 32(DX), X12              // X12 =  m[4]+ m[5]
+	MOVOU 80(DX), X13              // X13 = m[10]+m[11]
+	MOVOU 96(DX), X14              // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15             // X15 = m[14]+m[15]
+	LONG $0x0f0943c4; WORD $0x08c5 // VPALIGNR     XMM8, XMM14, XMM13, 0x8  /* m[11],  m[12] */
+	LONG $0x6d1941c4; BYTE $0xcf   // VPUNPCKHQDQ  XMM9, XMM12, XMM15  /*  m[5], m[15] */
+	MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+	MOVOU 16(DX), X13              // X13 =  m[2]+ m[3]
+	MOVOU 64(DX), X15              // X15 =  m[8]+ m[9]
+	LONG $0x6c0141c4; BYTE $0xd4   // VPUNPCKLQDQ XMM10, XMM15, XMM12  /*  m[8],  m[0] */
+	LONG $0x6d0941c4; BYTE $0xde   // VPUNPCKHQDQ XMM11, XMM14, XMM14  /*   ___, m[13] */
+	LONG $0x6c1141c4; BYTE $0xdb   // VPUNPCKLQDQ XMM11, XMM13, XMM11  /*  m[2],   ___ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12               // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X13               // X13 =  m[6]+ m[7]
+	MOVOU 64(DX), X14               // X14 =  m[8]+ m[9]
+	MOVOU 80(DX), X15               // X15 = m[10]+m[11]
+	LONG  $0x6d1941c4; BYTE $0xc4   // VPUNPCKHQDQ  XMM8, XMM12, XMM12  /*   ___, m[3] */
+	LONG  $0x6c0141c4; BYTE $0xc0   // VPUNPCKLQDQ  XMM8, XMM15,  XMM8  /* m[10],  ___ */
+	LONG  $0x6d1141c4; BYTE $0xce   // VPUNPCKHQDQ  XMM9, XMM13, XMM14  /*  m[7], m[9] */
+	MOVOU 0(DX), X12                // X12 =  m[0]+ m[1]
+	MOVOU 32(DX), X14               // X14 =  m[4]+ m[5]
+	MOVOU 112(DX), X15              // X15 = m[14]+m[15]
+	LONG  $0x6c0141c4; BYTE $0xd5   // VPUNPCKLQDQ XMM10, XMM15, XMM13  /* m[14], m[6] */
+	LONG  $0x0f0943c4; WORD $0x08dc // VPALIGNR    XMM11, XMM14, XMM12, 0x8  /*  m[1],  m[4] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   4
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12             // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X13             // X13 =  m[6]+ m[7]
+	MOVOU 80(DX), X14             // X14 = m[10]+m[11]
+	MOVOU 96(DX), X15             // X15 = m[12]+m[13]
+	LONG  $0x6d1141c4; BYTE $0xc4 // VPUNPCKHQDQ  XMM8, XMM13, XMM12  /*  m[7],  m[3] */
+	LONG  $0x6d0141c4; BYTE $0xce // VPUNPCKHQDQ  XMM9, XMM15, XMM14  /* m[13], m[11] */
+	MOVOU 0(DX), X12              // X12 =  m[0]+ m[1]
+	MOVOU 64(DX), X13             // X13 =  m[8]+ m[9]
+	MOVOU 112(DX), X14            // X14 = m[14]+m[15]
+	LONG  $0x6d1141c4; BYTE $0xd4 // VPUNPCKHQDQ XMM10, XMM13, XMM12  /*  m[9],  m[1] */
+	LONG  $0x6c0141c4; BYTE $0xde // VPUNPCKLQDQ XMM11, XMM15, XMM14  /* m[12], m[14] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12             // X12 =  m[2]+ m[3]
+	MOVOU 32(DX), X13             // X13 =  m[4]+ m[5]
+	MOVOU 80(DX), X14             // X14 = m[10]+m[11]
+	MOVOU 112(DX), X15            // X15 = m[14]+m[15]
+	LONG  $0x6d1141c4; BYTE $0xc5 // VPUNPCKHQDQ  XMM8, XMM13, XMM13  /*   ___,  m[5] */
+	LONG  $0x6c1941c4; BYTE $0xc0 // VPUNPCKLQDQ  XMM8, XMM12,  XMM8  /*  m[2],  ____ */
+	LONG  $0x6d0141c4; BYTE $0xcf // VPUNPCKHQDQ  XMM9, XMM15, XMM15  /*   ___, m[15] */
+	LONG  $0x6c1141c4; BYTE $0xc9 // VPUNPCKLQDQ  XMM9, XMM13,  XMM9  /*  m[4],  ____ */
+	MOVOU 0(DX), X12              // X12 =  m[0]+ m[1]
+	MOVOU 48(DX), X13             // X13 =  m[6]+ m[7]
+	MOVOU 64(DX), X15             // X15 =  m[8]+ m[9]
+	LONG  $0x6c1141c4; BYTE $0xd6 // VPUNPCKLQDQ XMM10, XMM13, XMM14  /*  m[6], m[10] */
+	LONG  $0x6c1941c4; BYTE $0xdf // VPUNPCKLQDQ XMM11, XMM12, XMM15  /*  m[0],  m[8] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   5
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12            // X12 =  m[2]+ m[3]
+	MOVOU 32(DX), X13            // X13 =  m[4]+ m[5]
+	MOVOU 64(DX), X14            // X14 =  m[8]+ m[9]
+	MOVOU 80(DX), X15            // X15 = m[10]+m[11]
+	LONG $0x6d0941c4; BYTE $0xc5 // VPUNPCKHQDQ  XMM8, XMM14, XMM13  /*  m[9],  m[5] */
+	LONG $0x6c1941c4; BYTE $0xcf // VPUNPCKLQDQ  XMM9, XMM12, XMM15  /*  m[2], m[10] */
+	MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+	MOVOU 48(DX), X14            // X14 =  m[6]+ m[7]
+	MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+	LONG $0x6d0941c4; BYTE $0xd6 // VPUNPCKHQDQ XMM10, XMM14, XMM14  /*   ___,  m[7] */
+	LONG $0x6c1941c4; BYTE $0xd2 // VPUNPCKLQDQ XMM10, XMM12, XMM10  /*  m[0],  ____ */
+	LONG $0x6d0141c4; BYTE $0xdf // VPUNPCKHQDQ XMM11, XMM15, XMM15  /*   ___, m[15] */
+	LONG $0x6c1141c4; BYTE $0xdb // VPUNPCKLQDQ XMM11, XMM13, XMM11  /*  m[4],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12              // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X13              // X13 =  m[6]+ m[7]
+	MOVOU 80(DX), X14              // X14 = m[10]+m[11]
+	MOVOU 112(DX), X15             // X15 = m[14]+m[15]
+	LONG $0x6d0941c4; BYTE $0xc6   // VPUNPCKHQDQ  XMM8, XMM14, XMM14  /*   ___, m[11] */
+	LONG $0x6c0141c4; BYTE $0xc0   // VPUNPCKLQDQ  XMM8, XMM15,  XMM8  /* m[14],  ____ */
+	LONG $0x6d1941c4; BYTE $0xcc   // VPUNPCKHQDQ  XMM9, XMM12, XMM12  /*   ___,  m[3] */
+	LONG $0x6c1141c4; BYTE $0xc9   // VPUNPCKLQDQ  XMM9, XMM13,  XMM9  /*  m[6],  ____ */
+	MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+	MOVOU 64(DX), X13              // X13 =  m[8]+ m[9]
+	MOVOU 96(DX), X14              // X14 = m[12]+m[13]
+	LONG $0x0f0943c4; WORD $0x08d4 // VPALIGNR    XMM10, XMM14, XMM12, 0x8  /*  m[1], m[12] */
+	LONG $0x6d0941c4; BYTE $0xde   // VPUNPCKHQDQ XMM11, XMM14, XMM14  /*   ___, m[13] */
+	LONG $0x6c1141c4; BYTE $0xdb   // VPUNPCKLQDQ XMM11, XMM13, XMM11  /*  m[8],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   6
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+	MOVOU 16(DX), X13            // X13 =  m[2]+ m[3]
+	MOVOU 48(DX), X14            // X14 =  m[6]+ m[7]
+	MOVOU 64(DX), X15            // X15 =  m[8]+ m[9]
+	LONG $0x6c1141c4; BYTE $0xc6 // VPUNPCKLQDQ  XMM8, XMM13, XMM14  /*  m[2],  m[6] */
+	LONG $0x6c1941c4; BYTE $0xcf // VPUNPCKLQDQ  XMM9, XMM12, XMM15  /*  m[0],  m[8] */
+	MOVOU 80(DX), X12            // X12 = m[10]+m[11]
+	MOVOU 96(DX), X14            // X14 = m[12]+m[13]
+	LONG $0x6c0941c4; BYTE $0xd4 // VPUNPCKLQDQ XMM10, XMM14, XMM12  /* m[12], m[10] */
+	LONG $0x6d1941c4; BYTE $0xdd // VPUNPCKHQDQ XMM11, XMM12, XMM13  /* m[11],  m[3] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+	MOVOU 32(DX), X13            // X13 =  m[4]+ m[5]
+	MOVOU 48(DX), X14            // X14 =  m[6]+ m[7]
+	MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+	LONG $0x6d0941c4; BYTE $0xc6 // VPUNPCKHQDQ  XMM8, XMM14, XMM14  /*   ___,  m[7] */
+	LONG $0x6c1141c4; BYTE $0xc0 // VPUNPCKLQDQ  XMM8, XMM13,  XMM8  /*  m[4],  ____ */
+	LONG $0x6d0141c4; BYTE $0xcc // VPUNPCKHQDQ  XMM9, XMM15, XMM12  /* m[15],  m[1] */
+	MOVOU 64(DX), X12            // X12 =  m[8]+ m[9]
+	MOVOU 96(DX), X14            // X14 = m[12]+m[13]
+	LONG $0x6d0941c4; BYTE $0xd5 // VPUNPCKHQDQ XMM10, XMM14, XMM13  /* m[13],  m[5] */
+	LONG $0x6d1941c4; BYTE $0xdc // VPUNPCKHQDQ XMM11, XMM12, XMM12  /*   ___,  m[9] */
+	LONG $0x6c0141c4; BYTE $0xdb // VPUNPCKLQDQ XMM11, XMM15, XMM11  /* m[14],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   7
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+	MOVOU 32(DX), X13              // X13 =  m[4]+ m[5]
+	MOVOU 96(DX), X14              // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15             // X15 = m[14]+m[15]
+	LONG $0x6d1941c4; BYTE $0xc4   // VPUNPCKHQDQ  XMM8, XMM12, XMM12  /*   ___,  m[1] */
+	LONG $0x6c0941c4; BYTE $0xc0   // VPUNPCKLQDQ  XMM8, XMM14,  XMM8  /* m[12],  ____ */
+	LONG $0x6c0141c4; BYTE $0xcd   // VPUNPCKLQDQ  XMM9, XMM15, XMM13  /* m[14],  m[4] */
+	MOVOU 80(DX), X12              // X12 = m[10]+m[11]
+	LONG $0x6d1141c4; BYTE $0xd7   // VPUNPCKHQDQ XMM10, XMM13, XMM15  /*  m[5], m[15] */
+	LONG $0x0f1943c4; WORD $0x08de // VPALIGNR    XMM11, XMM12, XMM14, 0x8  /* m[13], m[10] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+	MOVOU 48(DX), X13              // X13 =  m[6]+ m[7]
+	MOVOU 64(DX), X14              // X14 =  m[8]+ m[9]
+	MOVOU 80(DX), X15              // X15 = m[10]+m[11]
+	LONG $0x6c1941c4; BYTE $0xc5   // VPUNPCKLQDQ  XMM8, XMM12, XMM13  /*  m[0],  m[6] */
+	LONG $0x0f0943c4; WORD $0x08ce // VPALIGNR     XMM9, XMM14, XMM14, 0x8  /*  m[9],  m[8] */
+	MOVOU 16(DX), X14              // X14 =  m[2]+ m[3]
+	LONG $0x6d1141c4; BYTE $0xd6   // VPUNPCKHQDQ XMM10, XMM13, XMM14  /*  m[7],  m[3] */
+	LONG $0x6d0141c4; BYTE $0xdf   // VPUNPCKHQDQ XMM11, XMM15, XMM15  /*   ___, m[11] */
+	LONG $0x6c0941c4; BYTE $0xdb   // VPUNPCKLQDQ XMM11, XMM14, XMM11  /*  m[2],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   8
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12              // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X13              // X13 =  m[6]+ m[7]
+	MOVOU 96(DX), X14              // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15             // X15 = m[14]+m[15]
+	LONG $0x6d0941c4; BYTE $0xc5   // VPUNPCKHQDQ  XMM8, XMM14, XMM13  /* m[13],  m[7] */
+	LONG $0x6d1941c4; BYTE $0xcc   // VPUNPCKHQDQ  XMM9, XMM12, XMM12  /*   ___,  m[3] */
+	LONG $0x6c0941c4; BYTE $0xc9   // VPUNPCKLQDQ  XMM9, XMM14,  XMM9  /* m[12],  ____ */
+	MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+	MOVOU 64(DX), X13              // X13 =  m[8]+ m[9]
+	MOVOU 80(DX), X14              // X14 = m[10]+m[11]
+	LONG $0x0f0143c4; WORD $0x08d6 // VPALIGNR    XMM10, XMM15, XMM14, 0x8  /* m[11], m[14] */
+	LONG $0x6d1941c4; BYTE $0xdd   // VPUNPCKHQDQ XMM11, XMM12, XMM13  /*  m[1],  m[9] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12            // X12 =  m[2]+ m[3]
+	MOVOU 32(DX), X13            // X13 =  m[4]+ m[5]
+	MOVOU 64(DX), X14            // X14 =  m[8]+ m[9]
+	MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+	LONG $0x6d1141c4; BYTE $0xc7 // VPUNPCKHQDQ  XMM8, XMM13, XMM15  /*  m[5], m[15] */
+	LONG $0x6c0941c4; BYTE $0xcc // VPUNPCKLQDQ  XMM9, XMM14, XMM12  /*  m[8],  m[2] */
+	MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+	MOVOU 48(DX), X14            // X14 =  m[6]+ m[7]
+	MOVOU 80(DX), X15            // X15 = m[10]+m[11]
+	LONG $0x6c1941c4; BYTE $0xd5 // VPUNPCKLQDQ XMM10, XMM12, XMM13  /*  m[0],  m[4] */
+	LONG $0x6c0941c4; BYTE $0xdf // VPUNPCKLQDQ XMM11, XMM14, XMM15  /*  m[6], m[10] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   9
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+	MOVOU 48(DX), X13              // X13 =  m[6]+ m[7]
+	MOVOU 80(DX), X14              // X14 = m[10]+m[11]
+	MOVOU 112(DX), X15             // X15 = m[14]+m[15]
+	LONG $0x6c1141c4; BYTE $0xc7   // VPUNPCKLQDQ  XMM8, XMM13, XMM15  /*  m[6], m[14] */
+	LONG $0x0f1943c4; WORD $0x08ce // VPALIGNR     XMM9, XMM12, XMM14, 0x8  /* m[11],  m[0] */
+	MOVOU 16(DX), X13              // X13 =  m[2]+ m[3]
+	MOVOU 64(DX), X14              // X14 =  m[8]+ m[9]
+	LONG $0x6d0141c4; BYTE $0xd6   // VPUNPCKHQDQ XMM10, XMM15, XMM14  /* m[15],  m[9] */
+	LONG $0x0f0943c4; WORD $0x08dd // VPALIGNR    XMM11, XMM14, XMM13, 0x8  /*  m[3],  m[8] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+	MOVOU 16(DX), X13              // X13 =  m[2]+ m[3]
+	MOVOU 80(DX), X14              // X14 = m[10]+m[11]
+	MOVOU 96(DX), X15              // X15 = m[12]+m[13]
+	LONG $0x6d0141c4; BYTE $0xc7   // VPUNPCKHQDQ  XMM8, XMM15, XMM15  /*   ___, m[13] */
+	LONG $0x6c0141c4; BYTE $0xc0   // VPUNPCKLQDQ  XMM8, XMM15,  XMM8  /* m[12],  ____ */
+	LONG $0x0f0943c4; WORD $0x08cc // VPALIGNR     XMM9, XMM14, XMM12, 0x8  /*  m[1], m[10] */
+	MOVOU 32(DX), X12              // X12 =  m[4]+ m[5]
+	MOVOU 48(DX), X15              // X15 =  m[6]+ m[7]
+	LONG $0x6d0141c4; BYTE $0xd7   // VPUNPCKHQDQ XMM10, XMM15, XMM15  /*   ___,  m[7] */
+	LONG $0x6c1141c4; BYTE $0xd2   // VPUNPCKLQDQ XMM10, XMM13, XMM10  /*  m[2],  ____ */
+	LONG $0x6d1941c4; BYTE $0xdc   // VPUNPCKHQDQ XMM11, XMM12, XMM12  /*   ___,  m[5] */
+	LONG $0x6c1941c4; BYTE $0xdb   // VPUNPCKLQDQ XMM11, XMM12, XMM11  /*  m[4],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   1 0
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+	MOVOU 48(DX), X13            // X13 =  m[6]+ m[7]
+	MOVOU 64(DX), X14            // X14 =  m[8]+ m[9]
+	MOVOU 80(DX), X15            // X15 = m[10]+m[11]
+	LONG $0x6c0141c4; BYTE $0xc6 // VPUNPCKLQDQ  XMM8, XMM15, XMM14  /* m[10],  m[8] */
+	LONG $0x6d1141c4; BYTE $0xcc // VPUNPCKHQDQ  XMM9, XMM13, XMM12  /*  m[7],  m[1] */
+	MOVOU 16(DX), X12            // X12 =  m[2]+ m[3]
+	MOVOU 32(DX), X14            // X14 =  m[4]+ m[5]
+	LONG $0x6c1941c4; BYTE $0xd6 // VPUNPCKLQDQ XMM10, XMM12, XMM14  /*  m[2],  m[4] */
+	LONG $0x6d0941c4; BYTE $0xde // VPUNPCKHQDQ XMM11, XMM14, XMM14  /*   ___,  m[5] */
+	LONG $0x6c1141c4; BYTE $0xdb // VPUNPCKLQDQ XMM11, XMM13, XMM11  /*  m[6],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12              // X12 =  m[2]+ m[3]
+	MOVOU 64(DX), X13              // X13 =  m[8]+ m[9]
+	MOVOU 96(DX), X14              // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15             // X15 = m[14]+m[15]
+	LONG $0x6d0141c4; BYTE $0xc5   // VPUNPCKHQDQ  XMM8, XMM15, XMM13  /* m[15],  m[9] */
+	LONG $0x6d1941c4; BYTE $0xce   // VPUNPCKHQDQ  XMM9, XMM12, XMM14  /*  m[3], m[13] */
+	MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+	MOVOU 80(DX), X13              // X13 = m[10]+m[11]
+	LONG $0x0f0143c4; WORD $0x08d5 // VPALIGNR    XMM10, XMM15, XMM13, 0x8  /* m[11], m[14] */
+	LONG $0x6c0941c4; BYTE $0xdc   // VPUNPCKLQDQ XMM11, XMM14, XMM12  /* m[12],  m[0] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   1 1
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12             // X12 = m[0]+m[1]
+	MOVOU 16(DX), X13            // X13 = m[2]+m[3]
+	MOVOU 32(DX), X14            // X14 = m[4]+m[5]
+	MOVOU 48(DX), X15            // X15 = m[6]+m[7]
+	LONG $0x6c1941c4; BYTE $0xc5 // VPUNPCKLQDQ  XMM8, XMM12, XMM13  /* m[0], m[2] */
+	LONG $0x6c0941c4; BYTE $0xcf // VPUNPCKLQDQ  XMM9, XMM14, XMM15  /* m[4], m[6] */
+	LONG $0x6d1941c4; BYTE $0xd5 // VPUNPCKHQDQ XMM10, XMM12, XMM13  /* m[1], m[3] */
+	LONG $0x6d0941c4; BYTE $0xdf // VPUNPCKHQDQ XMM11, XMM14, XMM15  /* m[5], m[7] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 64(DX), X12            // X12 =  m[8]+ m[9]
+	MOVOU 80(DX), X13            // X13 = m[10]+m[11]
+	MOVOU 96(DX), X14            // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+	LONG $0x6c1941c4; BYTE $0xc5 // VPUNPCKLQDQ  XMM8, XMM12, XMM13  /*  m[8],m[10] */
+	LONG $0x6c0941c4; BYTE $0xcf // VPUNPCKLQDQ  XMM9, XMM14, XMM15  /* m[12],m[14] */
+	LONG $0x6d1941c4; BYTE $0xd5 // VPUNPCKHQDQ XMM10, XMM12, XMM13  /*  m[9],m[11] */
+	LONG $0x6d0941c4; BYTE $0xdf // VPUNPCKHQDQ XMM11, XMM14, XMM15  /* m[13],m[15] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   1 2
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 112(DX), X12             // X12 = m[14]+m[15]
+	MOVOU 32(DX), X13              // X13 =  m[4]+ m[5]
+	MOVOU 64(DX), X14              // X14 =  m[8]+ m[9]
+	MOVOU 96(DX), X15              // X15 = m[12]+m[13]
+	LONG $0x6c1941c4; BYTE $0xc5   // VPUNPCKLQDQ  XMM8, XMM12, XMM13  /* m[14],  m[4] */
+	LONG $0x6d0941c4; BYTE $0xcf   // VPUNPCKHQDQ  XMM9, XMM14, XMM15  /*  m[9], m[13] */
+	MOVOU 80(DX), X13              // X13 = m[10]+m[11]
+	MOVOU 48(DX), X15              // X15 =  m[6]+ m[7]
+	LONG $0x6c1141c4; BYTE $0xd6   // VPUNPCKLQDQ XMM10, XMM13, XMM14  /* m[10],  m[8] */
+	LONG $0x0f0143c4; WORD $0x08dc // VPALIGNR    XMM11, XMM15, XMM12, 0x8  /* m[15],  m[6] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+	MOVOU 32(DX), X13              // X13 =  m[4]+ m[5]
+	MOVOU 80(DX), X14              // X14 = m[10]+m[11]
+	LONG $0x0f1943c4; WORD $0x08c4 // VPALIGNR     XMM8, XMM12, XMM12, 0x8  /*  m[1],  m[0] */
+	LONG $0x6d0941c4; BYTE $0xcd   // VPUNPCKHQDQ  XMM9, XMM14, XMM13  /* m[11], m[5] */
+	MOVOU 16(DX), X12              // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X13              // X13 =  m[6]+ m[7]
+	MOVOU 96(DX), X14              // X14 = m[12]+m[13]
+	LONG $0x6c0941c4; BYTE $0xd4   // VPUNPCKLQDQ XMM10, XMM14, XMM12  /* m[12], m[2] */
+	LONG $0x6d1141c4; BYTE $0xdc   // VPUNPCKHQDQ XMM11, XMM13, XMM12  /*  m[7], m[3] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	// Reload digest (most current value store in &out)
+	MOVQ  out+144(FP), SI // SI: &in
+	MOVOU 0(SI), X12      // X12 = in[0]+in[1]      /* row1l = LOAD( &S->h[0] ); */
+	MOVOU 16(SI), X13     // X13 = in[2]+in[3]      /* row1h = LOAD( &S->h[2] ); */
+	MOVOU 32(SI), X14     // X14 = in[4]+in[5]      /* row2l = LOAD( &S->h[4] ); */
+	MOVOU 48(SI), X15     // X15 = in[6]+in[7]      /* row2h = LOAD( &S->h[6] ); */
+
+	// Final computations and prepare for storing
+	PXOR X4, X0  // X0 = X0 ^ X4          /* row1l = _mm_xor_si128( row3l, row1l ); */
+	PXOR X5, X1  // X1 = X1 ^ X5          /* row1h = _mm_xor_si128( row3h, row1h ); */
+	PXOR X12, X0 // X0 = X0 ^ X12         /*  STORE( &S->h[0], _mm_xor_si128( LOAD( &S->h[0] ), row1l ) ); */
+	PXOR X13, X1 // X1 = X1 ^ X13         /*  STORE( &S->h[2], _mm_xor_si128( LOAD( &S->h[2] ), row1h ) ); */
+	PXOR X6, X2  // X2 = X2 ^ X6          /*  row2l = _mm_xor_si128( row4l, row2l ); */
+	PXOR X7, X3  // X3 = X3 ^ X7          /*  row2h = _mm_xor_si128( row4h, row2h ); */
+	PXOR X14, X2 // X2 = X2 ^ X14         /*  STORE( &S->h[4], _mm_xor_si128( LOAD( &S->h[4] ), row2l ) ); */
+	PXOR X15, X3 // X3 = X3 ^ X15         /*  STORE( &S->h[6], _mm_xor_si128( LOAD( &S->h[6] ), row2h ) ); */
+
+	// Store digest into &out
+	MOVQ  out+144(FP), SI // SI: &out
+	MOVOU X0, 0(SI)       // out[0]+out[1] = X0
+	MOVOU X1, 16(SI)      // out[2]+out[3] = X1
+	MOVOU X2, 32(SI)      // out[4]+out[5] = X2
+	MOVOU X3, 48(SI)      // out[6]+out[7] = X3
+
+	// Increment message pointer and check if there's more to do
+	ADDQ $128, DX // message += 128
+	SUBQ $1, R8
+	JNZ  loop
+
+complete:
+	RET

vendor/github.com/minio/blake2b-simd/compressSse_amd64.go

@@ -0,0 +1,41 @@
+//+build !noasm
+//+build !appengine
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package blake2b
+
+//go:noescape
+func blockSSELoop(p []uint8, in, iv, t, f, shffle, out []uint64)
+
+func compressSSE(d *digest, p []uint8) {
+	var (
+		in     [8]uint64
+		out    [8]uint64
+		shffle [2]uint64
+	)
+
+	// vector for PSHUFB instruction
+	shffle[0] = 0x0201000706050403
+	shffle[1] = 0x0a09080f0e0d0c0b
+
+	in[0], in[1], in[2], in[3], in[4], in[5], in[6], in[7] = d.h[0], d.h[1], d.h[2], d.h[3], d.h[4], d.h[5], d.h[6], d.h[7]
+
+	blockSSELoop(p, in[:], iv[:], d.t[:], d.f[:], shffle[:], out[:])
+
+	d.h[0], d.h[1], d.h[2], d.h[3], d.h[4], d.h[5], d.h[6], d.h[7] = out[0], out[1], out[2], out[3], out[4], out[5], out[6], out[7]
+}

vendor/github.com/minio/blake2b-simd/compressSse_amd64.s

@@ -0,0 +1,770 @@
+//+build !noasm !appengine
+
+//
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+//
+// Based on SSE implementation from https://github.com/BLAKE2/BLAKE2/blob/master/sse/blake2b.c
+//
+// Use github.com/fwessels/asm2plan9s on this file to assemble instructions to their Plan9 equivalent
+//
+// Assembly code below essentially follows the ROUND macro (see blake2b-round.h) which is defined as:
+//   #define ROUND(r) \
+//     LOAD_MSG_ ##r ##_1(b0, b1); \
+//     G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     LOAD_MSG_ ##r ##_2(b0, b1); \
+//     G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     DIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h); \
+//     LOAD_MSG_ ##r ##_3(b0, b1); \
+//     G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     LOAD_MSG_ ##r ##_4(b0, b1); \
+//     G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     UNDIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h);
+//
+// as well as the go equivalent in https://github.com/dchest/blake2b/blob/master/block.go
+//
+// As in the macro, G1/G2 in the 1st and 2nd half are identical (so literal copy of assembly)
+//
+// Rounds are also the same, except for the loading of the message (and rounds 1 & 11 and
+// rounds 2 & 12 are identical)
+//
+
+#define G1 \
+	\ // G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1);
+	LONG $0xd40f4166; BYTE $0xc0   \ // PADDQ  XMM0,XMM8        /* v0 += m[0], v1 += m[2] */
+	LONG $0xd40f4166; BYTE $0xc9   \ // PADDQ  XMM1,XMM9        /* v2 += m[4], v3 += m[6] */
+	LONG $0xc2d40f66               \ // PADDQ  XMM0,XMM2        /* v0 += v4, v1 += v5 */
+	LONG $0xcbd40f66               \ // PADDQ  XMM1,XMM3        /* v2 += v6, v3 += v7 */
+	LONG $0xf0ef0f66               \ // PXOR   XMM6,XMM0        /* v12 ^= v0, v13 ^= v1 */
+	LONG $0xf9ef0f66               \ // PXOR   XMM7,XMM1        /* v14 ^= v2, v15 ^= v3 */
+	LONG $0xf6700f66; BYTE $0xb1   \ // PSHUFD XMM6,XMM6,0xb1   /* v12 = v12<<(64-32) | v12>>32, v13 = v13<<(64-32) | v13>>32 */
+	LONG $0xff700f66; BYTE $0xb1   \ // PSHUFD XMM7,XMM7,0xb1   /* v14 = v14<<(64-32) | v14>>32, v15 = v15<<(64-32) | v15>>32 */
+	LONG $0xe6d40f66               \ // PADDQ  XMM4,XMM6        /* v8 += v12, v9 += v13  */
+	LONG $0xefd40f66               \ // PADDQ  XMM5,XMM7        /* v10 += v14, v11 += v15 */
+	LONG $0xd4ef0f66               \ // PXOR   XMM2,XMM4        /* v4 ^= v8, v5 ^= v9 */
+	LONG $0xddef0f66               \ // PXOR   XMM3,XMM5        /* v6 ^= v10, v7 ^= v11 */
+	LONG $0x380f4166; WORD $0xd400 \ // PSHUFB XMM2,XMM12       /* v4 = v4<<(64-24) | v4>>24, v5 = v5<<(64-24) | v5>>24 */
+	LONG $0x380f4166; WORD $0xdc00   // PSHUFB XMM3,XMM12       /* v6 = v6<<(64-24) | v6>>24, v7 = v7<<(64-24) | v7>>24 */
+
+#define G2 \
+	\ // G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1);
+	LONG  $0xd40f4166; BYTE $0xc2   \ // PADDQ  XMM0,XMM10        /* v0 += m[1], v1 += m[3] */
+	LONG  $0xd40f4166; BYTE $0xcb   \ // PADDQ  XMM1,XMM11        /* v2 += m[5], v3 += m[7] */
+	LONG  $0xc2d40f66               \ // PADDQ  XMM0,XMM2         /* v0 += v4, v1 += v5 */
+	LONG  $0xcbd40f66               \ // PADDQ  XMM1,XMM3         /* v2 += v6, v3 += v7 */
+	LONG  $0xf0ef0f66               \ // PXOR   XMM6,XMM0         /* v12 ^= v0, v13 ^= v1 */
+	LONG  $0xf9ef0f66               \ // PXOR   XMM7,XMM1         /* v14 ^= v2, v15 ^= v3 */
+	LONG  $0xf6700ff2; BYTE $0x39   \ // PSHUFLW XMM6,XMM6,0x39   /* combined with next ... */
+	LONG  $0xf6700ff3; BYTE $0x39   \ // PSHUFHW XMM6,XMM6,0x39   /* v12 = v12<<(64-16) | v12>>16, v13 = v13<<(64-16) | v13>>16 */
+	LONG  $0xff700ff2; BYTE $0x39   \ // PSHUFLW XMM7,XMM7,0x39   /* combined with next ... */
+	LONG  $0xff700ff3; BYTE $0x39   \ // PSHUFHW XMM7,XMM7,0x39   /* v14 = v14<<(64-16) | v14>>16, v15 = v15<<(64-16) | v15>>16 */
+	LONG  $0xe6d40f66               \ // PADDQ  XMM4,XMM6         /* v8 += v12, v9 += v13 */
+	LONG  $0xefd40f66               \ // PADDQ  XMM5,XMM7         /* v10 += v14, v11 += v15 */
+	LONG  $0xd4ef0f66               \ // PXOR   XMM2,XMM4         /* v4 ^= v8, v5 ^= v9 */
+	LONG  $0xddef0f66               \ // PXOR   XMM3,XMM5         /* v6 ^= v10, v7 ^= v11 */
+	MOVOU X2, X15                   \
+	LONG  $0xd40f4466; BYTE $0xfa   \ // PADDQ  XMM15,XMM2        /* temp reg = reg*2   */
+	LONG  $0xd2730f66; BYTE $0x3f   \ // PSRLQ  XMM2,0x3f         /*      reg = reg>>63 */
+	LONG  $0xef0f4166; BYTE $0xd7   \ // PXOR   XMM2,XMM15        /* ORed together: v4 = v4<<(64-63) | v4>>63, v5 = v5<<(64-63) | v5>>63 */
+	MOVOU X3, X15                   \
+	LONG  $0xd40f4466; BYTE $0xfb   \ // PADDQ XMM15,XMM3         /* temp reg = reg*2   */
+	LONG  $0xd3730f66; BYTE $0x3f   \ // PSRLQ XMM3,0x3f          /*      reg = reg>>63 */
+	LONG  $0xef0f4166; BYTE $0xdf     // PXOR  XMM3,XMM15         /* ORed together: v6 = v6<<(64-63) | v6>>63, v7 = v7<<(64-63) | v7>>63 */
+
+#define DIAGONALIZE \
+	\ // DIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h);
+	MOVOU X6, X13                   \                                     /* t0 = row4l;\                                                            */
+	MOVOU X2, X14                   \                                     /* t1 = row2l;\                                                            */
+	MOVOU X4, X6                    \                                     /* row4l = row3l;\                                                         */
+	MOVOU X5, X4                    \                                     /* row3l = row3h;\                                                         */
+	MOVOU X6, X5                    \                                     /* row3h = row4l;\                                                         */
+	LONG  $0x6c0f4566; BYTE $0xfd   \ // PUNPCKLQDQ XMM15, XMM13          /*                                    _mm_unpacklo_epi64(t0, t0)           */
+	MOVOU X7, X6                    \
+	LONG  $0x6d0f4166; BYTE $0xf7   \ // PUNPCKHQDQ  XMM6, XMM15          /*  row4l = _mm_unpackhi_epi64(row4h,                           ); \       */
+	LONG  $0x6c0f4466; BYTE $0xff   \ // PUNPCKLQDQ XMM15,  XMM7          /*                                 _mm_unpacklo_epi64(row4h, row4h)        */
+	MOVOU X13, X7                   \
+	LONG  $0x6d0f4166; BYTE $0xff   \ // PUNPCKHQDQ  XMM7, XMM15          /*  row4h = _mm_unpackhi_epi64(t0,                                 ); \    */
+	LONG  $0x6c0f4466; BYTE $0xfb   \ // PUNPCKLQDQ XMM15,  XMM3          /*                                    _mm_unpacklo_epi64(row2h, row2h)     */
+	LONG  $0x6d0f4166; BYTE $0xd7   \ // PUNPCKHQDQ  XMM2, XMM15          /*  row2l = _mm_unpackhi_epi64(row2l,                                 ); \ */
+	LONG  $0x6c0f4566; BYTE $0xfe   \ // PUNPCKLQDQ XMM15, XMM14          /*                                    _mm_unpacklo_epi64(t1, t1)           */
+	LONG  $0x6d0f4166; BYTE $0xdf     // PUNPCKHQDQ  XMM3, XMM15          /*  row2h = _mm_unpackhi_epi64(row2h,                           )          */
+
+#define UNDIAGONALIZE \
+	\ // UNDIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h);
+	MOVOU X4, X13                   \                                     /* t0 = row3l;\                                                            */
+	MOVOU X5, X4                    \                                     /* row3l = row3h;\                                                         */
+	MOVOU X13, X5                   \                                     /* row3h = t0;\                                                            */
+	MOVOU X2, X13                   \                                     /* t0 = row2l;\                                                            */
+	MOVOU X6, X14                   \                                     /* t1 = row4l;\                                                            */
+	LONG  $0x6c0f4466; BYTE $0xfa   \ // PUNPCKLQDQ XMM15,  XMM2          /*                                    _mm_unpacklo_epi64(row2l, row2l)     */
+	MOVOU X3, X2                    \
+	LONG  $0x6d0f4166; BYTE $0xd7   \ // PUNPCKHQDQ  XMM2, XMM15          /*  row2l = _mm_unpackhi_epi64(row2h,                                 ); \ */
+	LONG  $0x6c0f4466; BYTE $0xfb   \ // PUNPCKLQDQ XMM15,  XMM3          /*                                 _mm_unpacklo_epi64(row2h, row2h)        */
+	MOVOU X13, X3                   \
+	LONG  $0x6d0f4166; BYTE $0xdf   \ // PUNPCKHQDQ  XMM3, XMM15          /*  row2h = _mm_unpackhi_epi64(t0,                                 ); \    */
+	LONG  $0x6c0f4466; BYTE $0xff   \ // PUNPCKLQDQ XMM15,  XMM7          /*                                    _mm_unpacklo_epi64(row4h, row4h)     */
+	LONG  $0x6d0f4166; BYTE $0xf7   \ // PUNPCKHQDQ  XMM6, XMM15          /*  row4l = _mm_unpackhi_epi64(row4l,                                 ); \ */
+	LONG  $0x6c0f4566; BYTE $0xfe   \ // PUNPCKLQDQ XMM15, XMM14          /*                                    _mm_unpacklo_epi64(t1, t1)           */
+	LONG  $0x6d0f4166; BYTE $0xff     // PUNPCKHQDQ  XMM7, XMM15          /*  row4h = _mm_unpackhi_epi64(row4h,                           )          */
+
+#define LOAD_SHUFFLE \
+	\ // Load shuffle value
+	MOVQ  shffle+120(FP), SI \ // SI: &shuffle
+	MOVOU 0(SI), X12           // X12 = 03040506 07000102 0b0c0d0e 0f08090a
+
+// func blockSSELoop(p []uint8, in, iv, t, f, shffle, out []uint64)
+TEXT ·blockSSELoop(SB), 7, $0
+	// REGISTER USE
+	//        R8: loop counter
+	//        DX: message pointer
+	//        SI: temp pointer for loading
+	//  X0 -  X7: v0 - v15
+	//  X8 - X11: m[0] - m[7]
+	//       X12: shuffle value
+	// X13 - X15: temp registers
+
+	// Load digest
+	MOVQ  in+24(FP), SI // SI: &in
+	MOVOU 0(SI), X0     // X0 = in[0]+in[1]      /* row1l = LOAD( &S->h[0] ); */
+	MOVOU 16(SI), X1    // X1 = in[2]+in[3]      /* row1h = LOAD( &S->h[2] ); */
+	MOVOU 32(SI), X2    // X2 = in[4]+in[5]      /* row2l = LOAD( &S->h[4] ); */
+	MOVOU 48(SI), X3    // X3 = in[6]+in[7]      /* row2h = LOAD( &S->h[6] ); */
+
+	// Already store digest into &out (so we can reload it later generically)
+	MOVQ  out+144(FP), SI // SI: &out
+	MOVOU X0, 0(SI)       // out[0]+out[1] = X0
+	MOVOU X1, 16(SI)      // out[2]+out[3] = X1
+	MOVOU X2, 32(SI)      // out[4]+out[5] = X2
+	MOVOU X3, 48(SI)      // out[6]+out[7] = X3
+
+	// Initialize message pointer and loop counter
+	MOVQ message+0(FP), DX     // DX: &p (message)
+	MOVQ message_len+8(FP), R8 // R8: len(message)
+	SHRQ $7, R8                // len(message) / 128
+	CMPQ R8, $0
+	JEQ  complete
+
+loop:
+	// Increment counter
+	MOVQ t+72(FP), SI // SI: &t
+	MOVQ 0(SI), R9
+	ADDQ $128, R9     // /* d.t[0] += BlockSize */
+	MOVQ R9, 0(SI)
+	CMPQ R9, $128     // /* if d.t[0] < BlockSize { */
+	JGE  noincr
+	MOVQ 8(SI), R9
+	ADDQ $1, R9       // /*     d.t[1]++ */
+	MOVQ R9, 8(SI)
+
+noincr:  // /* } */
+
+	// Load initialization vector
+	MOVQ  iv+48(FP), SI // SI: &iv
+	MOVOU 0(SI), X4     // X4 = iv[0]+iv[1]      /* row3l = LOAD( &blake2b_IV[0] ); */
+	MOVOU 16(SI), X5    // X5 = iv[2]+iv[3]      /* row3h = LOAD( &blake2b_IV[2] ); */
+	MOVOU 32(SI), X6    // X6 = iv[4]+iv[5]      /*                        LOAD( &blake2b_IV[4] )                      */
+	MOVOU 48(SI), X7    // X7 = iv[6]+iv[7]      /*                        LOAD( &blake2b_IV[6] )                      */
+	MOVQ  t+72(FP), SI  // SI: &t
+	MOVOU 0(SI), X8     // X8 = t[0]+t[1]        /*                                                LOAD( &S->t[0] )    */
+	PXOR  X8, X6        // X6 = X6 ^ X8          /* row4l = _mm_xor_si128(                       ,                  ); */
+	MOVQ  t+96(FP), SI  // SI: &f
+	MOVOU 0(SI), X8     // X8 = f[0]+f[1]        /*                                                LOAD( &S->f[0] )    */
+	PXOR  X8, X7        // X7 = X7 ^ X8          /* row4h = _mm_xor_si128(                       ,                  ); */
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   1
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12             // X12 = m[0]+m[1]
+	MOVOU 16(DX), X13            // X13 = m[2]+m[3]
+	MOVOU 32(DX), X14            // X14 = m[4]+m[5]
+	MOVOU 48(DX), X15            // X15 = m[6]+m[7]
+	MOVOU X12, X8
+	LONG $0x6c0f4566; BYTE $0xc5 // PUNPCKLQDQ  XMM8, XMM13  /* m[0], m[2] */
+	MOVOU X14, X9
+	LONG $0x6c0f4566; BYTE $0xcf // PUNPCKLQDQ  XMM9, XMM15  /* m[4], m[6] */
+	MOVOU X12, X10
+	LONG $0x6d0f4566; BYTE $0xd5 // PUNPCKHQDQ XMM10, XMM13  /* m[1], m[3] */
+	MOVOU X14, X11
+	LONG $0x6d0f4566; BYTE $0xdf // PUNPCKHQDQ XMM11, XMM15  /* m[5], m[7] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 64(DX), X12            // X12 =  m[8]+ m[9]
+	MOVOU 80(DX), X13            // X13 = m[10]+m[11]
+	MOVOU 96(DX), X14            // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+	MOVOU X12, X8
+	LONG $0x6c0f4566; BYTE $0xc5 // PUNPCKLQDQ  XMM8, XMM13  /*  m[8],m[10] */
+	MOVOU X14, X9
+	LONG $0x6c0f4566; BYTE $0xcf // PUNPCKLQDQ  XMM9, XMM15  /* m[12],m[14] */
+	MOVOU X12, X10
+	LONG $0x6d0f4566; BYTE $0xd5 // PUNPCKHQDQ XMM10, XMM13  /*  m[9],m[11] */
+	MOVOU X14, X11
+	LONG $0x6d0f4566; BYTE $0xdf // PUNPCKHQDQ XMM11, XMM15  /* m[13],m[15] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   2
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 112(DX), X12                         // X12 = m[14]+m[15]
+	MOVOU 32(DX), X13                          // X13 =  m[4]+ m[5]
+	MOVOU 64(DX), X14                          // X14 =  m[8]+ m[9]
+	MOVOU 96(DX), X15                          // X15 = m[12]+m[13]
+	MOVOU X12, X8
+	LONG $0x6c0f4566; BYTE $0xc5               // PUNPCKLQDQ  XMM8, XMM13  /* m[14],  m[4] */
+	MOVOU X14, X9
+	LONG $0x6d0f4566; BYTE $0xcf               // PUNPCKHQDQ  XMM9, XMM15  /*  m[9], m[13] */
+	MOVOU 80(DX), X10                          // X10 = m[10]+m[11]
+	MOVOU 48(DX), X11                          // X11 =  m[6]+ m[7]
+	LONG $0x6c0f4566; BYTE $0xd6               // PUNPCKLQDQ XMM10, XMM14  /* m[10],  m[8] */
+	LONG $0x3a0f4566; WORD $0xdc0f; BYTE $0x08 // PALIGNR    XMM11, XMM12, 0x8  /* m[15],  m[6] */; ; ; ; ;
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+	MOVOU 32(DX), X13                          // X13 =  m[4]+ m[5]
+	MOVOU 80(DX), X14                          // X14 = m[10]+m[11]
+	MOVOU X12, X8
+	LONG $0x3a0f4566; WORD $0xc40f; BYTE $0x08 // PALIGNR     XMM8, XMM12, 0x8  /*  m[1],  m[0] */
+	MOVOU X14, X9
+	LONG $0x6d0f4566; BYTE $0xcd               // PUNPCKHQDQ  XMM9, XMM13  /* m[11], m[5] */
+	MOVOU 16(DX), X12                          // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X11                          // X11 =  m[6]+ m[7]
+	MOVOU 96(DX), X10                          // X10 = m[12]+m[13]
+	LONG $0x6c0f4566; BYTE $0xd4               // PUNPCKLQDQ XMM10, XMM12  /* m[12], m[2] */
+	LONG $0x6d0f4566; BYTE $0xdc               // PUNPCKHQDQ XMM11, XMM12  /*  m[7], m[3] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   3
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 32(DX), X12                          // X12 =  m[4]+ m[5]
+	MOVOU 80(DX), X13                          // X13 = m[10]+m[11]
+	MOVOU 96(DX), X14                          // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15                         // X15 = m[14]+m[15]
+	MOVOU X14, X8
+	LONG $0x3a0f4566; WORD $0xc50f; BYTE $0x08 // PALIGNR     XMM8, XMM13, 0x8  /* m[11],  m[12] */
+	MOVOU X12, X9
+	LONG $0x6d0f4566; BYTE $0xcf               // PUNPCKHQDQ  XMM9, XMM15  /*  m[5], m[15] */
+	MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+	MOVOU 16(DX), X13                          // X13 =  m[2]+ m[3]
+	MOVOU 64(DX), X10                          // X10 =  m[8]+ m[9]
+	LONG $0x6c0f4566; BYTE $0xd4               // PUNPCKLQDQ XMM10, XMM12  /*  m[8],  m[0] */
+	LONG $0x6d0f4566; BYTE $0xf6               // PUNPCKHQDQ XMM14, XMM14  /*   ___, m[13] */
+	MOVOU X13, X11
+	LONG $0x6c0f4566; BYTE $0xde               // PUNPCKLQDQ XMM11, XMM14  /*  m[2],   ___ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12                          // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X13                          // X13 =  m[6]+ m[7]
+	MOVOU 64(DX), X14                          // X14 =  m[8]+ m[9]
+	MOVOU 80(DX), X15                          // X15 = m[10]+m[11]
+	MOVOU X12, X9
+	LONG $0x6d0f4566; BYTE $0xcc               // PUNPCKHQDQ  XMM9, XMM12  /*   ___, m[3] */
+	MOVOU X15, X8
+	LONG $0x6c0f4566; BYTE $0xc1               // PUNPCKLQDQ  XMM8,  XMM9  /* m[10],  ___ */
+	MOVOU X13, X9
+	LONG $0x6d0f4566; BYTE $0xce               // PUNPCKHQDQ  XMM9, XMM14  /*  m[7], m[9] */
+	MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+	MOVOU 32(DX), X11                          // X11 =  m[4]+ m[5]
+	MOVOU 112(DX), X10                         // X10 = m[14]+m[15]
+	LONG $0x6c0f4566; BYTE $0xd5               // PUNPCKLQDQ XMM10, XMM13  /* m[14], m[6] */
+	LONG $0x3a0f4566; WORD $0xdc0f; BYTE $0x08 // PALIGNR    XMM11, XMM12, 0x8  /*  m[1],  m[4] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   4
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12            // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X13            // X13 =  m[6]+ m[7]
+	MOVOU 80(DX), X14            // X14 = m[10]+m[11]
+	MOVOU 96(DX), X15            // X15 = m[12]+m[13]
+	MOVOU X13, X8
+	LONG $0x6d0f4566; BYTE $0xc4 // PUNPCKHQDQ  XMM8, XMM12  /*  m[7],  m[3] */
+	MOVOU X15, X9
+	LONG $0x6d0f4566; BYTE $0xce // PUNPCKHQDQ  XMM9, XMM14  /* m[13], m[11] */
+	MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+	MOVOU 64(DX), X10            // X10 =  m[8]+ m[9]
+	MOVOU 112(DX), X14           // X14 = m[14]+m[15]
+	LONG $0x6d0f4566; BYTE $0xd4 // PUNPCKHQDQ XMM10, XMM12  /*  m[9],  m[1] */
+	MOVOU X15, X11
+	LONG $0x6c0f4566; BYTE $0xde // PUNPCKLQDQ XMM11, XMM14  /* m[12], m[14] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12            // X12 =  m[2]+ m[3]
+	MOVOU 32(DX), X13            // X13 =  m[4]+ m[5]
+	MOVOU 80(DX), X14            // X14 = m[10]+m[11]
+	MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+	MOVOU X13, X9
+	LONG $0x6d0f4566; BYTE $0xcd // PUNPCKHQDQ  XMM9, XMM13  /*   ___,  m[5] */
+	MOVOU X12, X8
+	LONG $0x6c0f4566; BYTE $0xc1 // PUNPCKLQDQ  XMM8,  XMM9  /*  m[2],  ____ */
+	MOVOU X15, X10
+	LONG $0x6d0f4566; BYTE $0xd7 // PUNPCKHQDQ XMM10, XMM15  /*   ___, m[15] */
+	MOVOU X13, X9
+	LONG $0x6c0f4566; BYTE $0xca // PUNPCKLQDQ  XMM9, XMM10  /*  m[4],  ____ */
+	MOVOU 0(DX), X11             // X11 =  m[0]+ m[1]
+	MOVOU 48(DX), X10            // X10 =  m[6]+ m[7]
+	MOVOU 64(DX), X15            // X15 =  m[8]+ m[9]
+	LONG $0x6c0f4566; BYTE $0xd6 // PUNPCKLQDQ XMM10, XMM14  /*  m[6], m[10] */
+	LONG $0x6c0f4566; BYTE $0xdf // PUNPCKLQDQ XMM11, XMM15  /*  m[0],  m[8] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   5
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12            // X12 =  m[2]+ m[3]
+	MOVOU 32(DX), X13            // X13 =  m[4]+ m[5]
+	MOVOU 64(DX), X14            // X14 =  m[8]+ m[9]
+	MOVOU 80(DX), X15            // X15 = m[10]+m[11]
+	MOVOU X14, X8
+	LONG $0x6d0f4566; BYTE $0xc5 // PUNPCKHQDQ  XMM8, XMM13  /*  m[9],  m[5] */
+	MOVOU X12, X9
+	LONG $0x6c0f4566; BYTE $0xcf // PUNPCKLQDQ  XMM9, XMM15  /*  m[2], m[10] */
+	MOVOU 0(DX), X10             // X10 =  m[0]+ m[1]
+	MOVOU 48(DX), X14            // X14 =  m[6]+ m[7]
+	MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+	LONG $0x6d0f4566; BYTE $0xf6 // PUNPCKHQDQ XMM14, XMM14  /*   ___,  m[7] */
+	LONG $0x6c0f4566; BYTE $0xd6 // PUNPCKLQDQ XMM10, XMM14  /*  m[0],  ____ */
+	LONG $0x6d0f4566; BYTE $0xff // PUNPCKHQDQ XMM15, XMM15  /*   ___, m[15] */
+	MOVOU X13, X11
+	LONG $0x6c0f4566; BYTE $0xdf // PUNPCKLQDQ XMM11, XMM15  /*  m[4],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12                          // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X13                          // X13 =  m[6]+ m[7]
+	MOVOU 80(DX), X14                          // X14 = m[10]+m[11]
+	MOVOU 112(DX), X15                         // X15 = m[14]+m[15]
+	LONG $0x6d0f4566; BYTE $0xf6               // PUNPCKHQDQ  XMM14, XMM14  /*   ___, m[11] */
+	MOVOU X15, X8
+	LONG $0x6c0f4566; BYTE $0xc6               // PUNPCKLQDQ  XMM8,  XMM14  /* m[14],  ____ */
+	LONG $0x6d0f4566; BYTE $0xe4               // PUNPCKHQDQ  XMM12, XMM12  /*   ___,  m[3] */
+	MOVOU X13, X9
+	LONG $0x6c0f4566; BYTE $0xcc               // PUNPCKLQDQ  XMM9,  XMM12  /*  m[6],  ____ */
+	MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+	MOVOU 64(DX), X11                          // X11 =  m[8]+ m[9]
+	MOVOU 96(DX), X14                          // X14 = m[12]+m[13]
+	MOVOU X14, X10
+	LONG $0x3a0f4566; WORD $0xd40f; BYTE $0x08 // PALIGNR    XMM10, XMM12, 0x8  /*  m[1], m[12] */
+	LONG $0x6d0f4566; BYTE $0xf6               // PUNPCKHQDQ XMM14, XMM14  /*   ___, m[13] */
+	LONG $0x6c0f4566; BYTE $0xde               // PUNPCKLQDQ XMM11, XMM14  /*  m[8],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   6
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+	MOVOU 16(DX), X13            // X13 =  m[2]+ m[3]
+	MOVOU 48(DX), X14            // X14 =  m[6]+ m[7]
+	MOVOU 64(DX), X15            // X15 =  m[8]+ m[9]
+	MOVOU X13, X8
+	LONG $0x6c0f4566; BYTE $0xc6 // PUNPCKLQDQ  XMM8, XMM14  /*  m[2],  m[6] */
+	MOVOU X12, X9
+	LONG $0x6c0f4566; BYTE $0xcf // PUNPCKLQDQ  XMM9, XMM15  /*  m[0],  m[8] */
+	MOVOU 80(DX), X12            // X12 = m[10]+m[11]
+	MOVOU 96(DX), X10            // X10 = m[12]+m[13]
+	LONG $0x6c0f4566; BYTE $0xd4 // PUNPCKLQDQ XMM10, XMM12  /* m[12], m[10] */
+	MOVOU X12, X11
+	LONG $0x6d0f4566; BYTE $0xdd // PUNPCKHQDQ XMM11, XMM13  /* m[11],  m[3] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+	MOVOU 32(DX), X13            // X13 =  m[4]+ m[5]
+	MOVOU 48(DX), X14            // X14 =  m[6]+ m[7]
+	MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+	MOVOU X14, X9
+	LONG $0x6d0f4566; BYTE $0xce // PUNPCKHQDQ  XMM9, XMM14  /*   ___,  m[7] */
+	MOVOU X13, X8
+	LONG $0x6c0f4566; BYTE $0xc1 // PUNPCKLQDQ  XMM8,  XMM9  /*  m[4],  ____ */
+	MOVOU X15, X9
+	LONG $0x6d0f4566; BYTE $0xcc // PUNPCKHQDQ  XMM9, XMM12  /* m[15],  m[1] */
+	MOVOU 64(DX), X12            // X12 =  m[8]+ m[9]
+	MOVOU 96(DX), X10            // X10 = m[12]+m[13]
+	LONG $0x6d0f4566; BYTE $0xd5 // PUNPCKHQDQ XMM10, XMM13  /* m[13],  m[5] */
+	LONG $0x6d0f4566; BYTE $0xe4 // PUNPCKHQDQ XMM12, XMM12  /*   ___,  m[9] */
+	MOVOU X15, X11
+	LONG $0x6c0f4566; BYTE $0xdc // PUNPCKLQDQ XMM11, XMM12  /* m[14],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   7
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+	MOVOU 32(DX), X13                          // X13 =  m[4]+ m[5]
+	MOVOU 96(DX), X14                          // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15                         // X15 = m[14]+m[15]
+	MOVOU X12, X9
+	LONG $0x6d0f4566; BYTE $0xcc               // PUNPCKHQDQ  XMM9, XMM12  /*   ___,  m[1] */
+	MOVOU X14, X8
+	LONG $0x6c0f4566; BYTE $0xc1               // PUNPCKLQDQ  XMM8,  XMM9  /* m[12],  ____ */
+	MOVOU X15, X9
+	LONG $0x6c0f4566; BYTE $0xcd               // PUNPCKLQDQ  XMM9, XMM13  /* m[14],  m[4] */
+	MOVOU 80(DX), X11                          // X11 = m[10]+m[11]
+	MOVOU X13, X10
+	LONG $0x6d0f4566; BYTE $0xd7               // PUNPCKHQDQ XMM10, XMM15  /*  m[5], m[15] */
+	LONG $0x3a0f4566; WORD $0xde0f; BYTE $0x08 // PALIGNR    XMM11, XMM14, 0x8  /* m[13], m[10] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+	MOVOU 48(DX), X13                          // X13 =  m[6]+ m[7]
+	MOVOU 64(DX), X14                          // X14 =  m[8]+ m[9]
+	MOVOU 80(DX), X15                          // X15 = m[10]+m[11]
+	MOVOU X12, X8
+	LONG $0x6c0f4566; BYTE $0xc5               // PUNPCKLQDQ  XMM8, XMM13  /*  m[0],  m[6] */
+	MOVOU X14, X9
+	LONG $0x3a0f4566; WORD $0xce0f; BYTE $0x08 // PALIGNR     XMM9, XMM14, 0x8  /*  m[9],  m[8] */
+	MOVOU 16(DX), X11                          // X14 =  m[2]+ m[3]
+	MOVOU X13, X10
+	LONG $0x6d0f4566; BYTE $0xd3               // PUNPCKHQDQ XMM10, XMM11  /*  m[7],  m[3] */
+	LONG $0x6d0f4566; BYTE $0xff               // PUNPCKHQDQ XMM15, XMM15  /*   ___, m[11] */
+	LONG $0x6c0f4566; BYTE $0xdf               // PUNPCKLQDQ XMM11, XMM15  /*  m[2],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   8
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12                          // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X13                          // X13 =  m[6]+ m[7]
+	MOVOU 96(DX), X14                          // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15                         // X15 = m[14]+m[15]
+	MOVOU X14, X8
+	LONG $0x6d0f4566; BYTE $0xc5               // PUNPCKHQDQ  XMM8, XMM13  /* m[13],  m[7] */
+	MOVOU X12, X10
+	LONG $0x6d0f4566; BYTE $0xd4               // PUNPCKHQDQ XMM10, XMM12  /*   ___,  m[3] */
+	MOVOU X14, X9
+	LONG $0x6c0f4566; BYTE $0xca               // PUNPCKLQDQ  XMM9,  XMM10  /* m[12],  ____ */
+	MOVOU 0(DX), X11                           // X11 =  m[0]+ m[1]
+	MOVOU 64(DX), X13                          // X13 =  m[8]+ m[9]
+	MOVOU 80(DX), X14                          // X14 = m[10]+m[11]
+	MOVOU X15, X10
+	LONG $0x3a0f4566; WORD $0xd60f; BYTE $0x08 // PALIGNR    XMM10, XMM14, 0x8  /* m[11], m[14] */
+	LONG $0x6d0f4566; BYTE $0xdd               // PUNPCKHQDQ XMM11, XMM13  /*  m[1],  m[9] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12            // X12 =  m[2]+ m[3]
+	MOVOU 32(DX), X13            // X13 =  m[4]+ m[5]
+	MOVOU 64(DX), X14            // X14 =  m[8]+ m[9]
+	MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+	MOVOU X13, X8
+	LONG $0x6d0f4566; BYTE $0xc7 // PUNPCKHQDQ  XMM8, XMM15  /*  m[5], m[15] */
+	MOVOU X14, X9
+	LONG $0x6c0f4566; BYTE $0xcc // PUNPCKLQDQ  XMM9, XMM12  /*  m[8],  m[2] */
+	MOVOU 0(DX), X10             // X10 =  m[0]+ m[1]
+	MOVOU 48(DX), X11            // X11 =  m[6]+ m[7]
+	MOVOU 80(DX), X15            // X15 = m[10]+m[11]
+	LONG $0x6c0f4566; BYTE $0xd5 // PUNPCKLQDQ XMM10, XMM13  /*  m[0],  m[4] */
+	LONG $0x6c0f4566; BYTE $0xdf // PUNPCKLQDQ XMM11, XMM15  /*  m[6], m[10] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   9
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12                            // X12 =  m[0]+ m[1]
+	MOVOU 48(DX), X13                           // X13 =  m[6]+ m[7]
+	MOVOU 80(DX), X14                           // X14 = m[10]+m[11]
+	MOVOU 112(DX), X15                          // X15 = m[14]+m[15]
+	MOVOU X13, X8
+	LONG  $0x6c0f4566; BYTE $0xc7               // PUNPCKLQDQ  XMM8, XMM15  /*  m[6], m[14] */
+	MOVOU X12, X9
+	LONG  $0x3a0f4566; WORD $0xce0f; BYTE $0x08 // PALIGNR     XMM9, XMM14, 0x8  /* m[11],  m[0] */
+	MOVOU 16(DX), X13                           // X13 =  m[2]+ m[3]
+	MOVOU 64(DX), X11                           // X11 =  m[8]+ m[9]
+	MOVOU X15, X10
+	LONG  $0x6d0f4566; BYTE $0xd3               // PUNPCKHQDQ XMM10, XMM11  /* m[15],  m[9] */
+	LONG  $0x3a0f4566; WORD $0xdd0f; BYTE $0x08 // PALIGNR    XMM11, XMM13, 0x8  /*  m[3],  m[8] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+	MOVOU 16(DX), X13                          // X13 =  m[2]+ m[3]
+	MOVOU 80(DX), X14                          // X14 = m[10]+m[11]
+	MOVOU 96(DX), X15                          // X15 = m[12]+m[13]
+	MOVOU X15, X9
+	LONG $0x6d0f4566; BYTE $0xcf               // PUNPCKHQDQ  XMM9, XMM15  /*   ___, m[13] */
+	MOVOU X15, X8
+	LONG $0x6c0f4566; BYTE $0xc1               // PUNPCKLQDQ  XMM8,  XMM9  /* m[12],  ____ */
+	MOVOU X14, X9
+	LONG $0x3a0f4566; WORD $0xcc0f; BYTE $0x08 // PALIGNR     XMM9, XMM12, 0x8  /*  m[1], m[10] */
+	MOVOU 32(DX), X12                          // X12 =  m[4]+ m[5]
+	MOVOU 48(DX), X15                          // X15 =  m[6]+ m[7]
+	MOVOU X15, X11
+	LONG $0x6d0f4566; BYTE $0xdf               // PUNPCKHQDQ XMM11, XMM15  /*   ___,  m[7] */
+	MOVOU X13, X10
+	LONG $0x6c0f4566; BYTE $0xd3               // PUNPCKLQDQ XMM10, XMM11  /*  m[2],  ____ */
+	MOVOU X12, X15
+	LONG $0x6d0f4566; BYTE $0xfc               // PUNPCKHQDQ XMM15, XMM12  /*   ___,  m[5] */
+	MOVOU X12, X11
+	LONG $0x6c0f4566; BYTE $0xdf               // PUNPCKLQDQ XMM11, XMM15  /*  m[4],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   1 0
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+	MOVOU 48(DX), X13            // X13 =  m[6]+ m[7]
+	MOVOU 64(DX), X14            // X14 =  m[8]+ m[9]
+	MOVOU 80(DX), X15            // X15 = m[10]+m[11]
+	MOVOU X15, X8
+	LONG $0x6c0f4566; BYTE $0xc6 // PUNPCKLQDQ  XMM8, XMM14  /* m[10],  m[8] */
+	MOVOU X13, X9
+	LONG $0x6d0f4566; BYTE $0xcc // PUNPCKHQDQ  XMM9, XMM12  /*  m[7],  m[1] */
+	MOVOU 16(DX), X10            // X10 =  m[2]+ m[3]
+	MOVOU 32(DX), X14            // X14 =  m[4]+ m[5]
+	LONG $0x6c0f4566; BYTE $0xd6 // PUNPCKLQDQ XMM10, XMM14  /*  m[2],  m[4] */
+	MOVOU X14, X15
+	LONG $0x6d0f4566; BYTE $0xfe // PUNPCKHQDQ XMM15, XMM14  /*   ___,  m[5] */
+	MOVOU X13, X11
+	LONG $0x6c0f4566; BYTE $0xdf // PUNPCKLQDQ XMM11, XMM15  /*  m[6],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12                          // X12 =  m[2]+ m[3]
+	MOVOU 64(DX), X13                          // X13 =  m[8]+ m[9]
+	MOVOU 96(DX), X14                          // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15                         // X15 = m[14]+m[15]
+	MOVOU X15, X8
+	LONG $0x6d0f4566; BYTE $0xc5               // PUNPCKHQDQ  XMM8, XMM13  /* m[15],  m[9] */
+	MOVOU X12, X9
+	LONG $0x6d0f4566; BYTE $0xce               // PUNPCKHQDQ  XMM9, XMM14  /*  m[3], m[13] */
+	MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+	MOVOU 80(DX), X13                          // X13 = m[10]+m[11]
+	MOVOU X15, X10
+	LONG $0x3a0f4566; WORD $0xd50f; BYTE $0x08 // PALIGNR    XMM10, XMM13, 0x8  /* m[11], m[14] */
+	MOVOU X14, X11
+	LONG $0x6c0f4566; BYTE $0xdc               // PUNPCKLQDQ XMM11, XMM12  /* m[12],  m[0] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   1 1
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12             // X12 = m[0]+m[1]
+	MOVOU 16(DX), X13            // X13 = m[2]+m[3]
+	MOVOU 32(DX), X14            // X14 = m[4]+m[5]
+	MOVOU 48(DX), X15            // X15 = m[6]+m[7]
+	MOVOU X12, X8
+	LONG $0x6c0f4566; BYTE $0xc5 // PUNPCKLQDQ  XMM8, XMM13  /* m[0], m[2] */
+	MOVOU X14, X9
+	LONG $0x6c0f4566; BYTE $0xcf // PUNPCKLQDQ  XMM9, XMM15  /* m[4], m[6] */
+	MOVOU X12, X10
+	LONG $0x6d0f4566; BYTE $0xd5 // PUNPCKHQDQ XMM10, XMM13  /* m[1], m[3] */
+	MOVOU X14, X11
+	LONG $0x6d0f4566; BYTE $0xdf // PUNPCKHQDQ XMM11, XMM15  /* m[5], m[7] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 64(DX), X12            // X12 =  m[8]+ m[9]
+	MOVOU 80(DX), X13            // X13 = m[10]+m[11]
+	MOVOU 96(DX), X14            // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+	MOVOU X12, X8
+	LONG $0x6c0f4566; BYTE $0xc5 // PUNPCKLQDQ  XMM8, XMM13  /*  m[8],m[10] */
+	MOVOU X14, X9
+	LONG $0x6c0f4566; BYTE $0xcf // PUNPCKLQDQ  XMM9, XMM15  /* m[12],m[14] */
+	MOVOU X12, X10
+	LONG $0x6d0f4566; BYTE $0xd5 // PUNPCKHQDQ XMM10, XMM13  /*  m[9],m[11] */
+	MOVOU X14, X11
+	LONG $0x6d0f4566; BYTE $0xdf // PUNPCKHQDQ XMM11, XMM15  /* m[13],m[15] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   1 2
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 112(DX), X12                         // X12 = m[14]+m[15]
+	MOVOU 32(DX), X13                          // X13 =  m[4]+ m[5]
+	MOVOU 64(DX), X14                          // X14 =  m[8]+ m[9]
+	MOVOU 96(DX), X15                          // X15 = m[12]+m[13]
+	MOVOU X12, X8
+	LONG $0x6c0f4566; BYTE $0xc5               // PUNPCKLQDQ  XMM8, XMM13  /* m[14],  m[4] */
+	MOVOU X14, X9
+	LONG $0x6d0f4566; BYTE $0xcf               // PUNPCKHQDQ  XMM9, XMM15  /*  m[9], m[13] */
+	MOVOU 80(DX), X10                          // X10 = m[10]+m[11]
+	MOVOU 48(DX), X11                          // X11 =  m[6]+ m[7]
+	LONG $0x6c0f4566; BYTE $0xd6               // PUNPCKLQDQ XMM10, XMM14  /* m[10],  m[8] */
+	LONG $0x3a0f4566; WORD $0xdc0f; BYTE $0x08 // PALIGNR    XMM11, XMM12, 0x8  /* m[15],  m[6] */; ; ; ; ;
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+	MOVOU 32(DX), X13                          // X13 =  m[4]+ m[5]
+	MOVOU 80(DX), X14                          // X14 = m[10]+m[11]
+	MOVOU X12, X8
+	LONG $0x3a0f4566; WORD $0xc40f; BYTE $0x08 // PALIGNR     XMM8, XMM12, 0x8  /*  m[1],  m[0] */
+	MOVOU X14, X9
+	LONG $0x6d0f4566; BYTE $0xcd               // PUNPCKHQDQ  XMM9, XMM13  /* m[11], m[5] */
+	MOVOU 16(DX), X12                          // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X11                          // X11 =  m[6]+ m[7]
+	MOVOU 96(DX), X10                          // X10 = m[12]+m[13]
+	LONG $0x6c0f4566; BYTE $0xd4               // PUNPCKLQDQ XMM10, XMM12  /* m[12], m[2] */
+	LONG $0x6d0f4566; BYTE $0xdc               // PUNPCKHQDQ XMM11, XMM12  /*  m[7], m[3] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	// Reload digest (most current value store in &out)
+	MOVQ  out+144(FP), SI // SI: &in
+	MOVOU 0(SI), X12      // X12 = in[0]+in[1]      /* row1l = LOAD( &S->h[0] ); */
+	MOVOU 16(SI), X13     // X13 = in[2]+in[3]      /* row1h = LOAD( &S->h[2] ); */
+	MOVOU 32(SI), X14     // X14 = in[4]+in[5]      /* row2l = LOAD( &S->h[4] ); */
+	MOVOU 48(SI), X15     // X15 = in[6]+in[7]      /* row2h = LOAD( &S->h[6] ); */
+
+	// Final computations and prepare for storing
+	PXOR X4, X0  // X0 = X0 ^ X4          /* row1l = _mm_xor_si128( row3l, row1l ); */
+	PXOR X5, X1  // X1 = X1 ^ X5          /* row1h = _mm_xor_si128( row3h, row1h ); */
+	PXOR X12, X0 // X0 = X0 ^ X12         /*  STORE( &S->h[0], _mm_xor_si128( LOAD( &S->h[0] ), row1l ) ); */
+	PXOR X13, X1 // X1 = X1 ^ X13         /*  STORE( &S->h[2], _mm_xor_si128( LOAD( &S->h[2] ), row1h ) ); */
+	PXOR X6, X2  // X2 = X2 ^ X6          /*  row2l = _mm_xor_si128( row4l, row2l ); */
+	PXOR X7, X3  // X3 = X3 ^ X7          /*  row2h = _mm_xor_si128( row4h, row2h ); */
+	PXOR X14, X2 // X2 = X2 ^ X14         /*  STORE( &S->h[4], _mm_xor_si128( LOAD( &S->h[4] ), row2l ) ); */
+	PXOR X15, X3 // X3 = X3 ^ X15         /*  STORE( &S->h[6], _mm_xor_si128( LOAD( &S->h[6] ), row2h ) ); */
+
+	// Store digest into &out
+	MOVQ  out+144(FP), SI // SI: &out
+	MOVOU X0, 0(SI)       // out[0]+out[1] = X0
+	MOVOU X1, 16(SI)      // out[2]+out[3] = X1
+	MOVOU X2, 32(SI)      // out[4]+out[5] = X2
+	MOVOU X3, 48(SI)      // out[6]+out[7] = X3
+
+	// Increment message pointer and check if there's more to do
+	ADDQ $128, DX // message += 128
+	SUBQ $1, R8
+	JNZ  loop
+
+complete:
+	RET

vendor/github.com/minio/blake2b-simd/compress_amd64.go

@@ -0,0 +1,30 @@
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package blake2b
+
+func compress(d *digest, p []uint8) {
+	// Verifies if AVX2 or AVX is available, use optimized code path.
+	if avx2 {
+		compressAVX2(d, p)
+	} else if avx {
+		compressAVX(d, p)
+	} else if ssse3 {
+		compressSSE(d, p)
+	} else {
+		compressGeneric(d, p)
+	}
+}

vendor/github.com/minio/blake2b-simd/compress_noasm.go

@@ -0,0 +1,23 @@
+//+build !amd64 noasm appengine
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package blake2b
+
+func compress(d *digest, p []uint8) {
+	compressGeneric(d, p)
+}

vendor/github.com/minio/blake2b-simd/cpuid.go

@@ -0,0 +1,60 @@
+// +build 386,!gccgo amd64,!gccgo
+
+// Copyright 2016 Frank Wessels <fwessels@xs4all.nl>
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package blake2b
+
+func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
+func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+func xgetbv(index uint32) (eax, edx uint32)
+
+// True when SIMD instructions are available.
+var avx2 = haveAVX2()
+var avx = haveAVX()
+var ssse3 = haveSSSE3()
+
+// haveAVX returns true when there is AVX support
+func haveAVX() bool {
+	_, _, c, _ := cpuid(1)
+
+	// Check XGETBV, OXSAVE and AVX bits
+	if c&(1<<26) != 0 && c&(1<<27) != 0 && c&(1<<28) != 0 {
+		// Check for OS support
+		eax, _ := xgetbv(0)
+		return (eax & 0x6) == 0x6
+	}
+	return false
+}
+
+// haveAVX2 returns true when there is AVX2 support
+func haveAVX2() bool {
+	mfi, _, _, _ := cpuid(0)
+
+	// Check AVX2, AVX2 requires OS support, but BMI1/2 don't.
+	if mfi >= 7 && haveAVX() {
+		_, ebx, _, _ := cpuidex(7, 0)
+		return (ebx & 0x00000020) != 0
+	}
+	return false
+}
+
+// haveSSSE3 returns true when there is SSSE3 support
+func haveSSSE3() bool {
+
+	_, _, c, _ := cpuid(1)
+
+	return (c & 0x00000200) != 0
+}

vendor/github.com/minio/blake2b-simd/cpuid_386.s

@@ -0,0 +1,33 @@
+// Copyright (c) 2015 Klaus Post, released under MIT License. See LICENSE file.
+
+// +build 386,!gccgo
+
+// func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuid(SB), 7, $0
+        XORL CX, CX
+        MOVL op+0(FP), AX
+        CPUID
+        MOVL AX, eax+4(FP)
+        MOVL BX, ebx+8(FP)
+        MOVL CX, ecx+12(FP)
+        MOVL DX, edx+16(FP)
+        RET
+
+// func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuidex(SB), 7, $0
+        MOVL op+0(FP), AX
+        MOVL op2+4(FP), CX
+        CPUID
+        MOVL AX, eax+8(FP)
+        MOVL BX, ebx+12(FP)
+        MOVL CX, ecx+16(FP)
+        MOVL DX, edx+20(FP)
+        RET
+
+// func xgetbv(index uint32) (eax, edx uint32)
+TEXT ·xgetbv(SB), 7, $0
+        MOVL index+0(FP), CX
+        BYTE $0x0f; BYTE $0x01; BYTE $0xd0 // XGETBV
+        MOVL AX, eax+4(FP)
+        MOVL DX, edx+8(FP)
+        RET

vendor/github.com/minio/blake2b-simd/cpuid_amd64.s

@@ -0,0 +1,34 @@
+// Copyright (c) 2015 Klaus Post, released under MIT License. See LICENSE file.
+
+// +build amd64,!gccgo
+
+// func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuid(SB), 7, $0
+        XORQ CX, CX
+        MOVL op+0(FP), AX
+        CPUID
+        MOVL AX, eax+8(FP)
+        MOVL BX, ebx+12(FP)
+        MOVL CX, ecx+16(FP)
+        MOVL DX, edx+20(FP)
+        RET
+
+
+// func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuidex(SB), 7, $0
+        MOVL op+0(FP), AX
+        MOVL op2+4(FP), CX
+        CPUID
+        MOVL AX, eax+8(FP)
+        MOVL BX, ebx+12(FP)
+        MOVL CX, ecx+16(FP)
+        MOVL DX, edx+20(FP)
+        RET
+
+// func xgetbv(index uint32) (eax, edx uint32)
+TEXT ·xgetbv(SB), 7, $0
+        MOVL index+0(FP), CX
+        BYTE $0x0f; BYTE $0x01; BYTE $0xd0 // XGETBV
+        MOVL AX, eax+8(FP)
+        MOVL DX, edx+12(FP)
+        RET

vendor/github.com/minio/sha256-simd/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

vendor/github.com/minio/sha256-simd/README.md

@@ -0,0 +1,133 @@
+# sha256-simd
+
+Accelerate SHA256 computations in pure Go using AVX512, SHA Extensions and AVX2 for Intel and ARM64 for ARM. On AVX512 it provides an up to 8x improvement (over 3 GB/s per core) in comparison to AVX2. SHA Extensions give a performance boost of close to 4x over AVX2.
+
+## Introduction
+
+This package is designed as a replacement for `crypto/sha256`. For Intel CPUs it has two flavors for AVX512 and AVX2 (AVX/SSE are also supported). For ARM CPUs with the Cryptography Extensions, advantage is taken of the SHA2 instructions resulting in a massive performance improvement.
+
+This package uses Golang assembly. The AVX512 version is based on the Intel's "multi-buffer crypto library for IPSec" whereas the other Intel implementations are described in "Fast SHA-256 Implementations on Intel Architecture Processors" by J. Guilford et al.
+
+## New: Support for Intel SHA Extensions
+
+Support for the Intel SHA Extensions has been added by Kristofer Peterson (@svenski123), originally developed for spacemeshos [here](https://github.com/spacemeshos/POET/issues/23). On CPUs that support it (known thus far Intel Celeron J3455 and AMD Ryzen) it gives a significant boost in performance (with thanks to @AudriusButkevicius for reporting the results; full results [here](https://github.com/minio/sha256-simd/pull/37#issuecomment-451607827)).
+
+```
+$ benchcmp avx2.txt sha-ext.txt
+benchmark           AVX2 MB/s    SHA Ext MB/s  speedup
+BenchmarkHash5M     514.40       1975.17       3.84x
+```
+
+Thanks to Kristofer Peterson, we also added additional performance changes such as optimized padding, endian conversions which sped up all implementations i.e. Intel SHA alone while doubled performance for small sizes, the other changes increased everything roughly 50%.
+
+## Support for AVX512
+
+We have added support for AVX512 which results in an up to 8x performance improvement over AVX2 (3.0 GHz Xeon Platinum 8124M CPU):
+
+```
+$ benchcmp avx2.txt avx512.txt
+benchmark           AVX2 MB/s    AVX512 MB/s  speedup
+BenchmarkHash5M     448.62       3498.20      7.80x
+```
+
+The original code was developed by Intel as part of the [multi-buffer crypto library](https://github.com/intel/intel-ipsec-mb) for IPSec or more specifically this [AVX512](https://github.com/intel/intel-ipsec-mb/blob/master/avx512/sha256_x16_avx512.asm) implementation. The key idea behind it is to process a total of 16 checksums in parallel by “transposing” 16 (independent) messages of 64 bytes between a total of 16 ZMM registers (each 64 bytes wide).
+
+Transposing the input messages means that in order to take full advantage of the speedup you need to have a (server) workload where multiple threads are doing SHA256 calculations in parallel. Unfortunately for this algorithm it is not possible for two message blocks processed in parallel to be dependent on one another — because then the (interim) result of the first part of the message has to be an input into the processing of the second part of the message.
+
+Whereas the original Intel C implementation requires some sort of explicit scheduling of messages to be processed in parallel, for Golang it makes sense to take advantage of channels in order to group messages together and use channels as well for sending back the results (thereby effectively decoupling the calculations). We have implemented a fairly simple scheduling mechanism that seems to work well in practice.
+
+Due to this different way of scheduling, we decided to use an explicit method to instantiate the AVX512 version. Essentially one or more AVX512 processing servers ([`Avx512Server`](https://github.com/minio/sha256-simd/blob/master/sha256blockAvx512_amd64.go#L294)) have to be created whereby each server can hash over 3 GB/s on a single core. An `hash.Hash` object ([`Avx512Digest`](https://github.com/minio/sha256-simd/blob/master/sha256blockAvx512_amd64.go#L45)) is then instantiated using one of these servers and used in the regular fashion:
+
+```go
+import "github.com/minio/sha256-simd"
+
+func main() {
+	server := sha256.NewAvx512Server()
+	h512 := sha256.NewAvx512(server)
+	h512.Write(fileBlock)
+	digest := h512.Sum([]byte{})
+}
+```
+
+Note that, because of the scheduling overhead, for small messages (< 1 MB) you will be better off using the regular SHA256 hashing (but those are typically not performance critical anyway). Some other tips to get the best performance:
+* Have many go routines doing SHA256 calculations in parallel.
+* Try to Write() messages in multiples of 64 bytes.
+* Try to keep the overall length of messages to a roughly similar size ie. 5 MB (this way all 16 ‘lanes’ in the AVX512 computations are contributing as much as possible).
+
+More detailed information can be found in this [blog](https://blog.minio.io/accelerate-sha256-up-to-8x-over-3-gb-s-per-core-with-avx512-a0b1d64f78f) post including scaling across cores.
+
+## Drop-In Replacement
+
+The following code snippet shows how you can use `github.com/minio/sha256-simd`. This will automatically select the fastest method for the architecture on which it will be executed.
+
+```go
+import "github.com/minio/sha256-simd"
+
+func main() {
+        ...
+	shaWriter := sha256.New()
+	io.Copy(shaWriter, file)
+        ...
+}
+```
+
+## Performance
+
+Below is the speed in MB/s for a single core (ranked fast to slow) for blocks larger than 1 MB.
+
+| Processor                         | SIMD    | Speed (MB/s) |
+| --------------------------------- | ------- | ------------:|
+| 3.0 GHz Intel Xeon Platinum 8124M | AVX512  |         3498 |
+| 3.7 GHz AMD Ryzen 7 2700X         | SHA Ext |         1979 |
+| 1.2 GHz ARM Cortex-A53            | ARM64   |          638 |
+| 3.0 GHz Intel Xeon Platinum 8124M | AVX2    |          449 |
+| 3.1 GHz Intel Core i7             | AVX     |          362 |
+| 3.1 GHz Intel Core i7             | SSE     |          299 |
+
+## asm2plan9s
+
+In order to be able to work more easily with AVX512/AVX2 instructions, a separate tool was developed to convert SIMD instructions into the corresponding BYTE sequence as accepted by Go assembly. See [asm2plan9s](https://github.com/minio/asm2plan9s) for more information.
+
+## Why and benefits
+
+One of the most performance sensitive parts of the [Minio](https://github.com/minio/minio) object storage server is related to SHA256 hash sums calculations. For instance during multi part uploads each part that is uploaded needs to be verified for data integrity by the server.
+
+Other applications that can benefit from enhanced SHA256 performance are deduplication in storage systems, intrusion detection, version control systems, integrity checking, etc.
+
+## ARM SHA Extensions
+
+The 64-bit ARMv8 core has introduced new instructions for SHA1 and SHA2 acceleration as part of the [Cryptography Extensions](http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0501f/CHDFJBCJ.html). Below you can see a small excerpt highlighting one of the rounds as is done for the SHA256 calculation process (for full code see [sha256block_arm64.s](https://github.com/minio/sha256-simd/blob/master/sha256block_arm64.s)).
+
+ ```
+ sha256h    q2, q3, v9.4s
+ sha256h2   q3, q4, v9.4s
+ sha256su0  v5.4s, v6.4s
+ rev32      v8.16b, v8.16b
+ add        v9.4s, v7.4s, v18.4s
+ mov        v4.16b, v2.16b
+ sha256h    q2, q3, v10.4s
+ sha256h2   q3, q4, v10.4s
+ sha256su0  v6.4s, v7.4s
+ sha256su1  v5.4s, v7.4s, v8.4s
+ ```
+
+### Detailed benchmarks
+
+Benchmarks generated on a 1.2 Ghz Quad-Core ARM Cortex A53 equipped [Pine64](https://www.pine64.com/).
+
+```
+minio@minio-arm:$ benchcmp golang.txt arm64.txt
+benchmark                 golang         arm64        speedup
+BenchmarkHash8Bytes-4     0.68 MB/s      5.70 MB/s      8.38x
+BenchmarkHash1K-4         5.65 MB/s    326.30 MB/s     57.75x
+BenchmarkHash8K-4         6.00 MB/s    570.63 MB/s     95.11x
+BenchmarkHash1M-4         6.05 MB/s    638.23 MB/s    105.49x
+```
+
+## License
+
+Released under the Apache License v2.0. You can find the complete text in the file LICENSE.
+
+## Contributing
+
+Contributions are welcome, please send PRs for any enhancements.

vendor/github.com/minio/sha256-simd/appveyor.yml

@@ -0,0 +1,32 @@
+# version format
+version: "{build}"
+
+# Operating system (build VM template)
+os: Windows Server 2012 R2
+
+# Platform.
+platform: x64
+
+clone_folder: c:\gopath\src\github.com\minio\sha256-simd
+
+# environment variables
+environment:
+  GOPATH: c:\gopath
+  GO15VENDOREXPERIMENT: 1
+
+# scripts that run after cloning repository
+install:
+  - set PATH=%GOPATH%\bin;c:\go\bin;%PATH%
+  - go version
+  - go env
+
+# to run your custom scripts instead of automatic MSBuild
+build_script:
+  - go test .
+  - go test -race .
+
+# to disable automatic tests
+test: off
+
+# to disable deployment
+deploy: off

vendor/github.com/minio/sha256-simd/cpuid.go

@@ -0,0 +1,119 @@
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package sha256
+
+// True when SIMD instructions are available.
+var avx512 bool
+var avx2 bool
+var avx bool
+var sse bool
+var sse2 bool
+var sse3 bool
+var ssse3 bool
+var sse41 bool
+var sse42 bool
+var popcnt bool
+var sha bool
+var armSha = haveArmSha()
+
+func init() {
+	var _xsave bool
+	var _osxsave bool
+	var _avx bool
+	var _avx2 bool
+	var _avx512f bool
+	var _avx512dq bool
+	//	var _avx512pf        bool
+	//	var _avx512er        bool
+	//	var _avx512cd        bool
+	var _avx512bw bool
+	var _avx512vl bool
+	var _sseState bool
+	var _avxState bool
+	var _opmaskState bool
+	var _zmmHI256State bool
+	var _hi16ZmmState bool
+
+	mfi, _, _, _ := cpuid(0)
+
+	if mfi >= 1 {
+		_, _, c, d := cpuid(1)
+
+		sse = (d & (1 << 25)) != 0
+		sse2 = (d & (1 << 26)) != 0
+		sse3 = (c & (1 << 0)) != 0
+		ssse3 = (c & (1 << 9)) != 0
+		sse41 = (c & (1 << 19)) != 0
+		sse42 = (c & (1 << 20)) != 0
+		popcnt = (c & (1 << 23)) != 0
+		_xsave = (c & (1 << 26)) != 0
+		_osxsave = (c & (1 << 27)) != 0
+		_avx = (c & (1 << 28)) != 0
+	}
+
+	if mfi >= 7 {
+		_, b, _, _ := cpuid(7)
+
+		_avx2 = (b & (1 << 5)) != 0
+		_avx512f = (b & (1 << 16)) != 0
+		_avx512dq = (b & (1 << 17)) != 0
+		//		_avx512pf = (b & (1 << 26)) != 0
+		//		_avx512er = (b & (1 << 27)) != 0
+		//		_avx512cd = (b & (1 << 28)) != 0
+		_avx512bw = (b & (1 << 30)) != 0
+		_avx512vl = (b & (1 << 31)) != 0
+		sha = (b & (1 << 29)) != 0
+	}
+
+	// Stop here if XSAVE unsupported or not enabled
+	if !_xsave || !_osxsave {
+		return
+	}
+
+	if _xsave && _osxsave {
+		a, _ := xgetbv(0)
+
+		_sseState = (a & (1 << 1)) != 0
+		_avxState = (a & (1 << 2)) != 0
+		_opmaskState = (a & (1 << 5)) != 0
+		_zmmHI256State = (a & (1 << 6)) != 0
+		_hi16ZmmState = (a & (1 << 7)) != 0
+	} else {
+		_sseState = true
+	}
+
+	// Very unlikely that OS would enable XSAVE and then disable SSE
+	if !_sseState {
+		sse = false
+		sse2 = false
+		sse3 = false
+		ssse3 = false
+		sse41 = false
+		sse42 = false
+	}
+
+	if _avxState {
+		avx = _avx
+		avx2 = _avx2
+	}
+
+	if _opmaskState && _zmmHI256State && _hi16ZmmState {
+		avx512 = (_avx512f &&
+			_avx512dq &&
+			_avx512bw &&
+			_avx512vl)
+	}
+}

vendor/github.com/minio/sha256-simd/cpuid_386.go

@@ -0,0 +1,24 @@
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package sha256
+
+func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
+func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+func xgetbv(index uint32) (eax, edx uint32)
+
+func haveArmSha() bool {
+	return false
+}

vendor/github.com/minio/sha256-simd/cpuid_386.s

@@ -0,0 +1,53 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015 Klaus Post
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// +build 386,!gccgo
+
+// func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuid(SB), 7, $0
+	XORL CX, CX
+	MOVL op+0(FP), AX
+	CPUID
+	MOVL AX, eax+4(FP)
+	MOVL BX, ebx+8(FP)
+	MOVL CX, ecx+12(FP)
+	MOVL DX, edx+16(FP)
+	RET
+
+// func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuidex(SB), 7, $0
+	MOVL op+0(FP), AX
+	MOVL op2+4(FP), CX
+	CPUID
+	MOVL AX, eax+8(FP)
+	MOVL BX, ebx+12(FP)
+	MOVL CX, ecx+16(FP)
+	MOVL DX, edx+20(FP)
+	RET
+
+// func xgetbv(index uint32) (eax, edx uint32)
+TEXT ·xgetbv(SB), 7, $0
+	MOVL index+0(FP), CX
+	BYTE $0x0f; BYTE $0x01; BYTE $0xd0 // XGETBV
+	MOVL AX, eax+4(FP)
+	MOVL DX, edx+8(FP)
+	RET

vendor/github.com/minio/sha256-simd/cpuid_amd64.go

@@ -0,0 +1,24 @@
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package sha256
+
+func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
+func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+func xgetbv(index uint32) (eax, edx uint32)
+
+func haveArmSha() bool {
+	return false
+}

vendor/github.com/minio/sha256-simd/cpuid_amd64.s

@@ -0,0 +1,53 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015 Klaus Post
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// +build amd64,!gccgo
+
+// func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuid(SB), 7, $0
+	XORQ CX, CX
+	MOVL op+0(FP), AX
+	CPUID
+	MOVL AX, eax+8(FP)
+	MOVL BX, ebx+12(FP)
+	MOVL CX, ecx+16(FP)
+	MOVL DX, edx+20(FP)
+	RET
+
+// func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuidex(SB), 7, $0
+	MOVL op+0(FP), AX
+	MOVL op2+4(FP), CX
+	CPUID
+	MOVL AX, eax+8(FP)
+	MOVL BX, ebx+12(FP)
+	MOVL CX, ecx+16(FP)
+	MOVL DX, edx+20(FP)
+	RET
+
+// func xgetbv(index uint32) (eax, edx uint32)
+TEXT ·xgetbv(SB), 7, $0
+	MOVL index+0(FP), CX
+	BYTE $0x0f; BYTE $0x01; BYTE $0xd0 // XGETBV
+	MOVL AX, eax+8(FP)
+	MOVL DX, edx+12(FP)
+	RET

vendor/github.com/minio/sha256-simd/cpuid_arm.go

@@ -0,0 +1,32 @@
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package sha256
+
+func cpuid(op uint32) (eax, ebx, ecx, edx uint32) {
+	return 0, 0, 0, 0
+}
+
+func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32) {
+	return 0, 0, 0, 0
+}
+
+func xgetbv(index uint32) (eax, edx uint32) {
+	return 0, 0
+}
+
+func haveArmSha() bool {
+	return false
+}

vendor/github.com/minio/sha256-simd/cpuid_linux_arm64.go

@@ -0,0 +1,49 @@
+// +build arm64,linux
+
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package sha256
+
+import (
+	"bytes"
+	"io/ioutil"
+)
+
+func cpuid(op uint32) (eax, ebx, ecx, edx uint32) {
+	return 0, 0, 0, 0
+}
+
+func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32) {
+	return 0, 0, 0, 0
+}
+
+func xgetbv(index uint32) (eax, edx uint32) {
+	return 0, 0
+}
+
+// File to check for cpu capabilities.
+const procCPUInfo = "/proc/cpuinfo"
+
+// Feature to check for.
+const sha256Feature = "sha2"
+
+func haveArmSha() bool {
+	cpuInfo, err := ioutil.ReadFile(procCPUInfo)
+	if err != nil {
+		return false
+	}
+	return bytes.Contains(cpuInfo, []byte(sha256Feature))
+}

vendor/github.com/minio/sha256-simd/cpuid_other.go

@@ -0,0 +1,34 @@
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// +build ppc64 ppc64le mips mipsle mips64 mips64le s390x wasm
+
+package sha256
+
+func cpuid(op uint32) (eax, ebx, ecx, edx uint32) {
+	return 0, 0, 0, 0
+}
+
+func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32) {
+	return 0, 0, 0, 0
+}
+
+func xgetbv(index uint32) (eax, edx uint32) {
+	return 0, 0
+}
+
+func haveArmSha() bool {
+	return false
+}

vendor/github.com/minio/sha256-simd/cpuid_others_arm64.go

@@ -0,0 +1,35 @@
+// +build arm64,!linux
+
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package sha256
+
+func cpuid(op uint32) (eax, ebx, ecx, edx uint32) {
+	return 0, 0, 0, 0
+}
+
+func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32) {
+	return 0, 0, 0, 0
+}
+
+func xgetbv(index uint32) (eax, edx uint32) {
+	return 0, 0
+}
+
+// Check for sha2 instruction flag.
+func haveArmSha() bool {
+	return false
+}

vendor/github.com/minio/sha256-simd/go.mod

@@ -0,0 +1 @@
+module github.com/minio/sha256-simd

vendor/github.com/minio/sha256-simd/sha256.go

@@ -0,0 +1,292 @@
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sha256
+
+import (
+	"crypto/sha256"
+	"encoding/binary"
+	"hash"
+	"runtime"
+)
+
+// Size - The size of a SHA256 checksum in bytes.
+const Size = 32
+
+// BlockSize - The blocksize of SHA256 in bytes.
+const BlockSize = 64
+
+const (
+	chunk = BlockSize
+	init0 = 0x6A09E667
+	init1 = 0xBB67AE85
+	init2 = 0x3C6EF372
+	init3 = 0xA54FF53A
+	init4 = 0x510E527F
+	init5 = 0x9B05688C
+	init6 = 0x1F83D9AB
+	init7 = 0x5BE0CD19
+)
+
+// digest represents the partial evaluation of a checksum.
+type digest struct {
+	h   [8]uint32
+	x   [chunk]byte
+	nx  int
+	len uint64
+}
+
+// Reset digest back to default
+func (d *digest) Reset() {
+	d.h[0] = init0
+	d.h[1] = init1
+	d.h[2] = init2
+	d.h[3] = init3
+	d.h[4] = init4
+	d.h[5] = init5
+	d.h[6] = init6
+	d.h[7] = init7
+	d.nx = 0
+	d.len = 0
+}
+
+type blockfuncType int
+
+const (
+	blockfuncGeneric blockfuncType = iota
+	blockfuncAvx512  blockfuncType = iota
+	blockfuncAvx2    blockfuncType = iota
+	blockfuncAvx     blockfuncType = iota
+	blockfuncSsse    blockfuncType = iota
+	blockfuncSha     blockfuncType = iota
+	blockfuncArm     blockfuncType = iota
+)
+
+var blockfunc blockfuncType
+
+func block(dig *digest, p []byte) {
+	if blockfunc == blockfuncSha {
+		blockShaGo(dig, p)
+	} else if blockfunc == blockfuncAvx2 {
+		blockAvx2Go(dig, p)
+	} else if blockfunc == blockfuncAvx {
+		blockAvxGo(dig, p)
+	} else if blockfunc == blockfuncSsse {
+		blockSsseGo(dig, p)
+	} else if blockfunc == blockfuncArm {
+		blockArmGo(dig, p)
+	} else if blockfunc == blockfuncGeneric {
+		blockGeneric(dig, p)
+	}
+}
+
+func init() {
+	is386bit := runtime.GOARCH == "386"
+	isARM := runtime.GOARCH == "arm"
+	switch {
+	case is386bit || isARM:
+		blockfunc = blockfuncGeneric
+	case sha && ssse3 && sse41:
+		blockfunc = blockfuncSha
+	case avx2:
+		blockfunc = blockfuncAvx2
+	case avx:
+		blockfunc = blockfuncAvx
+	case ssse3:
+		blockfunc = blockfuncSsse
+	case armSha:
+		blockfunc = blockfuncArm
+	default:
+		blockfunc = blockfuncGeneric
+	}
+}
+
+// New returns a new hash.Hash computing the SHA256 checksum.
+func New() hash.Hash {
+	if blockfunc != blockfuncGeneric {
+		d := new(digest)
+		d.Reset()
+		return d
+	}
+	// Fallback to the standard golang implementation
+	// if no features were found.
+	return sha256.New()
+}
+
+// Sum256 - single caller sha256 helper
+func Sum256(data []byte) (result [Size]byte) {
+	var d digest
+	d.Reset()
+	d.Write(data)
+	result = d.checkSum()
+	return
+}
+
+// Return size of checksum
+func (d *digest) Size() int { return Size }
+
+// Return blocksize of checksum
+func (d *digest) BlockSize() int { return BlockSize }
+
+// Write to digest
+func (d *digest) Write(p []byte) (nn int, err error) {
+	nn = len(p)
+	d.len += uint64(nn)
+	if d.nx > 0 {
+		n := copy(d.x[d.nx:], p)
+		d.nx += n
+		if d.nx == chunk {
+			block(d, d.x[:])
+			d.nx = 0
+		}
+		p = p[n:]
+	}
+	if len(p) >= chunk {
+		n := len(p) &^ (chunk - 1)
+		block(d, p[:n])
+		p = p[n:]
+	}
+	if len(p) > 0 {
+		d.nx = copy(d.x[:], p)
+	}
+	return
+}
+
+// Return sha256 sum in bytes
+func (d *digest) Sum(in []byte) []byte {
+	// Make a copy of d0 so that caller can keep writing and summing.
+	d0 := *d
+	hash := d0.checkSum()
+	return append(in, hash[:]...)
+}
+
+// Intermediate checksum function
+func (d *digest) checkSum() (digest [Size]byte) {
+	n := d.nx
+
+	var k [64]byte
+	copy(k[:], d.x[:n])
+
+	k[n] = 0x80
+
+	if n >= 56 {
+		block(d, k[:])
+
+		// clear block buffer - go compiles this to optimal 1x xorps + 4x movups
+		// unfortunately expressing this more succinctly results in much worse code
+		k[0] = 0
+		k[1] = 0
+		k[2] = 0
+		k[3] = 0
+		k[4] = 0
+		k[5] = 0
+		k[6] = 0
+		k[7] = 0
+		k[8] = 0
+		k[9] = 0
+		k[10] = 0
+		k[11] = 0
+		k[12] = 0
+		k[13] = 0
+		k[14] = 0
+		k[15] = 0
+		k[16] = 0
+		k[17] = 0
+		k[18] = 0
+		k[19] = 0
+		k[20] = 0
+		k[21] = 0
+		k[22] = 0
+		k[23] = 0
+		k[24] = 0
+		k[25] = 0
+		k[26] = 0
+		k[27] = 0
+		k[28] = 0
+		k[29] = 0
+		k[30] = 0
+		k[31] = 0
+		k[32] = 0
+		k[33] = 0
+		k[34] = 0
+		k[35] = 0
+		k[36] = 0
+		k[37] = 0
+		k[38] = 0
+		k[39] = 0
+		k[40] = 0
+		k[41] = 0
+		k[42] = 0
+		k[43] = 0
+		k[44] = 0
+		k[45] = 0
+		k[46] = 0
+		k[47] = 0
+		k[48] = 0
+		k[49] = 0
+		k[50] = 0
+		k[51] = 0
+		k[52] = 0
+		k[53] = 0
+		k[54] = 0
+		k[55] = 0
+		k[56] = 0
+		k[57] = 0
+		k[58] = 0
+		k[59] = 0
+		k[60] = 0
+		k[61] = 0
+		k[62] = 0
+		k[63] = 0
+	}
+	binary.BigEndian.PutUint64(k[56:64], uint64(d.len)<<3)
+	block(d, k[:])
+
+	{
+		const i = 0
+		binary.BigEndian.PutUint32(digest[i*4:i*4+4], d.h[i])
+	}
+	{
+		const i = 1
+		binary.BigEndian.PutUint32(digest[i*4:i*4+4], d.h[i])
+	}
+	{
+		const i = 2
+		binary.BigEndian.PutUint32(digest[i*4:i*4+4], d.h[i])
+	}
+	{
+		const i = 3
+		binary.BigEndian.PutUint32(digest[i*4:i*4+4], d.h[i])
+	}
+	{
+		const i = 4
+		binary.BigEndian.PutUint32(digest[i*4:i*4+4], d.h[i])
+	}
+	{
+		const i = 5
+		binary.BigEndian.PutUint32(digest[i*4:i*4+4], d.h[i])
+	}
+	{
+		const i = 6
+		binary.BigEndian.PutUint32(digest[i*4:i*4+4], d.h[i])
+	}
+	{
+		const i = 7
+		binary.BigEndian.PutUint32(digest[i*4:i*4+4], d.h[i])
+	}
+
+	return
+}

vendor/github.com/minio/sha256-simd/sha256blockAvx2_amd64.go

@@ -0,0 +1,22 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sha256
+
+//go:noescape
+func blockAvx2(h []uint32, message []uint8)

vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.asm

@@ -0,0 +1,686 @@
+
+// 16x Parallel implementation of SHA256 for AVX512
+
+//
+// Minio Cloud Storage, (C) 2017 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//
+// This code is based on the Intel Multi-Buffer Crypto for IPSec library
+// and more specifically the following implementation:
+// https://github.com/intel/intel-ipsec-mb/blob/master/avx512/sha256_x16_avx512.asm
+//
+// For Golang it has been converted into Plan 9 assembly with the help of
+// github.com/minio/asm2plan9s to assemble the AVX512 instructions
+//
+
+// Copyright (c) 2017, Intel Corporation
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+//     * Redistributions of source code must retain the above copyright notice,
+//       this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of Intel Corporation nor the names of its contributors
+//       may be used to endorse or promote products derived from this software
+//       without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#define SHA256_DIGEST_ROW_SIZE 64
+
+// arg1
+#define STATE rdi
+#define STATE_P9 DI
+// arg2
+#define INP_SIZE rsi
+#define INP_SIZE_P9 SI
+
+#define IDX rcx
+#define TBL rdx
+#define TBL_P9 DX
+
+#define INPUT rax
+#define INPUT_P9 AX
+
+#define inp0	r9
+#define SCRATCH_P9 R12
+#define SCRATCH  r12
+#define maskp    r13
+#define MASKP_P9 R13
+#define mask     r14
+#define MASK_P9  R14
+
+#define A       zmm0
+#define B       zmm1
+#define C       zmm2
+#define D       zmm3
+#define E       zmm4
+#define F       zmm5
+#define G       zmm6
+#define H       zmm7
+#define T1      zmm8
+#define TMP0    zmm9
+#define TMP1    zmm10
+#define TMP2    zmm11
+#define TMP3    zmm12
+#define TMP4    zmm13
+#define TMP5    zmm14
+#define TMP6    zmm15
+
+#define W0      zmm16
+#define W1      zmm17
+#define W2      zmm18
+#define W3      zmm19
+#define W4      zmm20
+#define W5      zmm21
+#define W6      zmm22
+#define W7      zmm23
+#define W8      zmm24
+#define W9      zmm25
+#define W10     zmm26
+#define W11     zmm27
+#define W12     zmm28
+#define W13     zmm29
+#define W14     zmm30
+#define W15     zmm31
+
+
+#define TRANSPOSE16(_r0, _r1, _r2, _r3, _r4, _r5, _r6, _r7, _r8, _r9, _r10, _r11, _r12, _r13, _r14, _r15, _t0, _t1) \
+    \
+    \ // input   r0  = {a15 a14 a13 a12   a11 a10  a9  a8    a7  a6  a5  a4    a3  a2  a1  a0}
+    \ //         r1  = {b15 b14 b13 b12   b11 b10  b9  b8    b7  b6  b5  b4    b3  b2  b1  b0}
+    \ //         r2  = {c15 c14 c13 c12   c11 c10  c9  c8    c7  c6  c5  c4    c3  c2  c1  c0}
+    \ //         r3  = {d15 d14 d13 d12   d11 d10  d9  d8    d7  d6  d5  d4    d3  d2  d1  d0}
+    \ //         r4  = {e15 e14 e13 e12   e11 e10  e9  e8    e7  e6  e5  e4    e3  e2  e1  e0}
+    \ //         r5  = {f15 f14 f13 f12   f11 f10  f9  f8    f7  f6  f5  f4    f3  f2  f1  f0}
+    \ //         r6  = {g15 g14 g13 g12   g11 g10  g9  g8    g7  g6  g5  g4    g3  g2  g1  g0}
+    \ //         r7  = {h15 h14 h13 h12   h11 h10  h9  h8    h7  h6  h5  h4    h3  h2  h1  h0}
+    \ //         r8  = {i15 i14 i13 i12   i11 i10  i9  i8    i7  i6  i5  i4    i3  i2  i1  i0}
+    \ //         r9  = {j15 j14 j13 j12   j11 j10  j9  j8    j7  j6  j5  j4    j3  j2  j1  j0}
+    \ //         r10 = {k15 k14 k13 k12   k11 k10  k9  k8    k7  k6  k5  k4    k3  k2  k1  k0}
+    \ //         r11 = {l15 l14 l13 l12   l11 l10  l9  l8    l7  l6  l5  l4    l3  l2  l1  l0}
+    \ //         r12 = {m15 m14 m13 m12   m11 m10  m9  m8    m7  m6  m5  m4    m3  m2  m1  m0}
+    \ //         r13 = {n15 n14 n13 n12   n11 n10  n9  n8    n7  n6  n5  n4    n3  n2  n1  n0}
+    \ //         r14 = {o15 o14 o13 o12   o11 o10  o9  o8    o7  o6  o5  o4    o3  o2  o1  o0}
+    \ //         r15 = {p15 p14 p13 p12   p11 p10  p9  p8    p7  p6  p5  p4    p3  p2  p1  p0}
+    \
+    \ // output  r0  = { p0  o0  n0  m0    l0  k0  j0  i0    h0  g0  f0  e0    d0  c0  b0  a0}
+    \ //         r1  = { p1  o1  n1  m1    l1  k1  j1  i1    h1  g1  f1  e1    d1  c1  b1  a1}
+    \ //         r2  = { p2  o2  n2  m2    l2  k2  j2  i2    h2  g2  f2  e2    d2  c2  b2  a2}
+    \ //         r3  = { p3  o3  n3  m3    l3  k3  j3  i3    h3  g3  f3  e3    d3  c3  b3  a3}
+    \ //         r4  = { p4  o4  n4  m4    l4  k4  j4  i4    h4  g4  f4  e4    d4  c4  b4  a4}
+    \ //         r5  = { p5  o5  n5  m5    l5  k5  j5  i5    h5  g5  f5  e5    d5  c5  b5  a5}
+    \ //         r6  = { p6  o6  n6  m6    l6  k6  j6  i6    h6  g6  f6  e6    d6  c6  b6  a6}
+    \ //         r7  = { p7  o7  n7  m7    l7  k7  j7  i7    h7  g7  f7  e7    d7  c7  b7  a7}
+    \ //         r8  = { p8  o8  n8  m8    l8  k8  j8  i8    h8  g8  f8  e8    d8  c8  b8  a8}
+    \ //         r9  = { p9  o9  n9  m9    l9  k9  j9  i9    h9  g9  f9  e9    d9  c9  b9  a9}
+    \ //         r10 = {p10 o10 n10 m10   l10 k10 j10 i10   h10 g10 f10 e10   d10 c10 b10 a10}
+    \ //         r11 = {p11 o11 n11 m11   l11 k11 j11 i11   h11 g11 f11 e11   d11 c11 b11 a11}
+    \ //         r12 = {p12 o12 n12 m12   l12 k12 j12 i12   h12 g12 f12 e12   d12 c12 b12 a12}
+    \ //         r13 = {p13 o13 n13 m13   l13 k13 j13 i13   h13 g13 f13 e13   d13 c13 b13 a13}
+    \ //         r14 = {p14 o14 n14 m14   l14 k14 j14 i14   h14 g14 f14 e14   d14 c14 b14 a14}
+    \ //         r15 = {p15 o15 n15 m15   l15 k15 j15 i15   h15 g15 f15 e15   d15 c15 b15 a15}
+    \
+    \ // process top half
+    vshufps _t0, _r0, _r1, 0x44      \ // t0 = {b13 b12 a13 a12   b9  b8  a9  a8   b5 b4 a5 a4   b1 b0 a1 a0}
+    vshufps _r0, _r0, _r1, 0xEE      \ // r0 = {b15 b14 a15 a14   b11 b10 a11 a10  b7 b6 a7 a6   b3 b2 a3 a2}
+    vshufps _t1, _r2, _r3, 0x44      \ // t1 = {d13 d12 c13 c12   d9  d8  c9  c8   d5 d4 c5 c4   d1 d0 c1 c0}
+    vshufps _r2, _r2, _r3, 0xEE      \ // r2 = {d15 d14 c15 c14   d11 d10 c11 c10  d7 d6 c7 c6   d3 d2 c3 c2}
+                                     \
+    vshufps	_r3, _t0, _t1, 0xDD      \ // r3 = {d13 c13 b13 a13   d9  c9  b9  a9   d5 c5 b5 a5   d1 c1 b1 a1}
+    vshufps	_r1, _r0, _r2, 0x88      \ // r1 = {d14 c14 b14 a14   d10 c10 b10 a10  d6 c6 b6 a6   d2 c2 b2 a2}
+    vshufps	_r0, _r0, _r2, 0xDD      \ // r0 = {d15 c15 b15 a15   d11 c11 b11 a11  d7 c7 b7 a7   d3 c3 b3 a3}
+    vshufps	_t0, _t0, _t1, 0x88      \ // t0 = {d12 c12 b12 a12   d8  c8  b8  a8   d4 c4 b4 a4   d0 c0 b0 a0}
+                                     \
+    \ // use r2 in place of t0
+    vshufps _r2, _r4, _r5, 0x44      \ // r2 = {f13 f12 e13 e12   f9  f8  e9  e8   f5 f4 e5 e4   f1 f0 e1 e0}
+    vshufps _r4, _r4, _r5, 0xEE      \ // r4 = {f15 f14 e15 e14   f11 f10 e11 e10  f7 f6 e7 e6   f3 f2 e3 e2}
+    vshufps _t1, _r6, _r7, 0x44      \ // t1 = {h13 h12 g13 g12   h9  h8  g9  g8   h5 h4 g5 g4   h1 h0 g1 g0}
+    vshufps _r6, _r6, _r7, 0xEE      \ // r6 = {h15 h14 g15 g14   h11 h10 g11 g10  h7 h6 g7 g6   h3 h2 g3 g2}
+                                     \
+    vshufps _r7, _r2, _t1, 0xDD      \ // r7 = {h13 g13 f13 e13   h9  g9  f9  e9   h5 g5 f5 e5   h1 g1 f1 e1}
+    vshufps _r5, _r4, _r6, 0x88      \ // r5 = {h14 g14 f14 e14   h10 g10 f10 e10  h6 g6 f6 e6   h2 g2 f2 e2}
+    vshufps _r4, _r4, _r6, 0xDD      \ // r4 = {h15 g15 f15 e15   h11 g11 f11 e11  h7 g7 f7 e7   h3 g3 f3 e3}
+    vshufps _r2, _r2, _t1, 0x88      \ // r2 = {h12 g12 f12 e12   h8  g8  f8  e8   h4 g4 f4 e4   h0 g0 f0 e0}
+                                     \
+    \ // use r6 in place of t0
+    vshufps _r6, _r8, _r9,    0x44   \ // r6  = {j13 j12 i13 i12   j9  j8  i9  i8   j5 j4 i5 i4   j1 j0 i1 i0}
+    vshufps _r8, _r8, _r9,    0xEE   \ // r8  = {j15 j14 i15 i14   j11 j10 i11 i10  j7 j6 i7 i6   j3 j2 i3 i2}
+    vshufps _t1, _r10, _r11,  0x44   \ // t1  = {l13 l12 k13 k12   l9  l8  k9  k8   l5 l4 k5 k4   l1 l0 k1 k0}
+    vshufps _r10, _r10, _r11, 0xEE   \ // r10 = {l15 l14 k15 k14   l11 l10 k11 k10  l7 l6 k7 k6   l3 l2 k3 k2}
+                                     \
+    vshufps _r11, _r6, _t1, 0xDD     \ // r11 = {l13 k13 j13 113   l9  k9  j9  i9   l5 k5 j5 i5   l1 k1 j1 i1}
+    vshufps _r9, _r8, _r10, 0x88     \ // r9  = {l14 k14 j14 114   l10 k10 j10 i10  l6 k6 j6 i6   l2 k2 j2 i2}
+    vshufps _r8, _r8, _r10, 0xDD     \ // r8  = {l15 k15 j15 115   l11 k11 j11 i11  l7 k7 j7 i7   l3 k3 j3 i3}
+    vshufps _r6, _r6, _t1,  0x88     \ // r6  = {l12 k12 j12 112   l8  k8  j8  i8   l4 k4 j4 i4   l0 k0 j0 i0}
+                                     \
+    \ // use r10 in place of t0
+    vshufps _r10, _r12, _r13, 0x44   \ // r10 = {n13 n12 m13 m12   n9  n8  m9  m8   n5 n4 m5 m4   n1 n0 a1 m0}
+    vshufps _r12, _r12, _r13, 0xEE   \ // r12 = {n15 n14 m15 m14   n11 n10 m11 m10  n7 n6 m7 m6   n3 n2 a3 m2}
+    vshufps _t1, _r14, _r15,  0x44   \ // t1  = {p13 p12 013 012   p9  p8  09  08   p5 p4 05 04   p1 p0 01 00}
+    vshufps _r14, _r14, _r15, 0xEE   \ // r14 = {p15 p14 015 014   p11 p10 011 010  p7 p6 07 06   p3 p2 03 02}
+                                     \
+    vshufps _r15, _r10, _t1,  0xDD   \ // r15 = {p13 013 n13 m13   p9  09  n9  m9   p5 05 n5 m5   p1 01 n1 m1}
+    vshufps _r13, _r12, _r14, 0x88   \ // r13 = {p14 014 n14 m14   p10 010 n10 m10  p6 06 n6 m6   p2 02 n2 m2}
+    vshufps _r12, _r12, _r14, 0xDD   \ // r12 = {p15 015 n15 m15   p11 011 n11 m11  p7 07 n7 m7   p3 03 n3 m3}
+    vshufps _r10, _r10, _t1,  0x88   \ // r10 = {p12 012 n12 m12   p8  08  n8  m8   p4 04 n4 m4   p0 00 n0 m0}
+                                     \
+    \ // At this point, the registers that contain interesting data are:
+    \ // t0, r3, r1, r0, r2, r7, r5, r4, r6, r11, r9, r8, r10, r15, r13, r12
+    \ // Can use t1 and r14 as scratch registers
+    LEAQ PSHUFFLE_TRANSPOSE16_MASK1<>(SB), BX \
+    LEAQ PSHUFFLE_TRANSPOSE16_MASK2<>(SB), R8 \
+                                     \
+    vmovdqu32 _r14, [rbx]            \
+    vpermi2q  _r14, _t0, _r2         \ // r14 = {h8  g8  f8  e8   d8  c8  b8  a8   h0 g0 f0 e0	 d0 c0 b0 a0}
+    vmovdqu32 _t1,  [r8]             \
+    vpermi2q  _t1,  _t0, _r2         \ // t1  = {h12 g12 f12 e12  d12 c12 b12 a12  h4 g4 f4 e4	 d4 c4 b4 a4}
+                                     \
+    vmovdqu32 _r2, [rbx]             \
+    vpermi2q  _r2, _r3, _r7          \ // r2  = {h9  g9  f9  e9   d9  c9  b9  a9   h1 g1 f1 e1	 d1 c1 b1 a1}
+    vmovdqu32 _t0, [r8]              \
+    vpermi2q  _t0, _r3, _r7          \ // t0  = {h13 g13 f13 e13  d13 c13 b13 a13  h5 g5 f5 e5	 d5 c5 b5 a5}
+                                     \
+    vmovdqu32 _r3, [rbx]             \
+    vpermi2q  _r3, _r1, _r5          \ // r3  = {h10 g10 f10 e10  d10 c10 b10 a10  h2 g2 f2 e2	 d2 c2 b2 a2}
+    vmovdqu32 _r7, [r8]              \
+    vpermi2q  _r7, _r1, _r5          \ // r7  = {h14 g14 f14 e14  d14 c14 b14 a14  h6 g6 f6 e6	 d6 c6 b6 a6}
+                                     \
+    vmovdqu32 _r1, [rbx]             \
+    vpermi2q  _r1, _r0, _r4          \ // r1  = {h11 g11 f11 e11  d11 c11 b11 a11  h3 g3 f3 e3	 d3 c3 b3 a3}
+    vmovdqu32 _r5, [r8]              \
+    vpermi2q  _r5, _r0, _r4          \ // r5  = {h15 g15 f15 e15  d15 c15 b15 a15  h7 g7 f7 e7	 d7 c7 b7 a7}
+                                     \
+    vmovdqu32 _r0, [rbx]             \
+    vpermi2q  _r0, _r6, _r10         \ // r0  = {p8  o8  n8  m8   l8  k8  j8  i8   p0 o0 n0 m0	 l0 k0 j0 i0}
+    vmovdqu32 _r4, [r8]              \
+    vpermi2q  _r4, _r6, _r10         \ // r4  = {p12 o12 n12 m12  l12 k12 j12 i12  p4 o4 n4 m4	 l4 k4 j4 i4}
+                                     \
+    vmovdqu32 _r6, [rbx]             \
+    vpermi2q  _r6, _r11, _r15        \ // r6  = {p9  o9  n9  m9   l9  k9  j9  i9   p1 o1 n1 m1	 l1 k1 j1 i1}
+    vmovdqu32 _r10, [r8]             \
+    vpermi2q  _r10, _r11, _r15       \ // r10 = {p13 o13 n13 m13  l13 k13 j13 i13  p5 o5 n5 m5	 l5 k5 j5 i5}
+                                     \
+    vmovdqu32 _r11, [rbx]            \
+    vpermi2q  _r11, _r9, _r13        \ // r11 = {p10 o10 n10 m10  l10 k10 j10 i10  p2 o2 n2 m2	 l2 k2 j2 i2}
+    vmovdqu32 _r15, [r8]             \
+    vpermi2q  _r15, _r9, _r13        \ // r15 = {p14 o14 n14 m14  l14 k14 j14 i14  p6 o6 n6 m6	 l6 k6 j6 i6}
+                                     \
+    vmovdqu32 _r9, [rbx]             \
+    vpermi2q  _r9, _r8, _r12         \ // r9  = {p11 o11 n11 m11  l11 k11 j11 i11  p3 o3 n3 m3	 l3 k3 j3 i3}
+    vmovdqu32 _r13, [r8]             \
+    vpermi2q  _r13, _r8, _r12        \ // r13 = {p15 o15 n15 m15  l15 k15 j15 i15  p7 o7 n7 m7	 l7 k7 j7 i7}
+                                     \
+    \ // At this point r8 and r12 can be used as scratch registers
+    vshuff64x2 _r8, _r14, _r0, 0xEE  \ // r8  = {p8  o8  n8  m8   l8  k8  j8  i8   h8 g8 f8 e8   d8 c8 b8 a8}
+    vshuff64x2 _r0, _r14, _r0, 0x44  \ // r0  = {p0  o0  n0  m0   l0  k0  j0  i0   h0 g0 f0 e0   d0 c0 b0 a0}
+                                     \
+    vshuff64x2 _r12, _t1, _r4, 0xEE  \ // r12 = {p12 o12 n12 m12  l12 k12 j12 i12  h12 g12 f12 e12  d12 c12 b12 a12}
+    vshuff64x2 _r4, _t1, _r4, 0x44   \ // r4  = {p4  o4  n4  m4   l4  k4  j4  i4   h4 g4 f4 e4   d4 c4 b4 a4}
+                                     \
+    vshuff64x2 _r14, _r7, _r15, 0xEE \ // r14 = {p14 o14 n14 m14  l14 k14 j14 i14  h14 g14 f14 e14  d14 c14 b14 a14}
+    vshuff64x2 _t1, _r7, _r15, 0x44  \ // t1  = {p6  o6  n6  m6   l6  k6  j6  i6   h6 g6 f6 e6   d6 c6 b6 a6}
+                                     \
+    vshuff64x2 _r15, _r5, _r13, 0xEE \ // r15 = {p15 o15 n15 m15  l15 k15 j15 i15  h15 g15 f15 e15  d15 c15 b15 a15}
+    vshuff64x2 _r7, _r5, _r13, 0x44  \ // r7  = {p7  o7  n7  m7   l7  k7  j7  i7   h7 g7 f7 e7   d7 c7 b7 a7}
+                                     \
+    vshuff64x2 _r13, _t0, _r10, 0xEE \ // r13 = {p13 o13 n13 m13  l13 k13 j13 i13  h13 g13 f13 e13  d13 c13 b13 a13}
+    vshuff64x2 _r5, _t0, _r10, 0x44  \ // r5  = {p5  o5  n5  m5   l5  k5  j5  i5   h5 g5 f5 e5   d5 c5 b5 a5}
+                                     \
+    vshuff64x2 _r10, _r3, _r11, 0xEE \ // r10 = {p10 o10 n10 m10  l10 k10 j10 i10  h10 g10 f10 e10  d10 c10 b10 a10}
+    vshuff64x2 _t0, _r3, _r11, 0x44  \ // t0  = {p2  o2  n2  m2   l2  k2  j2  i2   h2 g2 f2 e2   d2 c2 b2 a2}
+                                     \
+    vshuff64x2 _r11, _r1, _r9, 0xEE  \ // r11 = {p11 o11 n11 m11  l11 k11 j11 i11  h11 g11 f11 e11  d11 c11 b11 a11}
+    vshuff64x2 _r3, _r1, _r9, 0x44   \ // r3  = {p3  o3  n3  m3   l3  k3  j3  i3   h3 g3 f3 e3   d3 c3 b3 a3}
+                                     \
+    vshuff64x2 _r9, _r2, _r6, 0xEE   \ // r9  = {p9  o9  n9  m9   l9  k9  j9  i9   h9 g9 f9 e9   d9 c9 b9 a9}
+    vshuff64x2 _r1, _r2, _r6, 0x44   \ // r1  = {p1  o1  n1  m1   l1  k1  j1  i1   h1 g1 f1 e1   d1 c1 b1 a1}
+                                     \
+    vmovdqu32 _r2, _t0               \ // r2  = {p2  o2  n2  m2   l2  k2  j2  i2   h2 g2 f2 e2   d2 c2 b2 a2}
+    vmovdqu32 _r6, _t1               \ // r6  = {p6  o6  n6  m6   l6  k6  j6  i6   h6 g6 f6 e6   d6 c6 b6 a6}
+
+
+//  CH(A, B, C) = (A&B) ^ (~A&C)
+// MAJ(E, F, G) = (E&F) ^ (E&G) ^ (F&G)
+// SIGMA0 = ROR_2  ^ ROR_13 ^ ROR_22
+// SIGMA1 = ROR_6  ^ ROR_11 ^ ROR_25
+// sigma0 = ROR_7  ^ ROR_18 ^ SHR_3
+// sigma1 = ROR_17 ^ ROR_19 ^ SHR_10
+
+// Main processing loop per round
+#define PROCESS_LOOP(_WT, _ROUND, _A, _B, _C, _D, _E, _F, _G, _H)  \
+    \ // T1 = H + SIGMA1(E) + CH(E, F, G) + Kt + Wt
+    \ // T2 = SIGMA0(A) + MAJ(A, B, C)
+    \ // H=G, G=F, F=E, E=D+T1, D=C, C=B, B=A, A=T1+T2
+    \
+    \ // H becomes T2, then add T1 for A
+    \ // D becomes D + T1 for E
+    \
+    vpaddd      T1, _H, TMP3           \ // T1 = H + Kt
+    vmovdqu32   TMP0, _E               \
+    vprord      TMP1, _E, 6            \ // ROR_6(E)
+    vprord      TMP2, _E, 11           \ // ROR_11(E)
+    vprord      TMP3, _E, 25           \ // ROR_25(E)
+    vpternlogd  TMP0, _F, _G, 0xCA     \ // TMP0 = CH(E,F,G)
+    vpaddd      T1, T1, _WT            \ // T1 = T1 + Wt
+    vpternlogd  TMP1, TMP2, TMP3, 0x96 \ // TMP1 = SIGMA1(E)
+    vpaddd      T1, T1, TMP0           \ // T1 = T1 + CH(E,F,G)
+    vpaddd      T1, T1, TMP1           \ // T1 = T1 + SIGMA1(E)
+    vpaddd      _D, _D, T1             \ // D = D + T1
+                                       \
+    vprord      _H, _A, 2              \ // ROR_2(A)
+    vprord      TMP2, _A, 13           \ // ROR_13(A)
+    vprord      TMP3, _A, 22           \ // ROR_22(A)
+    vmovdqu32   TMP0, _A               \
+    vpternlogd  TMP0, _B, _C, 0xE8     \ // TMP0 = MAJ(A,B,C)
+    vpternlogd  _H, TMP2, TMP3, 0x96   \ // H(T2) = SIGMA0(A)
+    vpaddd      _H, _H, TMP0           \ // H(T2) = SIGMA0(A) + MAJ(A,B,C)
+    vpaddd      _H, _H, T1             \ // H(A) = H(T2) + T1
+                                       \
+    vmovdqu32   TMP3, [TBL + ((_ROUND+1)*64)] \ // Next Kt
+
+
+#define MSG_SCHED_ROUND_16_63(_WT, _WTp1, _WTp9, _WTp14) \
+    vprord      TMP4, _WTp14, 17                         \ // ROR_17(Wt-2)
+    vprord      TMP5, _WTp14, 19                         \ // ROR_19(Wt-2)
+    vpsrld      TMP6, _WTp14, 10                         \ // SHR_10(Wt-2)
+    vpternlogd  TMP4, TMP5, TMP6, 0x96                   \ // TMP4 = sigma1(Wt-2)
+                                                         \
+    vpaddd      _WT, _WT, TMP4	                         \ // Wt = Wt-16 + sigma1(Wt-2)
+    vpaddd      _WT, _WT, _WTp9	                         \ // Wt = Wt-16 + sigma1(Wt-2) + Wt-7
+                                                         \
+    vprord      TMP4, _WTp1, 7                           \ // ROR_7(Wt-15)
+    vprord      TMP5, _WTp1, 18                          \ // ROR_18(Wt-15)
+    vpsrld      TMP6, _WTp1, 3                           \ // SHR_3(Wt-15)
+    vpternlogd  TMP4, TMP5, TMP6, 0x96                   \ // TMP4 = sigma0(Wt-15)
+                                                         \
+    vpaddd      _WT, _WT, TMP4	                         \ // Wt = Wt-16 + sigma1(Wt-2) +
+                                                         \ //      Wt-7 + sigma0(Wt-15) +
+
+
+// Note this is reading in a block of data for one lane
+// When all 16 are read, the data must be transposed to build msg schedule
+#define MSG_SCHED_ROUND_00_15(_WT, OFFSET, LABEL)             \
+    TESTQ $(1<<OFFSET), MASK_P9                               \
+    JE    LABEL                                               \
+    MOVQ  OFFSET*24(INPUT_P9), R9                             \
+    vmovups _WT, [inp0+IDX]                                   \
+LABEL:                                                        \
+
+#define MASKED_LOAD(_WT, OFFSET, LABEL) \
+    TESTQ $(1<<OFFSET), MASK_P9         \
+    JE    LABEL                         \
+    MOVQ  OFFSET*24(INPUT_P9), R9       \
+    vmovups _WT,[inp0+IDX]              \
+LABEL:                                  \
+
+TEXT ·sha256_x16_avx512(SB), 7, $0
+    MOVQ  digests+0(FP), STATE_P9       //
+    MOVQ  scratch+8(FP), SCRATCH_P9
+    MOVQ  mask_len+32(FP), INP_SIZE_P9  // number of blocks to process
+    MOVQ  mask+24(FP), MASKP_P9
+    MOVQ (MASKP_P9), MASK_P9
+    kmovq k1, mask
+    LEAQ  inputs+48(FP), INPUT_P9
+
+    // Initialize digests
+    vmovdqu32 A, [STATE + 0*SHA256_DIGEST_ROW_SIZE]
+    vmovdqu32 B, [STATE + 1*SHA256_DIGEST_ROW_SIZE]
+    vmovdqu32 C, [STATE + 2*SHA256_DIGEST_ROW_SIZE]
+    vmovdqu32 D, [STATE + 3*SHA256_DIGEST_ROW_SIZE]
+    vmovdqu32 E, [STATE + 4*SHA256_DIGEST_ROW_SIZE]
+    vmovdqu32 F, [STATE + 5*SHA256_DIGEST_ROW_SIZE]
+    vmovdqu32 G, [STATE + 6*SHA256_DIGEST_ROW_SIZE]
+    vmovdqu32 H, [STATE + 7*SHA256_DIGEST_ROW_SIZE]
+
+    MOVQ  table+16(FP), TBL_P9
+
+    xor IDX, IDX
+
+    // Read in first block of input data
+    MASKED_LOAD( W0,  0, skipInput0)
+    MASKED_LOAD( W1,  1, skipInput1)
+    MASKED_LOAD( W2,  2, skipInput2)
+    MASKED_LOAD( W3,  3, skipInput3)
+    MASKED_LOAD( W4,  4, skipInput4)
+    MASKED_LOAD( W5,  5, skipInput5)
+    MASKED_LOAD( W6,  6, skipInput6)
+    MASKED_LOAD( W7,  7, skipInput7)
+    MASKED_LOAD( W8,  8, skipInput8)
+    MASKED_LOAD( W9,  9, skipInput9)
+    MASKED_LOAD(W10, 10, skipInput10)
+    MASKED_LOAD(W11, 11, skipInput11)
+    MASKED_LOAD(W12, 12, skipInput12)
+    MASKED_LOAD(W13, 13, skipInput13)
+    MASKED_LOAD(W14, 14, skipInput14)
+    MASKED_LOAD(W15, 15, skipInput15)
+
+lloop:
+    LEAQ PSHUFFLE_BYTE_FLIP_MASK<>(SB), TBL_P9
+    vmovdqu32 TMP2, [TBL]
+
+    // Get first K from table
+    MOVQ  table+16(FP), TBL_P9
+    vmovdqu32	TMP3, [TBL]
+
+    // Save digests for later addition
+    vmovdqu32 [SCRATCH + 64*0], A
+    vmovdqu32 [SCRATCH + 64*1], B
+    vmovdqu32 [SCRATCH + 64*2], C
+    vmovdqu32 [SCRATCH + 64*3], D
+    vmovdqu32 [SCRATCH + 64*4], E
+    vmovdqu32 [SCRATCH + 64*5], F
+    vmovdqu32 [SCRATCH + 64*6], G
+    vmovdqu32 [SCRATCH + 64*7], H
+
+    add IDX, 64
+
+    // Transpose input data
+    TRANSPOSE16(W0, W1, W2, W3, W4, W5, W6, W7, W8, W9, W10, W11, W12, W13, W14, W15, TMP0, TMP1)
+
+    vpshufb W0, W0, TMP2
+    vpshufb W1, W1, TMP2
+    vpshufb W2, W2, TMP2
+    vpshufb W3, W3, TMP2
+    vpshufb W4, W4, TMP2
+    vpshufb W5, W5, TMP2
+    vpshufb W6, W6, TMP2
+    vpshufb W7, W7, TMP2
+    vpshufb W8, W8, TMP2
+    vpshufb W9, W9, TMP2
+    vpshufb W10, W10, TMP2
+    vpshufb W11, W11, TMP2
+    vpshufb W12, W12, TMP2
+    vpshufb W13, W13, TMP2
+    vpshufb W14, W14, TMP2
+    vpshufb W15, W15, TMP2
+
+    // MSG Schedule for W0-W15 is now complete in registers
+    // Process first 48 rounds
+    // Calculate next Wt+16 after processing is complete and Wt is unneeded
+
+    PROCESS_LOOP( W0,  0, A, B, C, D, E, F, G, H)
+    MSG_SCHED_ROUND_16_63( W0,  W1,  W9, W14)
+    PROCESS_LOOP( W1,  1, H, A, B, C, D, E, F, G)
+    MSG_SCHED_ROUND_16_63( W1,  W2, W10, W15)
+    PROCESS_LOOP( W2,  2, G, H, A, B, C, D, E, F)
+    MSG_SCHED_ROUND_16_63( W2,  W3, W11,  W0)
+    PROCESS_LOOP( W3,  3, F, G, H, A, B, C, D, E)
+    MSG_SCHED_ROUND_16_63( W3,  W4, W12,  W1)
+    PROCESS_LOOP( W4,  4, E, F, G, H, A, B, C, D)
+    MSG_SCHED_ROUND_16_63( W4,  W5, W13,  W2)
+    PROCESS_LOOP( W5,  5, D, E, F, G, H, A, B, C)
+    MSG_SCHED_ROUND_16_63( W5,  W6, W14,  W3)
+    PROCESS_LOOP( W6,  6, C, D, E, F, G, H, A, B)
+    MSG_SCHED_ROUND_16_63( W6,  W7, W15,  W4)
+    PROCESS_LOOP( W7,  7, B, C, D, E, F, G, H, A)
+    MSG_SCHED_ROUND_16_63( W7,  W8,  W0,  W5)
+    PROCESS_LOOP( W8,  8, A, B, C, D, E, F, G, H)
+    MSG_SCHED_ROUND_16_63( W8,  W9,  W1,  W6)
+    PROCESS_LOOP( W9,  9, H, A, B, C, D, E, F, G)
+    MSG_SCHED_ROUND_16_63( W9, W10,  W2,  W7)
+    PROCESS_LOOP(W10, 10, G, H, A, B, C, D, E, F)
+    MSG_SCHED_ROUND_16_63(W10, W11,  W3,  W8)
+    PROCESS_LOOP(W11, 11, F, G, H, A, B, C, D, E)
+    MSG_SCHED_ROUND_16_63(W11, W12,  W4,  W9)
+    PROCESS_LOOP(W12, 12, E, F, G, H, A, B, C, D)
+    MSG_SCHED_ROUND_16_63(W12, W13,  W5, W10)
+    PROCESS_LOOP(W13, 13, D, E, F, G, H, A, B, C)
+    MSG_SCHED_ROUND_16_63(W13, W14,  W6, W11)
+    PROCESS_LOOP(W14, 14, C, D, E, F, G, H, A, B)
+    MSG_SCHED_ROUND_16_63(W14, W15,  W7, W12)
+    PROCESS_LOOP(W15, 15, B, C, D, E, F, G, H, A)
+    MSG_SCHED_ROUND_16_63(W15,  W0,  W8, W13)
+    PROCESS_LOOP( W0, 16, A, B, C, D, E, F, G, H)
+    MSG_SCHED_ROUND_16_63( W0,  W1,  W9, W14)
+    PROCESS_LOOP( W1, 17, H, A, B, C, D, E, F, G)
+    MSG_SCHED_ROUND_16_63( W1,  W2, W10, W15)
+    PROCESS_LOOP( W2, 18, G, H, A, B, C, D, E, F)
+    MSG_SCHED_ROUND_16_63( W2,  W3, W11,  W0)
+    PROCESS_LOOP( W3, 19, F, G, H, A, B, C, D, E)
+    MSG_SCHED_ROUND_16_63( W3,  W4, W12,  W1)
+    PROCESS_LOOP( W4, 20, E, F, G, H, A, B, C, D)
+    MSG_SCHED_ROUND_16_63( W4,  W5, W13,  W2)
+    PROCESS_LOOP( W5, 21, D, E, F, G, H, A, B, C)
+    MSG_SCHED_ROUND_16_63( W5,  W6, W14,  W3)
+    PROCESS_LOOP( W6, 22, C, D, E, F, G, H, A, B)
+    MSG_SCHED_ROUND_16_63( W6,  W7, W15,  W4)
+    PROCESS_LOOP( W7, 23, B, C, D, E, F, G, H, A)
+    MSG_SCHED_ROUND_16_63( W7,  W8,  W0,  W5)
+    PROCESS_LOOP( W8, 24, A, B, C, D, E, F, G, H)
+    MSG_SCHED_ROUND_16_63( W8,  W9,  W1,  W6)
+    PROCESS_LOOP( W9, 25, H, A, B, C, D, E, F, G)
+    MSG_SCHED_ROUND_16_63( W9, W10,  W2,  W7)
+    PROCESS_LOOP(W10, 26, G, H, A, B, C, D, E, F)
+    MSG_SCHED_ROUND_16_63(W10, W11,  W3,  W8)
+    PROCESS_LOOP(W11, 27, F, G, H, A, B, C, D, E)
+    MSG_SCHED_ROUND_16_63(W11, W12,  W4,  W9)
+    PROCESS_LOOP(W12, 28, E, F, G, H, A, B, C, D)
+    MSG_SCHED_ROUND_16_63(W12, W13,  W5, W10)
+    PROCESS_LOOP(W13, 29, D, E, F, G, H, A, B, C)
+    MSG_SCHED_ROUND_16_63(W13, W14,  W6, W11)
+    PROCESS_LOOP(W14, 30, C, D, E, F, G, H, A, B)
+    MSG_SCHED_ROUND_16_63(W14, W15,  W7, W12)
+    PROCESS_LOOP(W15, 31, B, C, D, E, F, G, H, A)
+    MSG_SCHED_ROUND_16_63(W15,  W0,  W8, W13)
+    PROCESS_LOOP( W0, 32, A, B, C, D, E, F, G, H)
+    MSG_SCHED_ROUND_16_63( W0,  W1,  W9, W14)
+    PROCESS_LOOP( W1, 33, H, A, B, C, D, E, F, G)
+    MSG_SCHED_ROUND_16_63( W1,  W2, W10, W15)
+    PROCESS_LOOP( W2, 34, G, H, A, B, C, D, E, F)
+    MSG_SCHED_ROUND_16_63( W2,  W3, W11,  W0)
+    PROCESS_LOOP( W3, 35, F, G, H, A, B, C, D, E)
+    MSG_SCHED_ROUND_16_63( W3,  W4, W12,  W1)
+    PROCESS_LOOP( W4, 36, E, F, G, H, A, B, C, D)
+    MSG_SCHED_ROUND_16_63( W4,  W5, W13,  W2)
+    PROCESS_LOOP( W5, 37, D, E, F, G, H, A, B, C)
+    MSG_SCHED_ROUND_16_63( W5,  W6, W14,  W3)
+    PROCESS_LOOP( W6, 38, C, D, E, F, G, H, A, B)
+    MSG_SCHED_ROUND_16_63( W6,  W7, W15,  W4)
+    PROCESS_LOOP( W7, 39, B, C, D, E, F, G, H, A)
+    MSG_SCHED_ROUND_16_63( W7,  W8,  W0,  W5)
+    PROCESS_LOOP( W8, 40, A, B, C, D, E, F, G, H)
+    MSG_SCHED_ROUND_16_63( W8,  W9,  W1,  W6)
+    PROCESS_LOOP( W9, 41, H, A, B, C, D, E, F, G)
+    MSG_SCHED_ROUND_16_63( W9, W10,  W2,  W7)
+    PROCESS_LOOP(W10, 42, G, H, A, B, C, D, E, F)
+    MSG_SCHED_ROUND_16_63(W10, W11,  W3,  W8)
+    PROCESS_LOOP(W11, 43, F, G, H, A, B, C, D, E)
+    MSG_SCHED_ROUND_16_63(W11, W12,  W4,  W9)
+    PROCESS_LOOP(W12, 44, E, F, G, H, A, B, C, D)
+    MSG_SCHED_ROUND_16_63(W12, W13,  W5, W10)
+    PROCESS_LOOP(W13, 45, D, E, F, G, H, A, B, C)
+    MSG_SCHED_ROUND_16_63(W13, W14,  W6, W11)
+    PROCESS_LOOP(W14, 46, C, D, E, F, G, H, A, B)
+    MSG_SCHED_ROUND_16_63(W14, W15,  W7, W12)
+    PROCESS_LOOP(W15, 47, B, C, D, E, F, G, H, A)
+    MSG_SCHED_ROUND_16_63(W15,  W0,  W8, W13)
+
+    // Check if this is the last block
+    sub INP_SIZE, 1
+    JE  lastLoop
+
+    // Load next mask for inputs
+    ADDQ $8, MASKP_P9
+    MOVQ (MASKP_P9), MASK_P9
+
+    // Process last 16 rounds
+    // Read in next block msg data for use in first 16 words of msg sched
+
+    PROCESS_LOOP( W0, 48, A, B, C, D, E, F, G, H)
+    MSG_SCHED_ROUND_00_15( W0,  0, skipNext0)
+    PROCESS_LOOP( W1, 49, H, A, B, C, D, E, F, G)
+    MSG_SCHED_ROUND_00_15( W1,  1, skipNext1)
+    PROCESS_LOOP( W2, 50, G, H, A, B, C, D, E, F)
+    MSG_SCHED_ROUND_00_15( W2,  2, skipNext2)
+    PROCESS_LOOP( W3, 51, F, G, H, A, B, C, D, E)
+    MSG_SCHED_ROUND_00_15( W3,  3, skipNext3)
+    PROCESS_LOOP( W4, 52, E, F, G, H, A, B, C, D)
+    MSG_SCHED_ROUND_00_15( W4,  4, skipNext4)
+    PROCESS_LOOP( W5, 53, D, E, F, G, H, A, B, C)
+    MSG_SCHED_ROUND_00_15( W5,  5, skipNext5)
+    PROCESS_LOOP( W6, 54, C, D, E, F, G, H, A, B)
+    MSG_SCHED_ROUND_00_15( W6,  6, skipNext6)
+    PROCESS_LOOP( W7, 55, B, C, D, E, F, G, H, A)
+    MSG_SCHED_ROUND_00_15( W7,  7, skipNext7)
+    PROCESS_LOOP( W8, 56, A, B, C, D, E, F, G, H)
+    MSG_SCHED_ROUND_00_15( W8,  8, skipNext8)
+    PROCESS_LOOP( W9, 57, H, A, B, C, D, E, F, G)
+    MSG_SCHED_ROUND_00_15( W9,  9, skipNext9)
+    PROCESS_LOOP(W10, 58, G, H, A, B, C, D, E, F)
+    MSG_SCHED_ROUND_00_15(W10, 10, skipNext10)
+    PROCESS_LOOP(W11, 59, F, G, H, A, B, C, D, E)
+    MSG_SCHED_ROUND_00_15(W11, 11, skipNext11)
+    PROCESS_LOOP(W12, 60, E, F, G, H, A, B, C, D)
+    MSG_SCHED_ROUND_00_15(W12, 12, skipNext12)
+    PROCESS_LOOP(W13, 61, D, E, F, G, H, A, B, C)
+    MSG_SCHED_ROUND_00_15(W13, 13, skipNext13)
+    PROCESS_LOOP(W14, 62, C, D, E, F, G, H, A, B)
+    MSG_SCHED_ROUND_00_15(W14, 14, skipNext14)
+    PROCESS_LOOP(W15, 63, B, C, D, E, F, G, H, A)
+    MSG_SCHED_ROUND_00_15(W15, 15, skipNext15)
+
+    // Add old digest
+    vmovdqu32  TMP2, A
+    vmovdqu32 A, [SCRATCH + 64*0]
+    vpaddd A{k1}, A, TMP2
+    vmovdqu32  TMP2, B
+    vmovdqu32 B, [SCRATCH + 64*1]
+    vpaddd B{k1}, B, TMP2
+    vmovdqu32  TMP2, C
+    vmovdqu32 C, [SCRATCH + 64*2]
+    vpaddd C{k1}, C, TMP2
+    vmovdqu32  TMP2, D
+    vmovdqu32 D, [SCRATCH + 64*3]
+    vpaddd D{k1}, D, TMP2
+    vmovdqu32  TMP2, E
+    vmovdqu32 E, [SCRATCH + 64*4]
+    vpaddd E{k1}, E, TMP2
+    vmovdqu32  TMP2, F
+    vmovdqu32 F, [SCRATCH + 64*5]
+    vpaddd F{k1}, F, TMP2
+    vmovdqu32  TMP2, G
+    vmovdqu32 G, [SCRATCH + 64*6]
+    vpaddd G{k1}, G, TMP2
+    vmovdqu32  TMP2, H
+    vmovdqu32 H, [SCRATCH + 64*7]
+    vpaddd H{k1}, H, TMP2
+
+    kmovq k1, mask
+    JMP lloop
+
+lastLoop:
+    // Process last 16 rounds
+    PROCESS_LOOP( W0, 48, A, B, C, D, E, F, G, H)
+    PROCESS_LOOP( W1, 49, H, A, B, C, D, E, F, G)
+    PROCESS_LOOP( W2, 50, G, H, A, B, C, D, E, F)
+    PROCESS_LOOP( W3, 51, F, G, H, A, B, C, D, E)
+    PROCESS_LOOP( W4, 52, E, F, G, H, A, B, C, D)
+    PROCESS_LOOP( W5, 53, D, E, F, G, H, A, B, C)
+    PROCESS_LOOP( W6, 54, C, D, E, F, G, H, A, B)
+    PROCESS_LOOP( W7, 55, B, C, D, E, F, G, H, A)
+    PROCESS_LOOP( W8, 56, A, B, C, D, E, F, G, H)
+    PROCESS_LOOP( W9, 57, H, A, B, C, D, E, F, G)
+    PROCESS_LOOP(W10, 58, G, H, A, B, C, D, E, F)
+    PROCESS_LOOP(W11, 59, F, G, H, A, B, C, D, E)
+    PROCESS_LOOP(W12, 60, E, F, G, H, A, B, C, D)
+    PROCESS_LOOP(W13, 61, D, E, F, G, H, A, B, C)
+    PROCESS_LOOP(W14, 62, C, D, E, F, G, H, A, B)
+    PROCESS_LOOP(W15, 63, B, C, D, E, F, G, H, A)
+
+    // Add old digest
+    vmovdqu32  TMP2, A
+    vmovdqu32 A, [SCRATCH + 64*0]
+    vpaddd A{k1}, A, TMP2
+    vmovdqu32  TMP2, B
+    vmovdqu32 B, [SCRATCH + 64*1]
+    vpaddd B{k1}, B, TMP2
+    vmovdqu32  TMP2, C
+    vmovdqu32 C, [SCRATCH + 64*2]
+    vpaddd C{k1}, C, TMP2
+    vmovdqu32  TMP2, D
+    vmovdqu32 D, [SCRATCH + 64*3]
+    vpaddd D{k1}, D, TMP2
+    vmovdqu32  TMP2, E
+    vmovdqu32 E, [SCRATCH + 64*4]
+    vpaddd E{k1}, E, TMP2
+    vmovdqu32  TMP2, F
+    vmovdqu32 F, [SCRATCH + 64*5]
+    vpaddd F{k1}, F, TMP2
+    vmovdqu32  TMP2, G
+    vmovdqu32 G, [SCRATCH + 64*6]
+    vpaddd G{k1}, G, TMP2
+    vmovdqu32  TMP2, H
+    vmovdqu32 H, [SCRATCH + 64*7]
+    vpaddd H{k1}, H, TMP2
+
+    // Write out digest
+    vmovdqu32 [STATE + 0*SHA256_DIGEST_ROW_SIZE], A
+    vmovdqu32 [STATE + 1*SHA256_DIGEST_ROW_SIZE], B
+    vmovdqu32 [STATE + 2*SHA256_DIGEST_ROW_SIZE], C
+    vmovdqu32 [STATE + 3*SHA256_DIGEST_ROW_SIZE], D
+    vmovdqu32 [STATE + 4*SHA256_DIGEST_ROW_SIZE], E
+    vmovdqu32 [STATE + 5*SHA256_DIGEST_ROW_SIZE], F
+    vmovdqu32 [STATE + 6*SHA256_DIGEST_ROW_SIZE], G
+    vmovdqu32 [STATE + 7*SHA256_DIGEST_ROW_SIZE], H
+
+    VZEROUPPER
+    RET
+
+//
+// Tables
+//
+
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x000(SB)/8, $0x0405060700010203
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x008(SB)/8, $0x0c0d0e0f08090a0b
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x010(SB)/8, $0x0405060700010203
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x018(SB)/8, $0x0c0d0e0f08090a0b
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x020(SB)/8, $0x0405060700010203
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x028(SB)/8, $0x0c0d0e0f08090a0b
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x030(SB)/8, $0x0405060700010203
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x038(SB)/8, $0x0c0d0e0f08090a0b
+GLOBL PSHUFFLE_BYTE_FLIP_MASK<>(SB), 8, $64
+
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x000(SB)/8, $0x0000000000000000
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x008(SB)/8, $0x0000000000000001
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x010(SB)/8, $0x0000000000000008
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x018(SB)/8, $0x0000000000000009
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x020(SB)/8, $0x0000000000000004
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x028(SB)/8, $0x0000000000000005
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x030(SB)/8, $0x000000000000000C
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x038(SB)/8, $0x000000000000000D
+GLOBL PSHUFFLE_TRANSPOSE16_MASK1<>(SB), 8, $64
+
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x000(SB)/8, $0x0000000000000002
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x008(SB)/8, $0x0000000000000003
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x010(SB)/8, $0x000000000000000A
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x018(SB)/8, $0x000000000000000B
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x020(SB)/8, $0x0000000000000006
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x028(SB)/8, $0x0000000000000007
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x030(SB)/8, $0x000000000000000E
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x038(SB)/8, $0x000000000000000F
+GLOBL PSHUFFLE_TRANSPOSE16_MASK2<>(SB), 8, $64

vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.go

@@ -0,0 +1,500 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2017 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sha256
+
+import (
+	"encoding/binary"
+	"errors"
+	"hash"
+	"sort"
+	"sync/atomic"
+	"time"
+)
+
+//go:noescape
+func sha256X16Avx512(digests *[512]byte, scratch *[512]byte, table *[512]uint64, mask []uint64, inputs [16][]byte)
+
+// Avx512ServerUID - Do not start at 0 but next multiple of 16 so as to be able to
+// differentiate with default initialiation value of 0
+const Avx512ServerUID = 16
+
+var uidCounter uint64
+
+// NewAvx512 - initialize sha256 Avx512 implementation.
+func NewAvx512(a512srv *Avx512Server) hash.Hash {
+	uid := atomic.AddUint64(&uidCounter, 1)
+	return &Avx512Digest{uid: uid, a512srv: a512srv}
+}
+
+// Avx512Digest - Type for computing SHA256 using Avx512
+type Avx512Digest struct {
+	uid     uint64
+	a512srv *Avx512Server
+	x       [chunk]byte
+	nx      int
+	len     uint64
+	final   bool
+	result  [Size]byte
+}
+
+// Size - Return size of checksum
+func (d *Avx512Digest) Size() int { return Size }
+
+// BlockSize - Return blocksize of checksum
+func (d Avx512Digest) BlockSize() int { return BlockSize }
+
+// Reset - reset sha digest to its initial values
+func (d *Avx512Digest) Reset() {
+	d.a512srv.blocksCh <- blockInput{uid: d.uid, reset: true}
+	d.nx = 0
+	d.len = 0
+	d.final = false
+}
+
+// Write to digest
+func (d *Avx512Digest) Write(p []byte) (nn int, err error) {
+
+	if d.final {
+		return 0, errors.New("Avx512Digest already finalized. Reset first before writing again")
+	}
+
+	nn = len(p)
+	d.len += uint64(nn)
+	if d.nx > 0 {
+		n := copy(d.x[d.nx:], p)
+		d.nx += n
+		if d.nx == chunk {
+			d.a512srv.blocksCh <- blockInput{uid: d.uid, msg: d.x[:]}
+			d.nx = 0
+		}
+		p = p[n:]
+	}
+	if len(p) >= chunk {
+		n := len(p) &^ (chunk - 1)
+		d.a512srv.blocksCh <- blockInput{uid: d.uid, msg: p[:n]}
+		p = p[n:]
+	}
+	if len(p) > 0 {
+		d.nx = copy(d.x[:], p)
+	}
+	return
+}
+
+// Sum - Return sha256 sum in bytes
+func (d *Avx512Digest) Sum(in []byte) (result []byte) {
+
+	if d.final {
+		return append(in, d.result[:]...)
+	}
+
+	trail := make([]byte, 0, 128)
+
+	len := d.len
+	// Padding.  Add a 1 bit and 0 bits until 56 bytes mod 64.
+	var tmp [64]byte
+	tmp[0] = 0x80
+	if len%64 < 56 {
+		trail = append(d.x[:d.nx], tmp[0:56-len%64]...)
+	} else {
+		trail = append(d.x[:d.nx], tmp[0:64+56-len%64]...)
+	}
+	d.nx = 0
+
+	// Length in bits.
+	len <<= 3
+	for i := uint(0); i < 8; i++ {
+		tmp[i] = byte(len >> (56 - 8*i))
+	}
+	trail = append(trail, tmp[0:8]...)
+
+	sumCh := make(chan [Size]byte)
+	d.a512srv.blocksCh <- blockInput{uid: d.uid, msg: trail, final: true, sumCh: sumCh}
+	d.result = <-sumCh
+	d.final = true
+	return append(in, d.result[:]...)
+}
+
+var table = [512]uint64{
+	0x428a2f98428a2f98, 0x428a2f98428a2f98, 0x428a2f98428a2f98, 0x428a2f98428a2f98,
+	0x428a2f98428a2f98, 0x428a2f98428a2f98, 0x428a2f98428a2f98, 0x428a2f98428a2f98,
+	0x7137449171374491, 0x7137449171374491, 0x7137449171374491, 0x7137449171374491,
+	0x7137449171374491, 0x7137449171374491, 0x7137449171374491, 0x7137449171374491,
+	0xb5c0fbcfb5c0fbcf, 0xb5c0fbcfb5c0fbcf, 0xb5c0fbcfb5c0fbcf, 0xb5c0fbcfb5c0fbcf,
+	0xb5c0fbcfb5c0fbcf, 0xb5c0fbcfb5c0fbcf, 0xb5c0fbcfb5c0fbcf, 0xb5c0fbcfb5c0fbcf,
+	0xe9b5dba5e9b5dba5, 0xe9b5dba5e9b5dba5, 0xe9b5dba5e9b5dba5, 0xe9b5dba5e9b5dba5,
+	0xe9b5dba5e9b5dba5, 0xe9b5dba5e9b5dba5, 0xe9b5dba5e9b5dba5, 0xe9b5dba5e9b5dba5,
+	0x3956c25b3956c25b, 0x3956c25b3956c25b, 0x3956c25b3956c25b, 0x3956c25b3956c25b,
+	0x3956c25b3956c25b, 0x3956c25b3956c25b, 0x3956c25b3956c25b, 0x3956c25b3956c25b,
+	0x59f111f159f111f1, 0x59f111f159f111f1, 0x59f111f159f111f1, 0x59f111f159f111f1,
+	0x59f111f159f111f1, 0x59f111f159f111f1, 0x59f111f159f111f1, 0x59f111f159f111f1,
+	0x923f82a4923f82a4, 0x923f82a4923f82a4, 0x923f82a4923f82a4, 0x923f82a4923f82a4,
+	0x923f82a4923f82a4, 0x923f82a4923f82a4, 0x923f82a4923f82a4, 0x923f82a4923f82a4,
+	0xab1c5ed5ab1c5ed5, 0xab1c5ed5ab1c5ed5, 0xab1c5ed5ab1c5ed5, 0xab1c5ed5ab1c5ed5,
+	0xab1c5ed5ab1c5ed5, 0xab1c5ed5ab1c5ed5, 0xab1c5ed5ab1c5ed5, 0xab1c5ed5ab1c5ed5,
+	0xd807aa98d807aa98, 0xd807aa98d807aa98, 0xd807aa98d807aa98, 0xd807aa98d807aa98,
+	0xd807aa98d807aa98, 0xd807aa98d807aa98, 0xd807aa98d807aa98, 0xd807aa98d807aa98,
+	0x12835b0112835b01, 0x12835b0112835b01, 0x12835b0112835b01, 0x12835b0112835b01,
+	0x12835b0112835b01, 0x12835b0112835b01, 0x12835b0112835b01, 0x12835b0112835b01,
+	0x243185be243185be, 0x243185be243185be, 0x243185be243185be, 0x243185be243185be,
+	0x243185be243185be, 0x243185be243185be, 0x243185be243185be, 0x243185be243185be,
+	0x550c7dc3550c7dc3, 0x550c7dc3550c7dc3, 0x550c7dc3550c7dc3, 0x550c7dc3550c7dc3,
+	0x550c7dc3550c7dc3, 0x550c7dc3550c7dc3, 0x550c7dc3550c7dc3, 0x550c7dc3550c7dc3,
+	0x72be5d7472be5d74, 0x72be5d7472be5d74, 0x72be5d7472be5d74, 0x72be5d7472be5d74,
+	0x72be5d7472be5d74, 0x72be5d7472be5d74, 0x72be5d7472be5d74, 0x72be5d7472be5d74,
+	0x80deb1fe80deb1fe, 0x80deb1fe80deb1fe, 0x80deb1fe80deb1fe, 0x80deb1fe80deb1fe,
+	0x80deb1fe80deb1fe, 0x80deb1fe80deb1fe, 0x80deb1fe80deb1fe, 0x80deb1fe80deb1fe,
+	0x9bdc06a79bdc06a7, 0x9bdc06a79bdc06a7, 0x9bdc06a79bdc06a7, 0x9bdc06a79bdc06a7,
+	0x9bdc06a79bdc06a7, 0x9bdc06a79bdc06a7, 0x9bdc06a79bdc06a7, 0x9bdc06a79bdc06a7,
+	0xc19bf174c19bf174, 0xc19bf174c19bf174, 0xc19bf174c19bf174, 0xc19bf174c19bf174,
+	0xc19bf174c19bf174, 0xc19bf174c19bf174, 0xc19bf174c19bf174, 0xc19bf174c19bf174,
+	0xe49b69c1e49b69c1, 0xe49b69c1e49b69c1, 0xe49b69c1e49b69c1, 0xe49b69c1e49b69c1,
+	0xe49b69c1e49b69c1, 0xe49b69c1e49b69c1, 0xe49b69c1e49b69c1, 0xe49b69c1e49b69c1,
+	0xefbe4786efbe4786, 0xefbe4786efbe4786, 0xefbe4786efbe4786, 0xefbe4786efbe4786,
+	0xefbe4786efbe4786, 0xefbe4786efbe4786, 0xefbe4786efbe4786, 0xefbe4786efbe4786,
+	0x0fc19dc60fc19dc6, 0x0fc19dc60fc19dc6, 0x0fc19dc60fc19dc6, 0x0fc19dc60fc19dc6,
+	0x0fc19dc60fc19dc6, 0x0fc19dc60fc19dc6, 0x0fc19dc60fc19dc6, 0x0fc19dc60fc19dc6,
+	0x240ca1cc240ca1cc, 0x240ca1cc240ca1cc, 0x240ca1cc240ca1cc, 0x240ca1cc240ca1cc,
+	0x240ca1cc240ca1cc, 0x240ca1cc240ca1cc, 0x240ca1cc240ca1cc, 0x240ca1cc240ca1cc,
+	0x2de92c6f2de92c6f, 0x2de92c6f2de92c6f, 0x2de92c6f2de92c6f, 0x2de92c6f2de92c6f,
+	0x2de92c6f2de92c6f, 0x2de92c6f2de92c6f, 0x2de92c6f2de92c6f, 0x2de92c6f2de92c6f,
+	0x4a7484aa4a7484aa, 0x4a7484aa4a7484aa, 0x4a7484aa4a7484aa, 0x4a7484aa4a7484aa,
+	0x4a7484aa4a7484aa, 0x4a7484aa4a7484aa, 0x4a7484aa4a7484aa, 0x4a7484aa4a7484aa,
+	0x5cb0a9dc5cb0a9dc, 0x5cb0a9dc5cb0a9dc, 0x5cb0a9dc5cb0a9dc, 0x5cb0a9dc5cb0a9dc,
+	0x5cb0a9dc5cb0a9dc, 0x5cb0a9dc5cb0a9dc, 0x5cb0a9dc5cb0a9dc, 0x5cb0a9dc5cb0a9dc,
+	0x76f988da76f988da, 0x76f988da76f988da, 0x76f988da76f988da, 0x76f988da76f988da,
+	0x76f988da76f988da, 0x76f988da76f988da, 0x76f988da76f988da, 0x76f988da76f988da,
+	0x983e5152983e5152, 0x983e5152983e5152, 0x983e5152983e5152, 0x983e5152983e5152,
+	0x983e5152983e5152, 0x983e5152983e5152, 0x983e5152983e5152, 0x983e5152983e5152,
+	0xa831c66da831c66d, 0xa831c66da831c66d, 0xa831c66da831c66d, 0xa831c66da831c66d,
+	0xa831c66da831c66d, 0xa831c66da831c66d, 0xa831c66da831c66d, 0xa831c66da831c66d,
+	0xb00327c8b00327c8, 0xb00327c8b00327c8, 0xb00327c8b00327c8, 0xb00327c8b00327c8,
+	0xb00327c8b00327c8, 0xb00327c8b00327c8, 0xb00327c8b00327c8, 0xb00327c8b00327c8,
+	0xbf597fc7bf597fc7, 0xbf597fc7bf597fc7, 0xbf597fc7bf597fc7, 0xbf597fc7bf597fc7,
+	0xbf597fc7bf597fc7, 0xbf597fc7bf597fc7, 0xbf597fc7bf597fc7, 0xbf597fc7bf597fc7,
+	0xc6e00bf3c6e00bf3, 0xc6e00bf3c6e00bf3, 0xc6e00bf3c6e00bf3, 0xc6e00bf3c6e00bf3,
+	0xc6e00bf3c6e00bf3, 0xc6e00bf3c6e00bf3, 0xc6e00bf3c6e00bf3, 0xc6e00bf3c6e00bf3,
+	0xd5a79147d5a79147, 0xd5a79147d5a79147, 0xd5a79147d5a79147, 0xd5a79147d5a79147,
+	0xd5a79147d5a79147, 0xd5a79147d5a79147, 0xd5a79147d5a79147, 0xd5a79147d5a79147,
+	0x06ca635106ca6351, 0x06ca635106ca6351, 0x06ca635106ca6351, 0x06ca635106ca6351,
+	0x06ca635106ca6351, 0x06ca635106ca6351, 0x06ca635106ca6351, 0x06ca635106ca6351,
+	0x1429296714292967, 0x1429296714292967, 0x1429296714292967, 0x1429296714292967,
+	0x1429296714292967, 0x1429296714292967, 0x1429296714292967, 0x1429296714292967,
+	0x27b70a8527b70a85, 0x27b70a8527b70a85, 0x27b70a8527b70a85, 0x27b70a8527b70a85,
+	0x27b70a8527b70a85, 0x27b70a8527b70a85, 0x27b70a8527b70a85, 0x27b70a8527b70a85,
+	0x2e1b21382e1b2138, 0x2e1b21382e1b2138, 0x2e1b21382e1b2138, 0x2e1b21382e1b2138,
+	0x2e1b21382e1b2138, 0x2e1b21382e1b2138, 0x2e1b21382e1b2138, 0x2e1b21382e1b2138,
+	0x4d2c6dfc4d2c6dfc, 0x4d2c6dfc4d2c6dfc, 0x4d2c6dfc4d2c6dfc, 0x4d2c6dfc4d2c6dfc,
+	0x4d2c6dfc4d2c6dfc, 0x4d2c6dfc4d2c6dfc, 0x4d2c6dfc4d2c6dfc, 0x4d2c6dfc4d2c6dfc,
+	0x53380d1353380d13, 0x53380d1353380d13, 0x53380d1353380d13, 0x53380d1353380d13,
+	0x53380d1353380d13, 0x53380d1353380d13, 0x53380d1353380d13, 0x53380d1353380d13,
+	0x650a7354650a7354, 0x650a7354650a7354, 0x650a7354650a7354, 0x650a7354650a7354,
+	0x650a7354650a7354, 0x650a7354650a7354, 0x650a7354650a7354, 0x650a7354650a7354,
+	0x766a0abb766a0abb, 0x766a0abb766a0abb, 0x766a0abb766a0abb, 0x766a0abb766a0abb,
+	0x766a0abb766a0abb, 0x766a0abb766a0abb, 0x766a0abb766a0abb, 0x766a0abb766a0abb,
+	0x81c2c92e81c2c92e, 0x81c2c92e81c2c92e, 0x81c2c92e81c2c92e, 0x81c2c92e81c2c92e,
+	0x81c2c92e81c2c92e, 0x81c2c92e81c2c92e, 0x81c2c92e81c2c92e, 0x81c2c92e81c2c92e,
+	0x92722c8592722c85, 0x92722c8592722c85, 0x92722c8592722c85, 0x92722c8592722c85,
+	0x92722c8592722c85, 0x92722c8592722c85, 0x92722c8592722c85, 0x92722c8592722c85,
+	0xa2bfe8a1a2bfe8a1, 0xa2bfe8a1a2bfe8a1, 0xa2bfe8a1a2bfe8a1, 0xa2bfe8a1a2bfe8a1,
+	0xa2bfe8a1a2bfe8a1, 0xa2bfe8a1a2bfe8a1, 0xa2bfe8a1a2bfe8a1, 0xa2bfe8a1a2bfe8a1,
+	0xa81a664ba81a664b, 0xa81a664ba81a664b, 0xa81a664ba81a664b, 0xa81a664ba81a664b,
+	0xa81a664ba81a664b, 0xa81a664ba81a664b, 0xa81a664ba81a664b, 0xa81a664ba81a664b,
+	0xc24b8b70c24b8b70, 0xc24b8b70c24b8b70, 0xc24b8b70c24b8b70, 0xc24b8b70c24b8b70,
+	0xc24b8b70c24b8b70, 0xc24b8b70c24b8b70, 0xc24b8b70c24b8b70, 0xc24b8b70c24b8b70,
+	0xc76c51a3c76c51a3, 0xc76c51a3c76c51a3, 0xc76c51a3c76c51a3, 0xc76c51a3c76c51a3,
+	0xc76c51a3c76c51a3, 0xc76c51a3c76c51a3, 0xc76c51a3c76c51a3, 0xc76c51a3c76c51a3,
+	0xd192e819d192e819, 0xd192e819d192e819, 0xd192e819d192e819, 0xd192e819d192e819,
+	0xd192e819d192e819, 0xd192e819d192e819, 0xd192e819d192e819, 0xd192e819d192e819,
+	0xd6990624d6990624, 0xd6990624d6990624, 0xd6990624d6990624, 0xd6990624d6990624,
+	0xd6990624d6990624, 0xd6990624d6990624, 0xd6990624d6990624, 0xd6990624d6990624,
+	0xf40e3585f40e3585, 0xf40e3585f40e3585, 0xf40e3585f40e3585, 0xf40e3585f40e3585,
+	0xf40e3585f40e3585, 0xf40e3585f40e3585, 0xf40e3585f40e3585, 0xf40e3585f40e3585,
+	0x106aa070106aa070, 0x106aa070106aa070, 0x106aa070106aa070, 0x106aa070106aa070,
+	0x106aa070106aa070, 0x106aa070106aa070, 0x106aa070106aa070, 0x106aa070106aa070,
+	0x19a4c11619a4c116, 0x19a4c11619a4c116, 0x19a4c11619a4c116, 0x19a4c11619a4c116,
+	0x19a4c11619a4c116, 0x19a4c11619a4c116, 0x19a4c11619a4c116, 0x19a4c11619a4c116,
+	0x1e376c081e376c08, 0x1e376c081e376c08, 0x1e376c081e376c08, 0x1e376c081e376c08,
+	0x1e376c081e376c08, 0x1e376c081e376c08, 0x1e376c081e376c08, 0x1e376c081e376c08,
+	0x2748774c2748774c, 0x2748774c2748774c, 0x2748774c2748774c, 0x2748774c2748774c,
+	0x2748774c2748774c, 0x2748774c2748774c, 0x2748774c2748774c, 0x2748774c2748774c,
+	0x34b0bcb534b0bcb5, 0x34b0bcb534b0bcb5, 0x34b0bcb534b0bcb5, 0x34b0bcb534b0bcb5,
+	0x34b0bcb534b0bcb5, 0x34b0bcb534b0bcb5, 0x34b0bcb534b0bcb5, 0x34b0bcb534b0bcb5,
+	0x391c0cb3391c0cb3, 0x391c0cb3391c0cb3, 0x391c0cb3391c0cb3, 0x391c0cb3391c0cb3,
+	0x391c0cb3391c0cb3, 0x391c0cb3391c0cb3, 0x391c0cb3391c0cb3, 0x391c0cb3391c0cb3,
+	0x4ed8aa4a4ed8aa4a, 0x4ed8aa4a4ed8aa4a, 0x4ed8aa4a4ed8aa4a, 0x4ed8aa4a4ed8aa4a,
+	0x4ed8aa4a4ed8aa4a, 0x4ed8aa4a4ed8aa4a, 0x4ed8aa4a4ed8aa4a, 0x4ed8aa4a4ed8aa4a,
+	0x5b9cca4f5b9cca4f, 0x5b9cca4f5b9cca4f, 0x5b9cca4f5b9cca4f, 0x5b9cca4f5b9cca4f,
+	0x5b9cca4f5b9cca4f, 0x5b9cca4f5b9cca4f, 0x5b9cca4f5b9cca4f, 0x5b9cca4f5b9cca4f,
+	0x682e6ff3682e6ff3, 0x682e6ff3682e6ff3, 0x682e6ff3682e6ff3, 0x682e6ff3682e6ff3,
+	0x682e6ff3682e6ff3, 0x682e6ff3682e6ff3, 0x682e6ff3682e6ff3, 0x682e6ff3682e6ff3,
+	0x748f82ee748f82ee, 0x748f82ee748f82ee, 0x748f82ee748f82ee, 0x748f82ee748f82ee,
+	0x748f82ee748f82ee, 0x748f82ee748f82ee, 0x748f82ee748f82ee, 0x748f82ee748f82ee,
+	0x78a5636f78a5636f, 0x78a5636f78a5636f, 0x78a5636f78a5636f, 0x78a5636f78a5636f,
+	0x78a5636f78a5636f, 0x78a5636f78a5636f, 0x78a5636f78a5636f, 0x78a5636f78a5636f,
+	0x84c8781484c87814, 0x84c8781484c87814, 0x84c8781484c87814, 0x84c8781484c87814,
+	0x84c8781484c87814, 0x84c8781484c87814, 0x84c8781484c87814, 0x84c8781484c87814,
+	0x8cc702088cc70208, 0x8cc702088cc70208, 0x8cc702088cc70208, 0x8cc702088cc70208,
+	0x8cc702088cc70208, 0x8cc702088cc70208, 0x8cc702088cc70208, 0x8cc702088cc70208,
+	0x90befffa90befffa, 0x90befffa90befffa, 0x90befffa90befffa, 0x90befffa90befffa,
+	0x90befffa90befffa, 0x90befffa90befffa, 0x90befffa90befffa, 0x90befffa90befffa,
+	0xa4506ceba4506ceb, 0xa4506ceba4506ceb, 0xa4506ceba4506ceb, 0xa4506ceba4506ceb,
+	0xa4506ceba4506ceb, 0xa4506ceba4506ceb, 0xa4506ceba4506ceb, 0xa4506ceba4506ceb,
+	0xbef9a3f7bef9a3f7, 0xbef9a3f7bef9a3f7, 0xbef9a3f7bef9a3f7, 0xbef9a3f7bef9a3f7,
+	0xbef9a3f7bef9a3f7, 0xbef9a3f7bef9a3f7, 0xbef9a3f7bef9a3f7, 0xbef9a3f7bef9a3f7,
+	0xc67178f2c67178f2, 0xc67178f2c67178f2, 0xc67178f2c67178f2, 0xc67178f2c67178f2,
+	0xc67178f2c67178f2, 0xc67178f2c67178f2, 0xc67178f2c67178f2, 0xc67178f2c67178f2}
+
+// Interface function to assembly ode
+func blockAvx512(digests *[512]byte, input [16][]byte, mask []uint64) [16][Size]byte {
+
+	scratch := [512]byte{}
+	sha256X16Avx512(digests, &scratch, &table, mask, input)
+
+	output := [16][Size]byte{}
+	for i := 0; i < 16; i++ {
+		output[i] = getDigest(i, digests[:])
+	}
+
+	return output
+}
+
+func getDigest(index int, state []byte) (sum [Size]byte) {
+	for j := 0; j < 16; j += 2 {
+		for i := index*4 + j*Size; i < index*4+(j+1)*Size; i += Size {
+			binary.BigEndian.PutUint32(sum[j*2:], binary.LittleEndian.Uint32(state[i:i+4]))
+		}
+	}
+	return
+}
+
+// Message to send across input channel
+type blockInput struct {
+	uid   uint64
+	msg   []byte
+	reset bool
+	final bool
+	sumCh chan [Size]byte
+}
+
+// Avx512Server - Type to implement 16x parallel handling of SHA256 invocations
+type Avx512Server struct {
+	blocksCh chan blockInput       // Input channel
+	totalIn  int                   // Total number of inputs waiting to be processed
+	lanes    [16]Avx512LaneInfo    // Array with info per lane (out of 16)
+	digests  map[uint64][Size]byte // Map of uids to (interim) digest results
+}
+
+// Avx512LaneInfo - Info for each lane
+type Avx512LaneInfo struct {
+	uid      uint64          // unique identification for this SHA processing
+	block    []byte          // input block to be processed
+	outputCh chan [Size]byte // channel for output result
+}
+
+// NewAvx512Server - Create new object for parallel processing handling
+func NewAvx512Server() *Avx512Server {
+	a512srv := &Avx512Server{}
+	a512srv.digests = make(map[uint64][Size]byte)
+	a512srv.blocksCh = make(chan blockInput)
+
+	// Start a single thread for reading from the input channel
+	go a512srv.Process()
+	return a512srv
+}
+
+// Process - Sole handler for reading from the input channel
+func (a512srv *Avx512Server) Process() {
+	for {
+		select {
+		case block := <-a512srv.blocksCh:
+			if block.reset {
+				a512srv.reset(block.uid)
+				continue
+			}
+			index := block.uid & 0xf
+			// fmt.Println("Adding message:", block.uid, index)
+
+			if a512srv.lanes[index].block != nil { // If slot is already filled, process all inputs
+				//fmt.Println("Invoking Blocks()")
+				a512srv.blocks()
+			}
+			a512srv.totalIn++
+			a512srv.lanes[index] = Avx512LaneInfo{uid: block.uid, block: block.msg}
+			if block.final {
+				a512srv.lanes[index].outputCh = block.sumCh
+			}
+			if a512srv.totalIn == len(a512srv.lanes) {
+				// fmt.Println("Invoking Blocks() while FULL: ")
+				a512srv.blocks()
+			}
+
+			// TODO: test with larger timeout
+		case <-time.After(1 * time.Microsecond):
+			for _, lane := range a512srv.lanes {
+				if lane.block != nil { // check if there is any input to process
+					// fmt.Println("Invoking Blocks() on TIMEOUT: ")
+					a512srv.blocks()
+					break // we are done
+				}
+			}
+		}
+	}
+}
+
+// Do a reset for this calculation
+func (a512srv *Avx512Server) reset(uid uint64) {
+
+	// Check if there is a message still waiting to be processed (and remove if so)
+	for i, lane := range a512srv.lanes {
+		if lane.uid == uid {
+			if lane.block != nil {
+				a512srv.lanes[i] = Avx512LaneInfo{} // clear message
+				a512srv.totalIn--
+			}
+		}
+	}
+
+	// Delete entry from hash map
+	delete(a512srv.digests, uid)
+}
+
+// Invoke assembly and send results back
+func (a512srv *Avx512Server) blocks() (err error) {
+
+	inputs := [16][]byte{}
+	for i := range inputs {
+		inputs[i] = a512srv.lanes[i].block
+	}
+
+	mask := expandMask(genMask(inputs))
+	outputs := blockAvx512(a512srv.getDigests(), inputs, mask)
+
+	a512srv.totalIn = 0
+	for i := 0; i < len(outputs); i++ {
+		uid, outputCh := a512srv.lanes[i].uid, a512srv.lanes[i].outputCh
+		a512srv.digests[uid] = outputs[i]
+		a512srv.lanes[i] = Avx512LaneInfo{}
+
+		if outputCh != nil {
+			// Send back result
+			outputCh <- outputs[i]
+			delete(a512srv.digests, uid) // Delete entry from hashmap
+		}
+	}
+	return
+}
+
+func (a512srv *Avx512Server) Write(uid uint64, p []byte) (nn int, err error) {
+	a512srv.blocksCh <- blockInput{uid: uid, msg: p}
+	return len(p), nil
+}
+
+// Sum - return sha256 sum in bytes for a given sum id.
+func (a512srv *Avx512Server) Sum(uid uint64, p []byte) [32]byte {
+	sumCh := make(chan [32]byte)
+	a512srv.blocksCh <- blockInput{uid: uid, msg: p, final: true, sumCh: sumCh}
+	return <-sumCh
+}
+
+func (a512srv *Avx512Server) getDigests() *[512]byte {
+	digests := [512]byte{}
+	for i, lane := range a512srv.lanes {
+		a, ok := a512srv.digests[lane.uid]
+		if ok {
+			binary.BigEndian.PutUint32(digests[(i+0*16)*4:], binary.LittleEndian.Uint32(a[0:4]))
+			binary.BigEndian.PutUint32(digests[(i+1*16)*4:], binary.LittleEndian.Uint32(a[4:8]))
+			binary.BigEndian.PutUint32(digests[(i+2*16)*4:], binary.LittleEndian.Uint32(a[8:12]))
+			binary.BigEndian.PutUint32(digests[(i+3*16)*4:], binary.LittleEndian.Uint32(a[12:16]))
+			binary.BigEndian.PutUint32(digests[(i+4*16)*4:], binary.LittleEndian.Uint32(a[16:20]))
+			binary.BigEndian.PutUint32(digests[(i+5*16)*4:], binary.LittleEndian.Uint32(a[20:24]))
+			binary.BigEndian.PutUint32(digests[(i+6*16)*4:], binary.LittleEndian.Uint32(a[24:28]))
+			binary.BigEndian.PutUint32(digests[(i+7*16)*4:], binary.LittleEndian.Uint32(a[28:32]))
+		} else {
+			binary.LittleEndian.PutUint32(digests[(i+0*16)*4:], init0)
+			binary.LittleEndian.PutUint32(digests[(i+1*16)*4:], init1)
+			binary.LittleEndian.PutUint32(digests[(i+2*16)*4:], init2)
+			binary.LittleEndian.PutUint32(digests[(i+3*16)*4:], init3)
+			binary.LittleEndian.PutUint32(digests[(i+4*16)*4:], init4)
+			binary.LittleEndian.PutUint32(digests[(i+5*16)*4:], init5)
+			binary.LittleEndian.PutUint32(digests[(i+6*16)*4:], init6)
+			binary.LittleEndian.PutUint32(digests[(i+7*16)*4:], init7)
+		}
+	}
+	return &digests
+}
+
+// Helper struct for sorting blocks based on length
+type lane struct {
+	len uint
+	pos uint
+}
+
+type lanes []lane
+
+func (lns lanes) Len() int           { return len(lns) }
+func (lns lanes) Swap(i, j int)      { lns[i], lns[j] = lns[j], lns[i] }
+func (lns lanes) Less(i, j int) bool { return lns[i].len < lns[j].len }
+
+// Helper struct for
+type maskRounds struct {
+	mask   uint64
+	rounds uint64
+}
+
+func genMask(input [16][]byte) [16]maskRounds {
+
+	// Sort on blocks length small to large
+	var sorted [16]lane
+	for c, inpt := range input {
+		sorted[c] = lane{uint(len(inpt)), uint(c)}
+	}
+	sort.Sort(lanes(sorted[:]))
+
+	// Create mask array including 'rounds' between masks
+	m, round, index := uint64(0xffff), uint64(0), 0
+	var mr [16]maskRounds
+	for _, s := range sorted {
+		if s.len > 0 {
+			if uint64(s.len)>>6 > round {
+				mr[index] = maskRounds{m, (uint64(s.len) >> 6) - round}
+				index++
+			}
+			round = uint64(s.len) >> 6
+		}
+		m = m & ^(1 << uint(s.pos))
+	}
+
+	return mr
+}
+
+// TODO: remove function
+func expandMask(mr [16]maskRounds) []uint64 {
+	size := uint64(0)
+	for _, r := range mr {
+		size += r.rounds
+	}
+	result, index := make([]uint64, size), 0
+	for _, r := range mr {
+		for j := uint64(0); j < r.rounds; j++ {
+			result[index] = r.mask
+			index++
+		}
+	}
+	return result
+}

vendor/github.com/minio/sha256-simd/sha256blockAvx_amd64.go

@@ -0,0 +1,22 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sha256
+
+//go:noescape
+func blockAvx(h []uint32, message []uint8, reserved0, reserved1, reserved2, reserved3 uint64)

vendor/github.com/minio/sha256-simd/sha256blockAvx_amd64.s

@@ -0,0 +1,408 @@
+//+build !noasm !appengine
+
+// SHA256 implementation for AVX
+
+//
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+//
+// This code is based on an Intel White-Paper:
+// "Fast SHA-256 Implementations on Intel Architecture Processors"
+//
+// together with the reference implementation from the following authors:
+//    James Guilford <james.guilford@intel.com>
+//    Kirk Yap <kirk.s.yap@intel.com>
+//    Tim Chen <tim.c.chen@linux.intel.com>
+//
+// For Golang it has been converted to Plan 9 assembly with the help of
+// github.com/minio/asm2plan9s to assemble Intel instructions to their Plan9
+// equivalents
+//
+
+#include "textflag.h"
+
+#define ROTATE_XS \
+	MOVOU X4, X15 \
+	MOVOU X5, X4  \
+	MOVOU X6, X5  \
+	MOVOU X7, X6  \
+	MOVOU X15, X7
+
+// compute s0 four at a time and s1 two at a time
+// compute W[-16] + W[-7] 4 at a time
+#define FOUR_ROUNDS_AND_SCHED(a, b, c, d, e, f, g, h) \
+	MOVL e, R13                    \ // y0 = e
+	ROLL $18, R13                  \ // y0 = e >> (25-11)
+	MOVL a, R14                    \ // y1 = a
+	LONG $0x0f41e3c4; WORD $0x04c6 \ // VPALIGNR XMM0,XMM7,XMM6,0x4      /* XTMP0 = W[-7]                           */
+	ROLL $23, R14                  \ // y1 = a >> (22-13)
+	XORL e, R13                    \ // y0 = e ^ (e >> (25-11))
+	MOVL f, R15                    \ // y2 = f
+	ROLL $27, R13                  \ // y0 = (e >> (11-6)) ^ (e >> (25-6))
+	XORL a, R14                    \ // y1 = a ^ (a >> (22-13)
+	XORL g, R15                    \ // y2 = f^g
+	LONG $0xc4fef9c5               \ // VPADDD XMM0,XMM0,XMM4            /* XTMP0 = W[-7] + W[-16]                  */
+	XORL e, R13                    \ // y0 = e ^ (e >> (11-6)) ^ (e >> (25-6) )
+	ANDL e, R15                    \ // y2 = (f^g)&e
+	ROLL $21, R14                  \ // y1 = (a >> (13-2)) ^ (a >> (22-2))
+	                               \
+	\ // compute s0
+	                               \
+	LONG $0x0f51e3c4; WORD $0x04cc \ // VPALIGNR XMM1,XMM5,XMM4,0x4      /* XTMP1 = W[-15]                          */
+	XORL a, R14                    \ // y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+	ROLL $26, R13                  \ // y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+	XORL g, R15                    \ // y2 = CH = ((f^g)&e)^g
+	ROLL $30, R14                  \ // y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+	ADDL R13, R15                  \ // y2 = S1 + CH
+	ADDL _xfer+48(FP), R15         \ // y2 = k + w + S1 + CH
+	MOVL a, R13                    \ // y0 = a
+	ADDL R15, h                    \ // h = h + S1 + CH + k + w
+	\ // ROTATE_ARGS
+	MOVL a, R15                    \ // y2 = a
+	LONG $0xd172e9c5; BYTE $0x07   \ // VPSRLD XMM2,XMM1,0x7             /*                                         */
+	ORL  c, R13                    \ // y0 = a|c
+	ADDL h, d                      \ // d = d + h + S1 + CH + k + w
+	ANDL c, R15                    \ // y2 = a&c
+	LONG $0xf172e1c5; BYTE $0x19   \ // VPSLLD XMM3,XMM1,0x19            /*                                         */
+	ANDL b, R13                    \ // y0 = (a|c)&b
+	ADDL R14, h                    \ // h = h + S1 + CH + k + w + S0
+	LONG $0xdaebe1c5               \ // VPOR   XMM3,XMM3,XMM2            /* XTMP1 = W[-15] MY_ROR 7                 */
+	ORL  R15, R13                  \ // y0 = MAJ = (a|c)&b)|(a&c)
+	ADDL R13, h                    \ // h = h + S1 + CH + k + w + S0 + MAJ
+	\ // ROTATE_ARGS
+	MOVL d, R13                    \ // y0 = e
+	MOVL h, R14                    \ // y1 = a
+	ROLL $18, R13                  \ // y0 = e >> (25-11)
+	XORL d, R13                    \ // y0 = e ^ (e >> (25-11))
+	MOVL e, R15                    \ // y2 = f
+	ROLL $23, R14                  \ // y1 = a >> (22-13)
+	LONG $0xd172e9c5; BYTE $0x12   \ // VPSRLD XMM2,XMM1,0x12            /*                                         */
+	XORL h, R14                    \ // y1 = a ^ (a >> (22-13)
+	ROLL $27, R13                  \ // y0 = (e >> (11-6)) ^ (e >> (25-6))
+	XORL f, R15                    \ // y2 = f^g
+	LONG $0xd172b9c5; BYTE $0x03   \ // VPSRLD XMM8,XMM1,0x3             /* XTMP4 = W[-15] >> 3                     */
+	ROLL $21, R14                  \ // y1 = (a >> (13-2)) ^ (a >> (22-2))
+	XORL d, R13                    \ // y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
+	ANDL d, R15                    \ // y2 = (f^g)&e
+	ROLL $26, R13                  \ // y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+	LONG $0xf172f1c5; BYTE $0x0e   \ // VPSLLD XMM1,XMM1,0xe             /*                                         */
+	XORL h, R14                    \ // y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+	XORL f, R15                    \ // y2 = CH = ((f^g)&e)^g
+	LONG $0xd9efe1c5               \ // VPXOR  XMM3,XMM3,XMM1            /*                                         */
+	ADDL R13, R15                  \ // y2 = S1 + CH
+	ADDL _xfer+52(FP), R15         \ // y2 = k + w + S1 + CH
+	ROLL $30, R14                  \ // y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+	LONG $0xdaefe1c5               \ // VPXOR  XMM3,XMM3,XMM2            /* XTMP1 = W[-15] MY_ROR 7 ^ W[-15] MY_ROR */
+	MOVL h, R13                    \ // y0 = a
+	ADDL R15, g                    \ // h = h + S1 + CH + k + w
+	MOVL h, R15                    \ // y2 = a
+	LONG $0xef61c1c4; BYTE $0xc8   \ // VPXOR  XMM1,XMM3,XMM8            /* XTMP1 = s0                              */
+	ORL  b, R13                    \ // y0 = a|c
+	ADDL g, c                      \ // d = d + h + S1 + CH + k + w
+	ANDL b, R15                    \ // y2 = a&c
+	                               \
+	\ // compute low s1
+	                               \
+	LONG $0xd770f9c5; BYTE $0xfa   \ // VPSHUFD XMM2,XMM7,0xfa           /* XTMP2 = W[-2] {BBAA}                    */
+	ANDL a, R13                    \ // y0 = (a|c)&b
+	ADDL R14, g                    \ // h = h + S1 + CH + k + w + S0
+	LONG $0xc1fef9c5               \ // VPADDD XMM0,XMM0,XMM1            /* XTMP0 = W[-16] + W[-7] + s0             */
+	ORL  R15, R13                  \ // y0 = MAJ = (a|c)&b)|(a&c)
+	ADDL R13, g                    \ // h = h + S1 + CH + k + w + S0 + MAJ
+	\ // ROTATE_ARGS
+	MOVL c, R13                    \ // y0 = e
+	MOVL g, R14                    \ // y1 = a
+	ROLL $18, R13                  \ // y0 = e >> (25-11)
+	XORL c, R13                    \ // y0 = e ^ (e >> (25-11))
+	ROLL $23, R14                  \ // y1 = a >> (22-13)
+	MOVL d, R15                    \ // y2 = f
+	XORL g, R14                    \ // y1 = a ^ (a >> (22-13)
+	ROLL $27, R13                  \ // y0 = (e >> (11-6)) ^ (e >> (25-6))
+	LONG $0xd272b9c5; BYTE $0x0a   \ // VPSRLD XMM8,XMM2,0xa             /* XTMP4 = W[-2] >> 10 {BBAA}              */
+	XORL e, R15                    \ // y2 = f^g
+	LONG $0xd273e1c5; BYTE $0x13   \ // VPSRLQ XMM3,XMM2,0x13            /* XTMP3 = W[-2] MY_ROR 19 {xBxA}          */
+	XORL c, R13                    \ // y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
+	ANDL c, R15                    \ // y2 = (f^g)&e
+	LONG $0xd273e9c5; BYTE $0x11   \ // VPSRLQ XMM2,XMM2,0x11            /* XTMP2 = W[-2] MY_ROR 17 {xBxA}          */
+	ROLL $21, R14                  \ // y1 = (a >> (13-2)) ^ (a >> (22-2))
+	XORL g, R14                    \ // y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+	XORL e, R15                    \ // y2 = CH = ((f^g)&e)^g
+	ROLL $26, R13                  \ // y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+	LONG $0xd3efe9c5               \ // VPXOR  XMM2,XMM2,XMM3            /*                                         */
+	ADDL R13, R15                  \ // y2 = S1 + CH
+	ROLL $30, R14                  \ // y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+	ADDL _xfer+56(FP), R15         \ // y2 = k + w + S1 + CH
+	LONG $0xc2ef39c5               \ // VPXOR  XMM8,XMM8,XMM2            /* XTMP4 = s1 {xBxA}                       */
+	MOVL g, R13                    \ // y0 = a
+	ADDL R15, f                    \ // h = h + S1 + CH + k + w
+	MOVL g, R15                    \ // y2 = a
+	LONG $0x003942c4; BYTE $0xc2   \ // VPSHUFB XMM8,XMM8,XMM10          /* XTMP4 = s1 {00BA}                       */
+	ORL  a, R13                    \ // y0 = a|c
+	ADDL f, b                      \ // d = d + h + S1 + CH + k + w
+	ANDL a, R15                    \ // y2 = a&c
+	LONG $0xfe79c1c4; BYTE $0xc0   \ // VPADDD XMM0,XMM0,XMM8            /* XTMP0 = {..., ..., W[1], W[0]}          */
+	ANDL h, R13                    \ // y0 = (a|c)&b
+	ADDL R14, f                    \ // h = h + S1 + CH + k + w + S0
+	                               \
+	\ // compute high s1
+	                               \
+	LONG $0xd070f9c5; BYTE $0x50   \ // VPSHUFD XMM2,XMM0,0x50           /* XTMP2 = W[-2] {DDCC}                    */
+	ORL  R15, R13                  \ // y0 = MAJ = (a|c)&b)|(a&c)
+	ADDL R13, f                    \ // h = h + S1 + CH + k + w + S0 + MAJ
+	\ // ROTATE_ARGS
+	MOVL b, R13                    \ // y0 = e
+	ROLL $18, R13                  \ // y0 = e >> (25-11)
+	MOVL f, R14                    \ // y1 = a
+	ROLL $23, R14                  \ // y1 = a >> (22-13)
+	XORL b, R13                    \ // y0 = e ^ (e >> (25-11))
+	MOVL c, R15                    \ // y2 = f
+	ROLL $27, R13                  \ // y0 = (e >> (11-6)) ^ (e >> (25-6))
+	LONG $0xd272a1c5; BYTE $0x0a   \ // VPSRLD XMM11,XMM2,0xa            /* XTMP5 = W[-2] >> 10 {DDCC}              */
+	XORL f, R14                    \ // y1 = a ^ (a >> (22-13)
+	XORL d, R15                    \ // y2 = f^g
+	LONG $0xd273e1c5; BYTE $0x13   \ // VPSRLQ XMM3,XMM2,0x13            /* XTMP3 = W[-2] MY_ROR 19 {xDxC}          */
+	XORL b, R13                    \ // y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
+	ANDL b, R15                    \ // y2 = (f^g)&e
+	ROLL $21, R14                  \ // y1 = (a >> (13-2)) ^ (a >> (22-2))
+	LONG $0xd273e9c5; BYTE $0x11   \ // VPSRLQ XMM2,XMM2,0x11            /* XTMP2 = W[-2] MY_ROR 17 {xDxC}          */
+	XORL f, R14                    \ // y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+	ROLL $26, R13                  \ // y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+	XORL d, R15                    \ // y2 = CH = ((f^g)&e)^g
+	LONG $0xd3efe9c5               \ // VPXOR  XMM2,XMM2,XMM3            /*                                         */
+	ROLL $30, R14                  \ // y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+	ADDL R13, R15                  \ // y2 = S1 + CH
+	ADDL _xfer+60(FP), R15         \ // y2 = k + w + S1 + CH
+	LONG $0xdaef21c5               \ // VPXOR  XMM11,XMM11,XMM2          /* XTMP5 = s1 {xDxC}                       */
+	MOVL f, R13                    \ // y0 = a
+	ADDL R15, e                    \ // h = h + S1 + CH + k + w
+	MOVL f, R15                    \ // y2 = a
+	LONG $0x002142c4; BYTE $0xdc   \ // VPSHUFB XMM11,XMM11,XMM12        /* XTMP5 = s1 {DC00}                       */
+	ORL  h, R13                    \ // y0 = a|c
+	ADDL e, a                      \ // d = d + h + S1 + CH + k + w
+	ANDL h, R15                    \ // y2 = a&c
+	LONG $0xe0fea1c5               \ // VPADDD XMM4,XMM11,XMM0           /* X0 = {W[3], W[2], W[1], W[0]}           */
+	ANDL g, R13                    \ // y0 = (a|c)&b
+	ADDL R14, e                    \ // h = h + S1 + CH + k + w + S0
+	ORL  R15, R13                  \ // y0 = MAJ = (a|c)&b)|(a&c)
+	ADDL R13, e                    \ // h = h + S1 + CH + k + w + S0 + MAJ
+	\ // ROTATE_ARGS
+	ROTATE_XS
+
+#define DO_ROUND(a, b, c, d, e, f, g, h, offset) \
+	MOVL e, R13                \ // y0 = e
+	ROLL $18, R13              \ // y0 = e >> (25-11)
+	MOVL a, R14                \ // y1 = a
+	XORL e, R13                \ // y0 = e ^ (e >> (25-11))
+	ROLL $23, R14              \ // y1 = a >> (22-13)
+	MOVL f, R15                \ // y2 = f
+	XORL a, R14                \ // y1 = a ^ (a >> (22-13)
+	ROLL $27, R13              \ // y0 = (e >> (11-6)) ^ (e >> (25-6))
+	XORL g, R15                \ // y2 = f^g
+	XORL e, R13                \ // y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
+	ROLL $21, R14              \ // y1 = (a >> (13-2)) ^ (a >> (22-2))
+	ANDL e, R15                \ // y2 = (f^g)&e
+	XORL a, R14                \ // y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+	ROLL $26, R13              \ // y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+	XORL g, R15                \ // y2 = CH = ((f^g)&e)^g
+	ADDL R13, R15              \ // y2 = S1 + CH
+	ROLL $30, R14              \ // y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+	ADDL _xfer+offset(FP), R15 \ // y2 = k + w + S1 + CH
+	MOVL a, R13                \ // y0 = a
+	ADDL R15, h                \ // h = h + S1 + CH + k + w
+	MOVL a, R15                \ // y2 = a
+	ORL  c, R13                \ // y0 = a|c
+	ADDL h, d                  \ // d = d + h + S1 + CH + k + w
+	ANDL c, R15                \ // y2 = a&c
+	ANDL b, R13                \ // y0 = (a|c)&b
+	ADDL R14, h                \ // h = h + S1 + CH + k + w + S0
+	ORL  R15, R13              \ // y0 = MAJ = (a|c)&b)|(a&c)
+	ADDL R13, h                // h = h + S1 + CH + k + w + S0 + MAJ
+
+// func blockAvx(h []uint32, message []uint8, reserved0, reserved1, reserved2, reserved3 uint64)
+TEXT ·blockAvx(SB), 7, $0-80
+
+	MOVQ h+0(FP), SI             // SI: &h
+	MOVQ message_base+24(FP), R8 // &message
+	MOVQ message_len+32(FP), R9  // length of message
+	CMPQ R9, $0
+	JEQ  done_hash
+	ADDQ R8, R9
+	MOVQ R9, reserved2+64(FP)    // store end of message
+
+	// Register definition
+	//  a -->  eax
+	//  b -->  ebx
+	//  c -->  ecx
+	//  d -->  r8d
+	//  e -->  edx
+	//  f -->  r9d
+	//  g --> r10d
+	//  h --> r11d
+	//
+	// y0 --> r13d
+	// y1 --> r14d
+	// y2 --> r15d
+
+	MOVL (0*4)(SI), AX  // a = H0
+	MOVL (1*4)(SI), BX  // b = H1
+	MOVL (2*4)(SI), CX  // c = H2
+	MOVL (3*4)(SI), R8  // d = H3
+	MOVL (4*4)(SI), DX  // e = H4
+	MOVL (5*4)(SI), R9  // f = H5
+	MOVL (6*4)(SI), R10 // g = H6
+	MOVL (7*4)(SI), R11 // h = H7
+
+	MOVOU bflipMask<>(SB), X13
+	MOVOU shuf00BA<>(SB), X10  // shuffle xBxA -> 00BA
+	MOVOU shufDC00<>(SB), X12  // shuffle xDxC -> DC00
+
+	MOVQ message_base+24(FP), SI // SI: &message
+
+loop0:
+	LEAQ constants<>(SB), BP
+
+	// byte swap first 16 dwords
+	MOVOU 0*16(SI), X4
+	LONG  $0x0059c2c4; BYTE $0xe5 // VPSHUFB XMM4, XMM4, XMM13
+	MOVOU 1*16(SI), X5
+	LONG  $0x0051c2c4; BYTE $0xed // VPSHUFB XMM5, XMM5, XMM13
+	MOVOU 2*16(SI), X6
+	LONG  $0x0049c2c4; BYTE $0xf5 // VPSHUFB XMM6, XMM6, XMM13
+	MOVOU 3*16(SI), X7
+	LONG  $0x0041c2c4; BYTE $0xfd // VPSHUFB XMM7, XMM7, XMM13
+
+	MOVQ SI, reserved3+72(FP)
+	MOVD $0x3, DI
+
+	// schedule 48 input dwords, by doing 3 rounds of 16 each
+loop1:
+	LONG  $0x4dfe59c5; BYTE $0x00 // VPADDD XMM9, XMM4, 0[RBP]   /* Add 1st constant to first part of message */
+	MOVOU X9, reserved0+48(FP)
+	FOUR_ROUNDS_AND_SCHED(AX, BX,  CX,  R8, DX, R9, R10, R11)
+
+	LONG  $0x4dfe59c5; BYTE $0x10 // VPADDD XMM9, XMM4, 16[RBP]   /* Add 2nd constant to message */
+	MOVOU X9, reserved0+48(FP)
+	FOUR_ROUNDS_AND_SCHED(DX, R9, R10, R11, AX, BX,  CX,  R8)
+
+	LONG  $0x4dfe59c5; BYTE $0x20 // VPADDD XMM9, XMM4, 32[RBP]   /* Add 3rd constant to message */
+	MOVOU X9, reserved0+48(FP)
+	FOUR_ROUNDS_AND_SCHED(AX, BX,  CX,  R8, DX, R9, R10, R11)
+
+	LONG  $0x4dfe59c5; BYTE $0x30 // VPADDD XMM9, XMM4, 48[RBP]   /* Add 4th constant to message */
+	MOVOU X9, reserved0+48(FP)
+	ADDQ  $64, BP
+	FOUR_ROUNDS_AND_SCHED(DX, R9, R10, R11, AX, BX,  CX,  R8)
+
+	SUBQ $1, DI
+	JNE  loop1
+
+	MOVD $0x2, DI
+
+loop2:
+	LONG  $0x4dfe59c5; BYTE $0x00 // VPADDD XMM9, XMM4, 0[RBP]   /* Add 1st constant to first part of message */
+	MOVOU X9, reserved0+48(FP)
+	DO_ROUND( AX,  BX,  CX,  R8,  DX,  R9, R10, R11, 48)
+	DO_ROUND(R11,  AX,  BX,  CX,  R8,  DX,  R9, R10, 52)
+	DO_ROUND(R10, R11,  AX,  BX,  CX,  R8,  DX,  R9, 56)
+	DO_ROUND( R9, R10, R11,  AX,  BX,  CX,  R8,  DX, 60)
+
+	LONG  $0x4dfe51c5; BYTE $0x10 // VPADDD XMM9, XMM5, 16[RBP]   /* Add 2nd constant to message */
+	MOVOU X9, reserved0+48(FP)
+	ADDQ  $32, BP
+	DO_ROUND( DX,  R9, R10, R11,  AX,  BX,  CX,  R8, 48)
+	DO_ROUND( R8,  DX,  R9, R10, R11,  AX,  BX,  CX, 52)
+	DO_ROUND( CX,  R8,  DX,  R9, R10, R11,  AX,  BX, 56)
+	DO_ROUND( BX,  CX,  R8,  DX,  R9, R10, R11,  AX, 60)
+
+	MOVOU X6, X4
+	MOVOU X7, X5
+
+	SUBQ $1, DI
+	JNE  loop2
+
+	MOVQ h+0(FP), SI    // SI: &h
+	ADDL (0*4)(SI), AX  // H0 = a + H0
+	MOVL AX, (0*4)(SI)
+	ADDL (1*4)(SI), BX  // H1 = b + H1
+	MOVL BX, (1*4)(SI)
+	ADDL (2*4)(SI), CX  // H2 = c + H2
+	MOVL CX, (2*4)(SI)
+	ADDL (3*4)(SI), R8  // H3 = d + H3
+	MOVL R8, (3*4)(SI)
+	ADDL (4*4)(SI), DX  // H4 = e + H4
+	MOVL DX, (4*4)(SI)
+	ADDL (5*4)(SI), R9  // H5 = f + H5
+	MOVL R9, (5*4)(SI)
+	ADDL (6*4)(SI), R10 // H6 = g + H6
+	MOVL R10, (6*4)(SI)
+	ADDL (7*4)(SI), R11 // H7 = h + H7
+	MOVL R11, (7*4)(SI)
+
+	MOVQ reserved3+72(FP), SI
+	ADDQ $64, SI
+	CMPQ reserved2+64(FP), SI
+	JNE  loop0
+
+done_hash:
+	RET
+
+// Constants table
+DATA constants<>+0x0(SB)/8, $0x71374491428a2f98
+DATA constants<>+0x8(SB)/8, $0xe9b5dba5b5c0fbcf
+DATA constants<>+0x10(SB)/8, $0x59f111f13956c25b
+DATA constants<>+0x18(SB)/8, $0xab1c5ed5923f82a4
+DATA constants<>+0x20(SB)/8, $0x12835b01d807aa98
+DATA constants<>+0x28(SB)/8, $0x550c7dc3243185be
+DATA constants<>+0x30(SB)/8, $0x80deb1fe72be5d74
+DATA constants<>+0x38(SB)/8, $0xc19bf1749bdc06a7
+DATA constants<>+0x40(SB)/8, $0xefbe4786e49b69c1
+DATA constants<>+0x48(SB)/8, $0x240ca1cc0fc19dc6
+DATA constants<>+0x50(SB)/8, $0x4a7484aa2de92c6f
+DATA constants<>+0x58(SB)/8, $0x76f988da5cb0a9dc
+DATA constants<>+0x60(SB)/8, $0xa831c66d983e5152
+DATA constants<>+0x68(SB)/8, $0xbf597fc7b00327c8
+DATA constants<>+0x70(SB)/8, $0xd5a79147c6e00bf3
+DATA constants<>+0x78(SB)/8, $0x1429296706ca6351
+DATA constants<>+0x80(SB)/8, $0x2e1b213827b70a85
+DATA constants<>+0x88(SB)/8, $0x53380d134d2c6dfc
+DATA constants<>+0x90(SB)/8, $0x766a0abb650a7354
+DATA constants<>+0x98(SB)/8, $0x92722c8581c2c92e
+DATA constants<>+0xa0(SB)/8, $0xa81a664ba2bfe8a1
+DATA constants<>+0xa8(SB)/8, $0xc76c51a3c24b8b70
+DATA constants<>+0xb0(SB)/8, $0xd6990624d192e819
+DATA constants<>+0xb8(SB)/8, $0x106aa070f40e3585
+DATA constants<>+0xc0(SB)/8, $0x1e376c0819a4c116
+DATA constants<>+0xc8(SB)/8, $0x34b0bcb52748774c
+DATA constants<>+0xd0(SB)/8, $0x4ed8aa4a391c0cb3
+DATA constants<>+0xd8(SB)/8, $0x682e6ff35b9cca4f
+DATA constants<>+0xe0(SB)/8, $0x78a5636f748f82ee
+DATA constants<>+0xe8(SB)/8, $0x8cc7020884c87814
+DATA constants<>+0xf0(SB)/8, $0xa4506ceb90befffa
+DATA constants<>+0xf8(SB)/8, $0xc67178f2bef9a3f7
+
+DATA bflipMask<>+0x00(SB)/8, $0x0405060700010203
+DATA bflipMask<>+0x08(SB)/8, $0x0c0d0e0f08090a0b
+
+DATA shuf00BA<>+0x00(SB)/8, $0x0b0a090803020100
+DATA shuf00BA<>+0x08(SB)/8, $0xFFFFFFFFFFFFFFFF
+
+DATA shufDC00<>+0x00(SB)/8, $0xFFFFFFFFFFFFFFFF
+DATA shufDC00<>+0x08(SB)/8, $0x0b0a090803020100
+
+GLOBL constants<>(SB), 8, $256
+GLOBL bflipMask<>(SB), (NOPTR+RODATA), $16
+GLOBL shuf00BA<>(SB), (NOPTR+RODATA), $16
+GLOBL shufDC00<>(SB), (NOPTR+RODATA), $16

vendor/github.com/minio/sha256-simd/sha256blockSha_amd64.go

@@ -0,0 +1,6 @@
+//+build !noasm
+
+package sha256
+
+//go:noescape
+func blockSha(h *[8]uint32, message []uint8)

vendor/github.com/minio/sha256-simd/sha256blockSha_amd64.s

@@ -0,0 +1,266 @@
+//+build !noasm !appengine
+
+// SHA intrinsic version of SHA256
+
+// Kristofer Peterson, (C) 2018.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "textflag.h"
+
+DATA K<>+0x00(SB)/4, $0x428a2f98
+DATA K<>+0x04(SB)/4, $0x71374491
+DATA K<>+0x08(SB)/4, $0xb5c0fbcf
+DATA K<>+0x0c(SB)/4, $0xe9b5dba5
+DATA K<>+0x10(SB)/4, $0x3956c25b
+DATA K<>+0x14(SB)/4, $0x59f111f1
+DATA K<>+0x18(SB)/4, $0x923f82a4
+DATA K<>+0x1c(SB)/4, $0xab1c5ed5
+DATA K<>+0x20(SB)/4, $0xd807aa98
+DATA K<>+0x24(SB)/4, $0x12835b01
+DATA K<>+0x28(SB)/4, $0x243185be
+DATA K<>+0x2c(SB)/4, $0x550c7dc3
+DATA K<>+0x30(SB)/4, $0x72be5d74
+DATA K<>+0x34(SB)/4, $0x80deb1fe
+DATA K<>+0x38(SB)/4, $0x9bdc06a7
+DATA K<>+0x3c(SB)/4, $0xc19bf174
+DATA K<>+0x40(SB)/4, $0xe49b69c1
+DATA K<>+0x44(SB)/4, $0xefbe4786
+DATA K<>+0x48(SB)/4, $0x0fc19dc6
+DATA K<>+0x4c(SB)/4, $0x240ca1cc
+DATA K<>+0x50(SB)/4, $0x2de92c6f
+DATA K<>+0x54(SB)/4, $0x4a7484aa
+DATA K<>+0x58(SB)/4, $0x5cb0a9dc
+DATA K<>+0x5c(SB)/4, $0x76f988da
+DATA K<>+0x60(SB)/4, $0x983e5152
+DATA K<>+0x64(SB)/4, $0xa831c66d
+DATA K<>+0x68(SB)/4, $0xb00327c8
+DATA K<>+0x6c(SB)/4, $0xbf597fc7
+DATA K<>+0x70(SB)/4, $0xc6e00bf3
+DATA K<>+0x74(SB)/4, $0xd5a79147
+DATA K<>+0x78(SB)/4, $0x06ca6351
+DATA K<>+0x7c(SB)/4, $0x14292967
+DATA K<>+0x80(SB)/4, $0x27b70a85
+DATA K<>+0x84(SB)/4, $0x2e1b2138
+DATA K<>+0x88(SB)/4, $0x4d2c6dfc
+DATA K<>+0x8c(SB)/4, $0x53380d13
+DATA K<>+0x90(SB)/4, $0x650a7354
+DATA K<>+0x94(SB)/4, $0x766a0abb
+DATA K<>+0x98(SB)/4, $0x81c2c92e
+DATA K<>+0x9c(SB)/4, $0x92722c85
+DATA K<>+0xa0(SB)/4, $0xa2bfe8a1
+DATA K<>+0xa4(SB)/4, $0xa81a664b
+DATA K<>+0xa8(SB)/4, $0xc24b8b70
+DATA K<>+0xac(SB)/4, $0xc76c51a3
+DATA K<>+0xb0(SB)/4, $0xd192e819
+DATA K<>+0xb4(SB)/4, $0xd6990624
+DATA K<>+0xb8(SB)/4, $0xf40e3585
+DATA K<>+0xbc(SB)/4, $0x106aa070
+DATA K<>+0xc0(SB)/4, $0x19a4c116
+DATA K<>+0xc4(SB)/4, $0x1e376c08
+DATA K<>+0xc8(SB)/4, $0x2748774c
+DATA K<>+0xcc(SB)/4, $0x34b0bcb5
+DATA K<>+0xd0(SB)/4, $0x391c0cb3
+DATA K<>+0xd4(SB)/4, $0x4ed8aa4a
+DATA K<>+0xd8(SB)/4, $0x5b9cca4f
+DATA K<>+0xdc(SB)/4, $0x682e6ff3
+DATA K<>+0xe0(SB)/4, $0x748f82ee
+DATA K<>+0xe4(SB)/4, $0x78a5636f
+DATA K<>+0xe8(SB)/4, $0x84c87814
+DATA K<>+0xec(SB)/4, $0x8cc70208
+DATA K<>+0xf0(SB)/4, $0x90befffa
+DATA K<>+0xf4(SB)/4, $0xa4506ceb
+DATA K<>+0xf8(SB)/4, $0xbef9a3f7
+DATA K<>+0xfc(SB)/4, $0xc67178f2
+GLOBL K<>(SB), RODATA|NOPTR, $256
+
+DATA SHUF_MASK<>+0x00(SB)/8, $0x0405060700010203
+DATA SHUF_MASK<>+0x08(SB)/8, $0x0c0d0e0f08090a0b
+GLOBL SHUF_MASK<>(SB), RODATA|NOPTR, $16
+
+// Register Usage
+// BX  base address of constant table (constant)
+// DX  hash_state (constant)
+// SI  hash_data.data
+// DI  hash_data.data + hash_data.length - 64 (constant)
+// X0  scratch
+// X1  scratch
+// X2  working hash state // ABEF
+// X3  working hash state // CDGH
+// X4  first 16 bytes of block
+// X5  second 16 bytes of block
+// X6  third 16 bytes of block
+// X7  fourth 16 bytes of block
+// X12 saved hash state // ABEF
+// X13 saved hash state // CDGH
+// X15 data shuffle mask (constant)
+
+TEXT ·blockSha(SB), NOSPLIT, $0-32
+	MOVQ      h+0(FP), DX
+	MOVQ      message_base+8(FP), SI
+	MOVQ      message_len+16(FP), DI
+	LEAQ      -64(SI)(DI*1), DI
+	MOVOU     (DX), X2
+	MOVOU     16(DX), X1
+	MOVO      X2, X3
+	PUNPCKLLQ X1, X2
+	PUNPCKHLQ X1, X3
+	PSHUFD    $0x27, X2, X2
+	PSHUFD    $0x27, X3, X3
+	MOVO      SHUF_MASK<>(SB), X15
+	LEAQ      K<>(SB), BX
+
+	JMP TEST
+
+LOOP:
+	MOVO X2, X12
+	MOVO X3, X13
+
+	// load block and shuffle
+	MOVOU  (SI), X4
+	MOVOU  16(SI), X5
+	MOVOU  32(SI), X6
+	MOVOU  48(SI), X7
+	PSHUFB X15, X4
+	PSHUFB X15, X5
+	PSHUFB X15, X6
+	PSHUFB X15, X7
+
+#define ROUND456 \
+	PADDL  X5, X0                    \
+	LONG   $0xdacb380f               \ // SHA256RNDS2 XMM3, XMM2
+	MOVO   X5, X1                    \
+	LONG   $0x0f3a0f66; WORD $0x04cc \ // PALIGNR XMM1, XMM4, 4
+	PADDL  X1, X6                    \
+	LONG   $0xf5cd380f               \ // SHA256MSG2 XMM6, XMM5
+	PSHUFD $0x4e, X0, X0             \
+	LONG   $0xd3cb380f               \ // SHA256RNDS2 XMM2, XMM3
+	LONG   $0xe5cc380f               // SHA256MSG1 XMM4, XMM5
+
+#define ROUND567 \
+	PADDL  X6, X0                    \
+	LONG   $0xdacb380f               \ // SHA256RNDS2 XMM3, XMM2
+	MOVO   X6, X1                    \
+	LONG   $0x0f3a0f66; WORD $0x04cd \ // PALIGNR XMM1, XMM5, 4
+	PADDL  X1, X7                    \
+	LONG   $0xfecd380f               \ // SHA256MSG2 XMM7, XMM6
+	PSHUFD $0x4e, X0, X0             \
+	LONG   $0xd3cb380f               \ // SHA256RNDS2 XMM2, XMM3
+	LONG   $0xeecc380f               // SHA256MSG1 XMM5, XMM6
+
+#define ROUND674 \
+	PADDL  X7, X0                    \
+	LONG   $0xdacb380f               \ // SHA256RNDS2 XMM3, XMM2
+	MOVO   X7, X1                    \
+	LONG   $0x0f3a0f66; WORD $0x04ce \ // PALIGNR XMM1, XMM6, 4
+	PADDL  X1, X4                    \
+	LONG   $0xe7cd380f               \ // SHA256MSG2 XMM4, XMM7
+	PSHUFD $0x4e, X0, X0             \
+	LONG   $0xd3cb380f               \ // SHA256RNDS2 XMM2, XMM3
+	LONG   $0xf7cc380f               // SHA256MSG1 XMM6, XMM7
+
+#define ROUND745 \
+	PADDL  X4, X0                    \
+	LONG   $0xdacb380f               \ // SHA256RNDS2 XMM3, XMM2
+	MOVO   X4, X1                    \
+	LONG   $0x0f3a0f66; WORD $0x04cf \ // PALIGNR XMM1, XMM7, 4
+	PADDL  X1, X5                    \
+	LONG   $0xeccd380f               \ // SHA256MSG2 XMM5, XMM4
+	PSHUFD $0x4e, X0, X0             \
+	LONG   $0xd3cb380f               \ // SHA256RNDS2 XMM2, XMM3
+	LONG   $0xfccc380f               // SHA256MSG1 XMM7, XMM4
+
+	// rounds 0-3
+	MOVO   (BX), X0
+	PADDL  X4, X0
+	LONG   $0xdacb380f   // SHA256RNDS2 XMM3, XMM2
+	PSHUFD $0x4e, X0, X0
+	LONG   $0xd3cb380f   // SHA256RNDS2 XMM2, XMM3
+
+	// rounds 4-7
+	MOVO   1*16(BX), X0
+	PADDL  X5, X0
+	LONG   $0xdacb380f   // SHA256RNDS2 XMM3, XMM2
+	PSHUFD $0x4e, X0, X0
+	LONG   $0xd3cb380f   // SHA256RNDS2 XMM2, XMM3
+	LONG   $0xe5cc380f   // SHA256MSG1 XMM4, XMM5
+
+	// rounds 8-11
+	MOVO   2*16(BX), X0
+	PADDL  X6, X0
+	LONG   $0xdacb380f   // SHA256RNDS2 XMM3, XMM2
+	PSHUFD $0x4e, X0, X0
+	LONG   $0xd3cb380f   // SHA256RNDS2 XMM2, XMM3
+	LONG   $0xeecc380f   // SHA256MSG1 XMM5, XMM6
+
+	MOVO 3*16(BX), X0; ROUND674  // rounds 12-15
+	MOVO 4*16(BX), X0; ROUND745  // rounds 16-19
+	MOVO 5*16(BX), X0; ROUND456  // rounds 20-23
+	MOVO 6*16(BX), X0; ROUND567  // rounds 24-27
+	MOVO 7*16(BX), X0; ROUND674  // rounds 28-31
+	MOVO 8*16(BX), X0; ROUND745  // rounds 32-35
+	MOVO 9*16(BX), X0; ROUND456  // rounds 36-39
+	MOVO 10*16(BX), X0; ROUND567 // rounds 40-43
+	MOVO 11*16(BX), X0; ROUND674 // rounds 44-47
+	MOVO 12*16(BX), X0; ROUND745 // rounds 48-51
+
+	// rounds 52-55
+	MOVO   13*16(BX), X0
+	PADDL  X5, X0
+	LONG   $0xdacb380f               // SHA256RNDS2 XMM3, XMM2
+	MOVO   X5, X1
+	LONG   $0x0f3a0f66; WORD $0x04cc // PALIGNR XMM1, XMM4, 4
+	PADDL  X1, X6
+	LONG   $0xf5cd380f               // SHA256MSG2 XMM6, XMM5
+	PSHUFD $0x4e, X0, X0
+	LONG   $0xd3cb380f               // SHA256RNDS2 XMM2, XMM3
+
+	// rounds 56-59
+	MOVO   14*16(BX), X0
+	PADDL  X6, X0
+	LONG   $0xdacb380f               // SHA256RNDS2 XMM3, XMM2
+	MOVO   X6, X1
+	LONG   $0x0f3a0f66; WORD $0x04cd // PALIGNR XMM1, XMM5, 4
+	PADDL  X1, X7
+	LONG   $0xfecd380f               // SHA256MSG2 XMM7, XMM6
+	PSHUFD $0x4e, X0, X0
+	LONG   $0xd3cb380f               // SHA256RNDS2 XMM2, XMM3
+
+	// rounds 60-63
+	MOVO   15*16(BX), X0
+	PADDL  X7, X0
+	LONG   $0xdacb380f   // SHA256RNDS2 XMM3, XMM2
+	PSHUFD $0x4e, X0, X0
+	LONG   $0xd3cb380f   // SHA256RNDS2 XMM2, XMM3
+
+	PADDL X12, X2
+	PADDL X13, X3
+
+	ADDQ $64, SI
+
+TEST:
+	CMPQ SI, DI
+	JBE  LOOP
+
+	PSHUFD $0x4e, X3, X0
+	LONG   $0x0e3a0f66; WORD $0xf0c2 // PBLENDW XMM0, XMM2, 0xf0
+	PSHUFD $0x4e, X2, X1
+	LONG   $0x0e3a0f66; WORD $0x0fcb // PBLENDW XMM1, XMM3, 0x0f
+	PSHUFD $0x1b, X0, X0
+	PSHUFD $0x1b, X1, X1
+
+	MOVOU X0, (DX)
+	MOVOU X1, 16(DX)
+
+	RET

vendor/github.com/minio/sha256-simd/sha256blockSsse_amd64.go

@@ -0,0 +1,22 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sha256
+
+//go:noescape
+func blockSsse(h []uint32, message []uint8, reserved0, reserved1, reserved2, reserved3 uint64)

vendor/github.com/minio/sha256-simd/sha256blockSsse_amd64.s

@@ -0,0 +1,429 @@
+//+build !noasm !appengine
+
+// SHA256 implementation for SSSE3
+
+//
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+//
+// This code is based on an Intel White-Paper:
+// "Fast SHA-256 Implementations on Intel Architecture Processors"
+//
+// together with the reference implementation from the following authors:
+//    James Guilford <james.guilford@intel.com>
+//    Kirk Yap <kirk.s.yap@intel.com>
+//    Tim Chen <tim.c.chen@linux.intel.com>
+//
+// For Golang it has been converted to Plan 9 assembly with the help of
+// github.com/minio/asm2plan9s to assemble Intel instructions to their Plan9
+// equivalents
+//
+
+#include "textflag.h"
+
+#define ROTATE_XS \
+	MOVOU X4, X15 \
+	MOVOU X5, X4  \
+	MOVOU X6, X5  \
+	MOVOU X7, X6  \
+	MOVOU X15, X7
+
+// compute s0 four at a time and s1 two at a time
+// compute W[-16] + W[-7] 4 at a time
+#define FOUR_ROUNDS_AND_SCHED(a, b, c, d, e, f, g, h) \
+	MOVL  e, R13                    \ // y0 = e
+	ROLL  $18, R13                  \ // y0 = e >> (25-11)
+	MOVL  a, R14                    \ // y1 = a
+	MOVOU X7, X0                    \
+	LONG  $0x0f3a0f66; WORD $0x04c6 \ // PALIGNR XMM0,XMM6,0x4            /* XTMP0 = W[-7]                           */
+	ROLL  $23, R14                  \ // y1 = a >> (22-13)
+	XORL  e, R13                    \ // y0 = e ^ (e >> (25-11))
+	MOVL  f, R15                    \ // y2 = f
+	ROLL  $27, R13                  \ // y0 = (e >> (11-6)) ^ (e >> (25-6))
+	XORL  a, R14                    \ // y1 = a ^ (a >> (22-13)
+	XORL  g, R15                    \ // y2 = f^g
+	LONG  $0xc4fe0f66               \ // PADDD XMM0,XMM4                  /* XTMP0 = W[-7] + W[-16]                  */
+	XORL  e, R13                    \ // y0 = e ^ (e >> (11-6)) ^ (e >> (25-6) )
+	ANDL  e, R15                    \ // y2 = (f^g)&e
+	ROLL  $21, R14                  \ // y1 = (a >> (13-2)) ^ (a >> (22-2))
+	                                \
+	\ // compute s0
+	                                \
+	MOVOU X5, X1                    \
+	LONG  $0x0f3a0f66; WORD $0x04cc \ // PALIGNR XMM1,XMM4,0x4            /* XTMP1 = W[-15]                          */
+	XORL  a, R14                    \ // y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+	ROLL  $26, R13                  \ // y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+	XORL  g, R15                    \ // y2 = CH = ((f^g)&e)^g
+	ROLL  $30, R14                  \ // y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+	ADDL  R13, R15                  \ // y2 = S1 + CH
+	ADDL  _xfer+48(FP), R15         \ // y2 = k + w + S1 + CH
+	MOVL  a, R13                    \ // y0 = a
+	ADDL  R15, h                    \ // h = h + S1 + CH + k + w
+	\ // ROTATE_ARGS
+	MOVL  a, R15                    \ // y2 = a
+	MOVOU X1, X2                    \
+	LONG  $0xd2720f66; BYTE $0x07   \ // PSRLD XMM2,0x7                   /*                                         */
+	ORL   c, R13                    \ // y0 = a|c
+	ADDL  h, d                      \ // d = d + h + S1 + CH + k + w
+	ANDL  c, R15                    \ // y2 = a&c
+	MOVOU X1, X3                    \
+	LONG  $0xf3720f66; BYTE $0x19   \ // PSLLD XMM3,0x19                  /*                                         */
+	ANDL  b, R13                    \ // y0 = (a|c)&b
+	ADDL  R14, h                    \ // h = h + S1 + CH + k + w + S0
+	LONG  $0xdaeb0f66               \ // POR   XMM3,XMM2                  /* XTMP1 = W[-15] MY_ROR 7                 */
+	ORL   R15, R13                  \ // y0 = MAJ = (a|c)&b)|(a&c)
+	ADDL  R13, h                    \ // h = h + S1 + CH + k + w + S0 + MAJ
+	\ // ROTATE_ARGS
+	MOVL  d, R13                    \ // y0 = e
+	MOVL  h, R14                    \ // y1 = a
+	ROLL  $18, R13                  \ // y0 = e >> (25-11)
+	XORL  d, R13                    \ // y0 = e ^ (e >> (25-11))
+	MOVL  e, R15                    \ // y2 = f
+	ROLL  $23, R14                  \ // y1 = a >> (22-13)
+	MOVOU X1, X2                    \
+	LONG  $0xd2720f66; BYTE $0x12   \ // PSRLD XMM2,0x12                  /*                                         */
+	XORL  h, R14                    \ // y1 = a ^ (a >> (22-13)
+	ROLL  $27, R13                  \ // y0 = (e >> (11-6)) ^ (e >> (25-6))
+	XORL  f, R15                    \ // y2 = f^g
+	MOVOU X1, X8                    \
+	LONG  $0x720f4166; WORD $0x03d0 \ // PSRLD XMM8,0x3                   /* XTMP4 = W[-15] >> 3                     */
+	ROLL  $21, R14                  \ // y1 = (a >> (13-2)) ^ (a >> (22-2))
+	XORL  d, R13                    \ // y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
+	ANDL  d, R15                    \ // y2 = (f^g)&e
+	ROLL  $26, R13                  \ // y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+	LONG  $0xf1720f66; BYTE $0x0e   \ // PSLLD XMM1,0xe                   /*                                         */
+	XORL  h, R14                    \ // y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+	XORL  f, R15                    \ // y2 = CH = ((f^g)&e)^g
+	LONG  $0xd9ef0f66               \ // PXOR  XMM3,XMM1                  /*                                         */
+	ADDL  R13, R15                  \ // y2 = S1 + CH
+	ADDL  _xfer+52(FP), R15         \ // y2 = k + w + S1 + CH
+	ROLL  $30, R14                  \ // y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+	LONG  $0xdaef0f66               \ // PXOR  XMM3,XMM2                  /* XTMP1 = W[-15] MY_ROR 7 ^ W[-15] MY_ROR */
+	MOVL  h, R13                    \ // y0 = a
+	ADDL  R15, g                    \ // h = h + S1 + CH + k + w
+	MOVL  h, R15                    \ // y2 = a
+	MOVOU X3, X1                    \
+	LONG  $0xef0f4166; BYTE $0xc8   \ // PXOR  XMM1,XMM8                  /* XTMP1 = s0                              */
+	ORL   b, R13                    \ // y0 = a|c
+	ADDL  g, c                      \ // d = d + h + S1 + CH + k + w
+	ANDL  b, R15                    \ // y2 = a&c
+	                                \
+	\ // compute low s1
+	                                \
+	LONG  $0xd7700f66; BYTE $0xfa   \ // PSHUFD XMM2,XMM7,0xfa            /* XTMP2 = W[-2] {BBAA}                    */
+	ANDL  a, R13                    \ // y0 = (a|c)&b
+	ADDL  R14, g                    \ // h = h + S1 + CH + k + w + S0
+	LONG  $0xc1fe0f66               \ // PADDD XMM0,XMM1                  /* XTMP0 = W[-16] + W[-7] + s0             */
+	ORL   R15, R13                  \ // y0 = MAJ = (a|c)&b)|(a&c)
+	ADDL  R13, g                    \ // h = h + S1 + CH + k + w + S0 + MAJ
+	\ // ROTATE_ARGS
+	MOVL  c, R13                    \ // y0 = e
+	MOVL  g, R14                    \ // y1 = a
+	ROLL  $18, R13                  \ // y0 = e >> (25-11)
+	XORL  c, R13                    \ // y0 = e ^ (e >> (25-11))
+	ROLL  $23, R14                  \ // y1 = a >> (22-13)
+	MOVL  d, R15                    \ // y2 = f
+	XORL  g, R14                    \ // y1 = a ^ (a >> (22-13)
+	ROLL  $27, R13                  \ // y0 = (e >> (11-6)) ^ (e >> (25-6))
+	MOVOU X2, X8                    \
+	LONG  $0x720f4166; WORD $0x0ad0 \ // PSRLD XMM8,0xa                   /* XTMP4 = W[-2] >> 10 {BBAA}              */
+	XORL  e, R15                    \ // y2 = f^g
+	MOVOU X2, X3                    \
+	LONG  $0xd3730f66; BYTE $0x13   \ // PSRLQ XMM3,0x13                  /* XTMP3 = W[-2] MY_ROR 19 {xBxA}          */
+	XORL  c, R13                    \ // y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
+	ANDL  c, R15                    \ // y2 = (f^g)&e
+	LONG  $0xd2730f66; BYTE $0x11   \ // PSRLQ XMM2,0x11                  /* XTMP2 = W[-2] MY_ROR 17 {xBxA}          */
+	ROLL  $21, R14                  \ // y1 = (a >> (13-2)) ^ (a >> (22-2))
+	XORL  g, R14                    \ // y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+	XORL  e, R15                    \ // y2 = CH = ((f^g)&e)^g
+	ROLL  $26, R13                  \ // y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+	LONG  $0xd3ef0f66               \ // PXOR  XMM2,XMM3                  /*                                         */
+	ADDL  R13, R15                  \ // y2 = S1 + CH
+	ROLL  $30, R14                  \ // y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+	ADDL  _xfer+56(FP), R15         \ // y2 = k + w + S1 + CH
+	LONG  $0xef0f4466; BYTE $0xc2   \ // PXOR  XMM8,XMM2                  /* XTMP4 = s1 {xBxA}                       */
+	MOVL  g, R13                    \ // y0 = a
+	ADDL  R15, f                    \ // h = h + S1 + CH + k + w
+	MOVL  g, R15                    \ // y2 = a
+	LONG  $0x380f4566; WORD $0xc200 \ // PSHUFB XMM8,XMM10                /* XTMP4 = s1 {00BA}                       */
+	ORL   a, R13                    \ // y0 = a|c
+	ADDL  f, b                      \ // d = d + h + S1 + CH + k + w
+	ANDL  a, R15                    \ // y2 = a&c
+	LONG  $0xfe0f4166; BYTE $0xc0   \ // PADDD XMM0,XMM8                  /* XTMP0 = {..., ..., W[1], W[0]}          */
+	ANDL  h, R13                    \ // y0 = (a|c)&b
+	ADDL  R14, f                    \ // h = h + S1 + CH + k + w + S0
+	                                \
+	\ // compute high s1
+	                                \
+	LONG  $0xd0700f66; BYTE $0x50   \ // PSHUFD XMM2,XMM0,0x50            /* XTMP2 = W[-2] {DDCC}                    */
+	ORL   R15, R13                  \ // y0 = MAJ = (a|c)&b)|(a&c)
+	ADDL  R13, f                    \ // h = h + S1 + CH + k + w + S0 + MAJ
+	\ // ROTATE_ARGS
+	MOVL  b, R13                    \ // y0 = e
+	ROLL  $18, R13                  \ // y0 = e >> (25-11)
+	MOVL  f, R14                    \ // y1 = a
+	ROLL  $23, R14                  \ // y1 = a >> (22-13)
+	XORL  b, R13                    \ // y0 = e ^ (e >> (25-11))
+	MOVL  c, R15                    \ // y2 = f
+	ROLL  $27, R13                  \ // y0 = (e >> (11-6)) ^ (e >> (25-6))
+	MOVOU X2, X11                   \
+	LONG  $0x720f4166; WORD $0x0ad3 \ // PSRLD XMM11,0xa                  /* XTMP5 = W[-2] >> 10 {DDCC}              */
+	XORL  f, R14                    \ // y1 = a ^ (a >> (22-13)
+	XORL  d, R15                    \ // y2 = f^g
+	MOVOU X2, X3                    \
+	LONG  $0xd3730f66; BYTE $0x13   \ // PSRLQ XMM3,0x13                  /* XTMP3 = W[-2] MY_ROR 19 {xDxC}          */
+	XORL  b, R13                    \ // y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
+	ANDL  b, R15                    \ // y2 = (f^g)&e
+	ROLL  $21, R14                  \ // y1 = (a >> (13-2)) ^ (a >> (22-2))
+	LONG  $0xd2730f66; BYTE $0x11   \ // PSRLQ XMM2,0x11                  /* XTMP2 = W[-2] MY_ROR 17 {xDxC}          */
+	XORL  f, R14                    \ // y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+	ROLL  $26, R13                  \ // y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+	XORL  d, R15                    \ // y2 = CH = ((f^g)&e)^g
+	LONG  $0xd3ef0f66               \ // PXOR  XMM2,XMM3                  /*                                         */
+	ROLL  $30, R14                  \ // y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+	ADDL  R13, R15                  \ // y2 = S1 + CH
+	ADDL  _xfer+60(FP), R15         \ // y2 = k + w + S1 + CH
+	LONG  $0xef0f4466; BYTE $0xda   \ // PXOR  XMM11,XMM2                 /* XTMP5 = s1 {xDxC}                       */
+	MOVL  f, R13                    \ // y0 = a
+	ADDL  R15, e                    \ // h = h + S1 + CH + k + w
+	MOVL  f, R15                    \ // y2 = a
+	LONG  $0x380f4566; WORD $0xdc00 \ // PSHUFB XMM11,XMM12               /* XTMP5 = s1 {DC00}                       */
+	ORL   h, R13                    \ // y0 = a|c
+	ADDL  e, a                      \ // d = d + h + S1 + CH + k + w
+	ANDL  h, R15                    \ // y2 = a&c
+	MOVOU X11, X4                   \
+	LONG  $0xe0fe0f66               \ // PADDD XMM4,XMM0                  /* X0 = {W[3], W[2], W[1], W[0]}           */
+	ANDL  g, R13                    \ // y0 = (a|c)&b
+	ADDL  R14, e                    \ // h = h + S1 + CH + k + w + S0
+	ORL   R15, R13                  \ // y0 = MAJ = (a|c)&b)|(a&c)
+	ADDL  R13, e                    \ // h = h + S1 + CH + k + w + S0 + MAJ
+	\ // ROTATE_ARGS
+	ROTATE_XS
+
+#define DO_ROUND(a, b, c, d, e, f, g, h, offset) \
+	MOVL e, R13                \ // y0 = e
+	ROLL $18, R13              \ // y0 = e >> (25-11)
+	MOVL a, R14                \ // y1 = a
+	XORL e, R13                \ // y0 = e ^ (e >> (25-11))
+	ROLL $23, R14              \ // y1 = a >> (22-13)
+	MOVL f, R15                \ // y2 = f
+	XORL a, R14                \ // y1 = a ^ (a >> (22-13)
+	ROLL $27, R13              \ // y0 = (e >> (11-6)) ^ (e >> (25-6))
+	XORL g, R15                \ // y2 = f^g
+	XORL e, R13                \ // y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
+	ROLL $21, R14              \ // y1 = (a >> (13-2)) ^ (a >> (22-2))
+	ANDL e, R15                \ // y2 = (f^g)&e
+	XORL a, R14                \ // y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+	ROLL $26, R13              \ // y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+	XORL g, R15                \ // y2 = CH = ((f^g)&e)^g
+	ADDL R13, R15              \ // y2 = S1 + CH
+	ROLL $30, R14              \ // y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+	ADDL _xfer+offset(FP), R15 \ // y2 = k + w + S1 + CH
+	MOVL a, R13                \ // y0 = a
+	ADDL R15, h                \ // h = h + S1 + CH + k + w
+	MOVL a, R15                \ // y2 = a
+	ORL  c, R13                \ // y0 = a|c
+	ADDL h, d                  \ // d = d + h + S1 + CH + k + w
+	ANDL c, R15                \ // y2 = a&c
+	ANDL b, R13                \ // y0 = (a|c)&b
+	ADDL R14, h                \ // h = h + S1 + CH + k + w + S0
+	ORL  R15, R13              \ // y0 = MAJ = (a|c)&b)|(a&c)
+	ADDL R13, h                // h = h + S1 + CH + k + w + S0 + MAJ
+
+// func blockSsse(h []uint32, message []uint8, reserved0, reserved1, reserved2, reserved3 uint64)
+TEXT ·blockSsse(SB), 7, $0-80
+
+	MOVQ h+0(FP), SI             // SI: &h
+	MOVQ message_base+24(FP), R8 // &message
+	MOVQ message_len+32(FP), R9  // length of message
+	CMPQ R9, $0
+	JEQ  done_hash
+	ADDQ R8, R9
+	MOVQ R9, reserved2+64(FP)    // store end of message
+
+	// Register definition
+	//  a -->  eax
+	//  b -->  ebx
+	//  c -->  ecx
+	//  d -->  r8d
+	//  e -->  edx
+	//  f -->  r9d
+	//  g --> r10d
+	//  h --> r11d
+	//
+	// y0 --> r13d
+	// y1 --> r14d
+	// y2 --> r15d
+
+	MOVL (0*4)(SI), AX  // a = H0
+	MOVL (1*4)(SI), BX  // b = H1
+	MOVL (2*4)(SI), CX  // c = H2
+	MOVL (3*4)(SI), R8  // d = H3
+	MOVL (4*4)(SI), DX  // e = H4
+	MOVL (5*4)(SI), R9  // f = H5
+	MOVL (6*4)(SI), R10 // g = H6
+	MOVL (7*4)(SI), R11 // h = H7
+
+	MOVOU bflipMask<>(SB), X13
+	MOVOU shuf00BA<>(SB), X10  // shuffle xBxA -> 00BA
+	MOVOU shufDC00<>(SB), X12  // shuffle xDxC -> DC00
+
+	MOVQ message_base+24(FP), SI // SI: &message
+
+loop0:
+	LEAQ constants<>(SB), BP
+
+	// byte swap first 16 dwords
+	MOVOU 0*16(SI), X4
+	LONG  $0x380f4166; WORD $0xe500 // PSHUFB XMM4, XMM13
+	MOVOU 1*16(SI), X5
+	LONG  $0x380f4166; WORD $0xed00 // PSHUFB XMM5, XMM13
+	MOVOU 2*16(SI), X6
+	LONG  $0x380f4166; WORD $0xf500 // PSHUFB XMM6, XMM13
+	MOVOU 3*16(SI), X7
+	LONG  $0x380f4166; WORD $0xfd00 // PSHUFB XMM7, XMM13
+
+	MOVQ SI, reserved3+72(FP)
+	MOVD $0x3, DI
+
+	// Align
+	//  nop    WORD PTR [rax+rax*1+0x0]
+
+	// schedule 48 input dwords, by doing 3 rounds of 16 each
+loop1:
+	MOVOU X4, X9
+	LONG  $0xfe0f4466; WORD $0x004d // PADDD XMM9, 0[RBP]   /* Add 1st constant to first part of message */
+	MOVOU X9, reserved0+48(FP)
+	FOUR_ROUNDS_AND_SCHED(AX, BX,  CX,  R8, DX, R9, R10, R11)
+
+	MOVOU X4, X9
+	LONG  $0xfe0f4466; WORD $0x104d // PADDD XMM9, 16[RBP]   /* Add 2nd constant to message */
+	MOVOU X9, reserved0+48(FP)
+	FOUR_ROUNDS_AND_SCHED(DX, R9, R10, R11, AX, BX,  CX,  R8)
+
+	MOVOU X4, X9
+	LONG  $0xfe0f4466; WORD $0x204d // PADDD XMM9, 32[RBP]   /* Add 3rd constant to message */
+	MOVOU X9, reserved0+48(FP)
+	FOUR_ROUNDS_AND_SCHED(AX, BX,  CX,  R8, DX, R9, R10, R11)
+
+	MOVOU X4, X9
+	LONG  $0xfe0f4466; WORD $0x304d // PADDD XMM9, 48[RBP]   /* Add 4th constant to message */
+	MOVOU X9, reserved0+48(FP)
+	ADDQ  $64, BP
+	FOUR_ROUNDS_AND_SCHED(DX, R9, R10, R11, AX, BX,  CX,  R8)
+
+	SUBQ $1, DI
+	JNE  loop1
+
+	MOVD $0x2, DI
+
+loop2:
+	MOVOU X4, X9
+	LONG  $0xfe0f4466; WORD $0x004d // PADDD XMM9, 0[RBP]   /* Add 1st constant to first part of message */
+	MOVOU X9, reserved0+48(FP)
+	DO_ROUND( AX,  BX,  CX,  R8,  DX,  R9, R10, R11, 48)
+	DO_ROUND(R11,  AX,  BX,  CX,  R8,  DX,  R9, R10, 52)
+	DO_ROUND(R10, R11,  AX,  BX,  CX,  R8,  DX,  R9, 56)
+	DO_ROUND( R9, R10, R11,  AX,  BX,  CX,  R8,  DX, 60)
+
+	MOVOU X5, X9
+	LONG  $0xfe0f4466; WORD $0x104d // PADDD XMM9, 16[RBP]   /* Add 2nd constant to message */
+	MOVOU X9, reserved0+48(FP)
+	ADDQ  $32, BP
+	DO_ROUND( DX,  R9, R10, R11,  AX,  BX,  CX,  R8, 48)
+	DO_ROUND( R8,  DX,  R9, R10, R11,  AX,  BX,  CX, 52)
+	DO_ROUND( CX,  R8,  DX,  R9, R10, R11,  AX,  BX, 56)
+	DO_ROUND( BX,  CX,  R8,  DX,  R9, R10, R11,  AX, 60)
+
+	MOVOU X6, X4
+	MOVOU X7, X5
+
+	SUBQ $1, DI
+	JNE  loop2
+
+	MOVQ h+0(FP), SI    // SI: &h
+	ADDL (0*4)(SI), AX  // H0 = a + H0
+	MOVL AX, (0*4)(SI)
+	ADDL (1*4)(SI), BX  // H1 = b + H1
+	MOVL BX, (1*4)(SI)
+	ADDL (2*4)(SI), CX  // H2 = c + H2
+	MOVL CX, (2*4)(SI)
+	ADDL (3*4)(SI), R8  // H3 = d + H3
+	MOVL R8, (3*4)(SI)
+	ADDL (4*4)(SI), DX  // H4 = e + H4
+	MOVL DX, (4*4)(SI)
+	ADDL (5*4)(SI), R9  // H5 = f + H5
+	MOVL R9, (5*4)(SI)
+	ADDL (6*4)(SI), R10 // H6 = g + H6
+	MOVL R10, (6*4)(SI)
+	ADDL (7*4)(SI), R11 // H7 = h + H7
+	MOVL R11, (7*4)(SI)
+
+	MOVQ reserved3+72(FP), SI
+	ADDQ $64, SI
+	CMPQ reserved2+64(FP), SI
+	JNE  loop0
+
+done_hash:
+	RET
+
+// Constants table
+DATA constants<>+0x0(SB)/8, $0x71374491428a2f98
+DATA constants<>+0x8(SB)/8, $0xe9b5dba5b5c0fbcf
+DATA constants<>+0x10(SB)/8, $0x59f111f13956c25b
+DATA constants<>+0x18(SB)/8, $0xab1c5ed5923f82a4
+DATA constants<>+0x20(SB)/8, $0x12835b01d807aa98
+DATA constants<>+0x28(SB)/8, $0x550c7dc3243185be
+DATA constants<>+0x30(SB)/8, $0x80deb1fe72be5d74
+DATA constants<>+0x38(SB)/8, $0xc19bf1749bdc06a7
+DATA constants<>+0x40(SB)/8, $0xefbe4786e49b69c1
+DATA constants<>+0x48(SB)/8, $0x240ca1cc0fc19dc6
+DATA constants<>+0x50(SB)/8, $0x4a7484aa2de92c6f
+DATA constants<>+0x58(SB)/8, $0x76f988da5cb0a9dc
+DATA constants<>+0x60(SB)/8, $0xa831c66d983e5152
+DATA constants<>+0x68(SB)/8, $0xbf597fc7b00327c8
+DATA constants<>+0x70(SB)/8, $0xd5a79147c6e00bf3
+DATA constants<>+0x78(SB)/8, $0x1429296706ca6351
+DATA constants<>+0x80(SB)/8, $0x2e1b213827b70a85
+DATA constants<>+0x88(SB)/8, $0x53380d134d2c6dfc
+DATA constants<>+0x90(SB)/8, $0x766a0abb650a7354
+DATA constants<>+0x98(SB)/8, $0x92722c8581c2c92e
+DATA constants<>+0xa0(SB)/8, $0xa81a664ba2bfe8a1
+DATA constants<>+0xa8(SB)/8, $0xc76c51a3c24b8b70
+DATA constants<>+0xb0(SB)/8, $0xd6990624d192e819
+DATA constants<>+0xb8(SB)/8, $0x106aa070f40e3585
+DATA constants<>+0xc0(SB)/8, $0x1e376c0819a4c116
+DATA constants<>+0xc8(SB)/8, $0x34b0bcb52748774c
+DATA constants<>+0xd0(SB)/8, $0x4ed8aa4a391c0cb3
+DATA constants<>+0xd8(SB)/8, $0x682e6ff35b9cca4f
+DATA constants<>+0xe0(SB)/8, $0x78a5636f748f82ee
+DATA constants<>+0xe8(SB)/8, $0x8cc7020884c87814
+DATA constants<>+0xf0(SB)/8, $0xa4506ceb90befffa
+DATA constants<>+0xf8(SB)/8, $0xc67178f2bef9a3f7
+
+DATA bflipMask<>+0x00(SB)/8, $0x0405060700010203
+DATA bflipMask<>+0x08(SB)/8, $0x0c0d0e0f08090a0b
+
+DATA shuf00BA<>+0x00(SB)/8, $0x0b0a090803020100
+DATA shuf00BA<>+0x08(SB)/8, $0xFFFFFFFFFFFFFFFF
+
+DATA shufDC00<>+0x00(SB)/8, $0xFFFFFFFFFFFFFFFF
+DATA shufDC00<>+0x08(SB)/8, $0x0b0a090803020100
+
+GLOBL constants<>(SB), 8, $256
+GLOBL bflipMask<>(SB), (NOPTR+RODATA), $16
+GLOBL shuf00BA<>(SB), (NOPTR+RODATA), $16
+GLOBL shufDC00<>(SB), (NOPTR+RODATA), $16

vendor/github.com/minio/sha256-simd/sha256block_386.go

@@ -0,0 +1,25 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sha256
+
+func blockArmGo(dig *digest, p []byte)  {}
+func blockAvx2Go(dig *digest, p []byte) {}
+func blockAvxGo(dig *digest, p []byte)  {}
+func blockSsseGo(dig *digest, p []byte) {}
+func blockShaGo(dig *digest, p []byte)  {}

vendor/github.com/minio/sha256-simd/sha256block_amd64.go

@@ -0,0 +1,53 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sha256
+
+func blockArmGo(dig *digest, p []byte) {}
+
+func blockAvxGo(dig *digest, p []byte) {
+
+	h := []uint32{dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]}
+
+	blockAvx(h[:], p[:], 0, 0, 0, 0)
+
+	dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]
+}
+
+func blockAvx2Go(dig *digest, p []byte) {
+
+	h := []uint32{dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]}
+
+	blockAvx2(h[:], p[:])
+
+	dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]
+}
+
+func blockSsseGo(dig *digest, p []byte) {
+
+	h := []uint32{dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]}
+
+	blockSsse(h[:], p[:], 0, 0, 0, 0)
+
+	dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]
+}
+
+func blockShaGo(dig *digest, p []byte) {
+
+	blockSha(&dig.h, p)
+}

vendor/github.com/minio/sha256-simd/sha256block_arm.go

@@ -0,0 +1,25 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sha256
+
+func blockAvx2Go(dig *digest, p []byte) {}
+func blockAvxGo(dig *digest, p []byte)  {}
+func blockSsseGo(dig *digest, p []byte) {}
+func blockShaGo(dig *digest, p []byte)  {}
+func blockArmGo(dig *digest, p []byte)  {}

vendor/github.com/minio/sha256-simd/sha256block_arm64.go

@@ -0,0 +1,37 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sha256
+
+func blockAvx2Go(dig *digest, p []byte) {}
+func blockAvxGo(dig *digest, p []byte)  {}
+func blockSsseGo(dig *digest, p []byte) {}
+func blockShaGo(dig *digest, p []byte)  {}
+
+//go:noescape
+func blockArm(h []uint32, message []uint8)
+
+func blockArmGo(dig *digest, p []byte) {
+
+	h := []uint32{dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]}
+
+	blockArm(h[:], p[:])
+
+	dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h[0], h[1], h[2], h[3], h[4],
+		h[5], h[6], h[7]
+}

vendor/github.com/minio/sha256-simd/sha256block_arm64.s

@@ -0,0 +1,192 @@
+//+build !noasm !appengine
+
+// ARM64 version of SHA256
+
+//
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+//
+// Based on implementation as found in https://github.com/jocover/sha256-armv8
+//
+// Use github.com/minio/asm2plan9s on this file to assemble ARM instructions to
+// their Plan9 equivalents
+//
+
+TEXT ·blockArm(SB), 7, $0
+	MOVD h+0(FP), R0
+	MOVD message+24(FP), R1
+	MOVD lenmessage+32(FP), R2 // length of message
+	SUBS $64, R2
+	BMI  complete
+
+	// Load constants table pointer
+	MOVD $·constants(SB), R3
+
+	// Cache constants table in registers v16 - v31
+	WORD $0x4cdf2870 // ld1	{v16.4s-v19.4s}, [x3], #64
+	WORD $0x4cdf7800 // ld1	{v0.4s}, [x0], #16
+	WORD $0x4cdf2874 // ld1	{v20.4s-v23.4s}, [x3], #64
+
+	WORD $0x4c407801 // ld1	{v1.4s}, [x0]
+	WORD $0x4cdf2878 // ld1	{v24.4s-v27.4s}, [x3], #64
+	WORD $0xd1004000 // sub	x0, x0, #0x10
+	WORD $0x4cdf287c // ld1	{v28.4s-v31.4s}, [x3], #64
+
+loop:
+	// Main loop
+	WORD $0x4cdf2025 // ld1	{v5.16b-v8.16b}, [x1], #64
+	WORD $0x4ea01c02 // mov	v2.16b, v0.16b
+	WORD $0x4ea11c23 // mov	v3.16b, v1.16b
+	WORD $0x6e2008a5 // rev32	v5.16b, v5.16b
+	WORD $0x6e2008c6 // rev32	v6.16b, v6.16b
+	WORD $0x4eb084a9 // add	v9.4s, v5.4s, v16.4s
+	WORD $0x6e2008e7 // rev32	v7.16b, v7.16b
+	WORD $0x4eb184ca // add	v10.4s, v6.4s, v17.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e094062 // sha256h	q2, q3, v9.4s
+	WORD $0x5e095083 // sha256h2	q3, q4, v9.4s
+	WORD $0x5e2828c5 // sha256su0	v5.4s, v6.4s
+	WORD $0x6e200908 // rev32	v8.16b, v8.16b
+	WORD $0x4eb284e9 // add	v9.4s, v7.4s, v18.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e0a4062 // sha256h	q2, q3, v10.4s
+	WORD $0x5e0a5083 // sha256h2	q3, q4, v10.4s
+	WORD $0x5e2828e6 // sha256su0	v6.4s, v7.4s
+	WORD $0x5e0860e5 // sha256su1	v5.4s, v7.4s, v8.4s
+	WORD $0x4eb3850a // add	v10.4s, v8.4s, v19.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e094062 // sha256h	q2, q3, v9.4s
+	WORD $0x5e095083 // sha256h2	q3, q4, v9.4s
+	WORD $0x5e282907 // sha256su0	v7.4s, v8.4s
+	WORD $0x5e056106 // sha256su1	v6.4s, v8.4s, v5.4s
+	WORD $0x4eb484a9 // add	v9.4s, v5.4s, v20.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e0a4062 // sha256h	q2, q3, v10.4s
+	WORD $0x5e0a5083 // sha256h2	q3, q4, v10.4s
+	WORD $0x5e2828a8 // sha256su0	v8.4s, v5.4s
+	WORD $0x5e0660a7 // sha256su1	v7.4s, v5.4s, v6.4s
+	WORD $0x4eb584ca // add	v10.4s, v6.4s, v21.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e094062 // sha256h	q2, q3, v9.4s
+	WORD $0x5e095083 // sha256h2	q3, q4, v9.4s
+	WORD $0x5e2828c5 // sha256su0	v5.4s, v6.4s
+	WORD $0x5e0760c8 // sha256su1	v8.4s, v6.4s, v7.4s
+	WORD $0x4eb684e9 // add	v9.4s, v7.4s, v22.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e0a4062 // sha256h	q2, q3, v10.4s
+	WORD $0x5e0a5083 // sha256h2	q3, q4, v10.4s
+	WORD $0x5e2828e6 // sha256su0	v6.4s, v7.4s
+	WORD $0x5e0860e5 // sha256su1	v5.4s, v7.4s, v8.4s
+	WORD $0x4eb7850a // add	v10.4s, v8.4s, v23.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e094062 // sha256h	q2, q3, v9.4s
+	WORD $0x5e095083 // sha256h2	q3, q4, v9.4s
+	WORD $0x5e282907 // sha256su0	v7.4s, v8.4s
+	WORD $0x5e056106 // sha256su1	v6.4s, v8.4s, v5.4s
+	WORD $0x4eb884a9 // add	v9.4s, v5.4s, v24.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e0a4062 // sha256h	q2, q3, v10.4s
+	WORD $0x5e0a5083 // sha256h2	q3, q4, v10.4s
+	WORD $0x5e2828a8 // sha256su0	v8.4s, v5.4s
+	WORD $0x5e0660a7 // sha256su1	v7.4s, v5.4s, v6.4s
+	WORD $0x4eb984ca // add	v10.4s, v6.4s, v25.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e094062 // sha256h	q2, q3, v9.4s
+	WORD $0x5e095083 // sha256h2	q3, q4, v9.4s
+	WORD $0x5e2828c5 // sha256su0	v5.4s, v6.4s
+	WORD $0x5e0760c8 // sha256su1	v8.4s, v6.4s, v7.4s
+	WORD $0x4eba84e9 // add	v9.4s, v7.4s, v26.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e0a4062 // sha256h	q2, q3, v10.4s
+	WORD $0x5e0a5083 // sha256h2	q3, q4, v10.4s
+	WORD $0x5e2828e6 // sha256su0	v6.4s, v7.4s
+	WORD $0x5e0860e5 // sha256su1	v5.4s, v7.4s, v8.4s
+	WORD $0x4ebb850a // add	v10.4s, v8.4s, v27.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e094062 // sha256h	q2, q3, v9.4s
+	WORD $0x5e095083 // sha256h2	q3, q4, v9.4s
+	WORD $0x5e282907 // sha256su0	v7.4s, v8.4s
+	WORD $0x5e056106 // sha256su1	v6.4s, v8.4s, v5.4s
+	WORD $0x4ebc84a9 // add	v9.4s, v5.4s, v28.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e0a4062 // sha256h	q2, q3, v10.4s
+	WORD $0x5e0a5083 // sha256h2	q3, q4, v10.4s
+	WORD $0x5e2828a8 // sha256su0	v8.4s, v5.4s
+	WORD $0x5e0660a7 // sha256su1	v7.4s, v5.4s, v6.4s
+	WORD $0x4ebd84ca // add	v10.4s, v6.4s, v29.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e094062 // sha256h	q2, q3, v9.4s
+	WORD $0x5e095083 // sha256h2	q3, q4, v9.4s
+	WORD $0x5e0760c8 // sha256su1	v8.4s, v6.4s, v7.4s
+	WORD $0x4ebe84e9 // add	v9.4s, v7.4s, v30.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e0a4062 // sha256h	q2, q3, v10.4s
+	WORD $0x5e0a5083 // sha256h2	q3, q4, v10.4s
+	WORD $0x4ebf850a // add	v10.4s, v8.4s, v31.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e094062 // sha256h	q2, q3, v9.4s
+	WORD $0x5e095083 // sha256h2	q3, q4, v9.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e0a4062 // sha256h	q2, q3, v10.4s
+	WORD $0x5e0a5083 // sha256h2	q3, q4, v10.4s
+	WORD $0x4ea38421 // add	v1.4s, v1.4s, v3.4s
+	WORD $0x4ea28400 // add	v0.4s, v0.4s, v2.4s
+
+	SUBS $64, R2
+	BPL  loop
+
+	// Store result
+	WORD $0x4c00a800 // st1	{v0.4s, v1.4s}, [x0]
+
+complete:
+	RET
+
+// Constants table
+DATA ·constants+0x0(SB)/8, $0x71374491428a2f98
+DATA ·constants+0x8(SB)/8, $0xe9b5dba5b5c0fbcf
+DATA ·constants+0x10(SB)/8, $0x59f111f13956c25b
+DATA ·constants+0x18(SB)/8, $0xab1c5ed5923f82a4
+DATA ·constants+0x20(SB)/8, $0x12835b01d807aa98
+DATA ·constants+0x28(SB)/8, $0x550c7dc3243185be
+DATA ·constants+0x30(SB)/8, $0x80deb1fe72be5d74
+DATA ·constants+0x38(SB)/8, $0xc19bf1749bdc06a7
+DATA ·constants+0x40(SB)/8, $0xefbe4786e49b69c1
+DATA ·constants+0x48(SB)/8, $0x240ca1cc0fc19dc6
+DATA ·constants+0x50(SB)/8, $0x4a7484aa2de92c6f
+DATA ·constants+0x58(SB)/8, $0x76f988da5cb0a9dc
+DATA ·constants+0x60(SB)/8, $0xa831c66d983e5152
+DATA ·constants+0x68(SB)/8, $0xbf597fc7b00327c8
+DATA ·constants+0x70(SB)/8, $0xd5a79147c6e00bf3
+DATA ·constants+0x78(SB)/8, $0x1429296706ca6351
+DATA ·constants+0x80(SB)/8, $0x2e1b213827b70a85
+DATA ·constants+0x88(SB)/8, $0x53380d134d2c6dfc
+DATA ·constants+0x90(SB)/8, $0x766a0abb650a7354
+DATA ·constants+0x98(SB)/8, $0x92722c8581c2c92e
+DATA ·constants+0xa0(SB)/8, $0xa81a664ba2bfe8a1
+DATA ·constants+0xa8(SB)/8, $0xc76c51a3c24b8b70
+DATA ·constants+0xb0(SB)/8, $0xd6990624d192e819
+DATA ·constants+0xb8(SB)/8, $0x106aa070f40e3585
+DATA ·constants+0xc0(SB)/8, $0x1e376c0819a4c116
+DATA ·constants+0xc8(SB)/8, $0x34b0bcb52748774c
+DATA ·constants+0xd0(SB)/8, $0x4ed8aa4a391c0cb3
+DATA ·constants+0xd8(SB)/8, $0x682e6ff35b9cca4f
+DATA ·constants+0xe0(SB)/8, $0x78a5636f748f82ee
+DATA ·constants+0xe8(SB)/8, $0x8cc7020884c87814
+DATA ·constants+0xf0(SB)/8, $0xa4506ceb90befffa
+DATA ·constants+0xf8(SB)/8, $0xc67178f2bef9a3f7
+
+GLOBL ·constants(SB), 8, $256
+

vendor/github.com/minio/sha256-simd/sha256block_noasm.go

@@ -0,0 +1,136 @@
+//+build !arm64 !amd64 noasm appengine
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sha256
+
+func blockGeneric(dig *digest, p []byte) {
+	var w [64]uint32
+	h0, h1, h2, h3, h4, h5, h6, h7 := dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]
+	for len(p) >= chunk {
+		// Can interlace the computation of w with the
+		// rounds below if needed for speed.
+		for i := 0; i < 16; i++ {
+			j := i * 4
+			w[i] = uint32(p[j])<<24 | uint32(p[j+1])<<16 | uint32(p[j+2])<<8 | uint32(p[j+3])
+		}
+		for i := 16; i < 64; i++ {
+			v1 := w[i-2]
+			t1 := (v1>>17 | v1<<(32-17)) ^ (v1>>19 | v1<<(32-19)) ^ (v1 >> 10)
+			v2 := w[i-15]
+			t2 := (v2>>7 | v2<<(32-7)) ^ (v2>>18 | v2<<(32-18)) ^ (v2 >> 3)
+			w[i] = t1 + w[i-7] + t2 + w[i-16]
+		}
+
+		a, b, c, d, e, f, g, h := h0, h1, h2, h3, h4, h5, h6, h7
+
+		for i := 0; i < 64; i++ {
+			t1 := h + ((e>>6 | e<<(32-6)) ^ (e>>11 | e<<(32-11)) ^ (e>>25 | e<<(32-25))) + ((e & f) ^ (^e & g)) + _K[i] + w[i]
+
+			t2 := ((a>>2 | a<<(32-2)) ^ (a>>13 | a<<(32-13)) ^ (a>>22 | a<<(32-22))) + ((a & b) ^ (a & c) ^ (b & c))
+
+			h = g
+			g = f
+			f = e
+			e = d + t1
+			d = c
+			c = b
+			b = a
+			a = t1 + t2
+		}
+
+		h0 += a
+		h1 += b
+		h2 += c
+		h3 += d
+		h4 += e
+		h5 += f
+		h6 += g
+		h7 += h
+
+		p = p[chunk:]
+	}
+
+	dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h0, h1, h2, h3, h4, h5, h6, h7
+}
+
+var _K = []uint32{
+	0x428a2f98,
+	0x71374491,
+	0xb5c0fbcf,
+	0xe9b5dba5,
+	0x3956c25b,
+	0x59f111f1,
+	0x923f82a4,
+	0xab1c5ed5,
+	0xd807aa98,
+	0x12835b01,
+	0x243185be,
+	0x550c7dc3,
+	0x72be5d74,
+	0x80deb1fe,
+	0x9bdc06a7,
+	0xc19bf174,
+	0xe49b69c1,
+	0xefbe4786,
+	0x0fc19dc6,
+	0x240ca1cc,
+	0x2de92c6f,
+	0x4a7484aa,
+	0x5cb0a9dc,
+	0x76f988da,
+	0x983e5152,
+	0xa831c66d,
+	0xb00327c8,
+	0xbf597fc7,
+	0xc6e00bf3,
+	0xd5a79147,
+	0x06ca6351,
+	0x14292967,
+	0x27b70a85,
+	0x2e1b2138,
+	0x4d2c6dfc,
+	0x53380d13,
+	0x650a7354,
+	0x766a0abb,
+	0x81c2c92e,
+	0x92722c85,
+	0xa2bfe8a1,
+	0xa81a664b,
+	0xc24b8b70,
+	0xc76c51a3,
+	0xd192e819,
+	0xd6990624,
+	0xf40e3585,
+	0x106aa070,
+	0x19a4c116,
+	0x1e376c08,
+	0x2748774c,
+	0x34b0bcb5,
+	0x391c0cb3,
+	0x4ed8aa4a,
+	0x5b9cca4f,
+	0x682e6ff3,
+	0x748f82ee,
+	0x78a5636f,
+	0x84c87814,
+	0x8cc70208,
+	0x90befffa,
+	0xa4506ceb,
+	0xbef9a3f7,
+	0xc67178f2,
+}

vendor/github.com/minio/sha256-simd/sha256block_other.go

@@ -0,0 +1,24 @@
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// +build ppc64 ppc64le mips mipsle mips64 mips64le s390x wasm
+
+package sha256
+
+func blockAvx2Go(dig *digest, p []byte) {}
+func blockAvxGo(dig *digest, p []byte)  {}
+func blockSsseGo(dig *digest, p []byte) {}
+func blockShaGo(dig *digest, p []byte)  {}
+func blockArmGo(dig *digest, p []byte)  {}

vendor/github.com/mr-tron/base58/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2017 Denis Subbotin
+Copyright (c) 2017 Nika Jones
+Copyright (c) 2017 Philip Schlump
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/mr-tron/base58/base58/DEPRECATED.md

@@ -0,0 +1,4 @@
+Files from this directory was copied to level up directory 
+==========================================================
+
+Now all development will be on top level

vendor/github.com/mr-tron/base58/base58/alphabet.go

@@ -0,0 +1,31 @@
+package base58
+
+// Alphabet is a a b58 alphabet.
+type Alphabet struct {
+	decode [128]int8
+	encode [58]byte
+}
+
+// NewAlphabet creates a new alphabet from the passed string.
+//
+// It panics if the passed string is not 58 bytes long or isn't valid ASCII.
+func NewAlphabet(s string) *Alphabet {
+	if len(s) != 58 {
+		panic("base58 alphabets must be 58 bytes long")
+	}
+	ret := new(Alphabet)
+	copy(ret.encode[:], s)
+	for i := range ret.decode {
+		ret.decode[i] = -1
+	}
+	for i, b := range ret.encode {
+		ret.decode[b] = int8(i)
+	}
+	return ret
+}
+
+// BTCAlphabet is the bitcoin base58 alphabet.
+var BTCAlphabet = NewAlphabet("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
+
+// FlickrAlphabet is the flickr base58 alphabet.
+var FlickrAlphabet = NewAlphabet("123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ")

vendor/github.com/mr-tron/base58/base58/base58.go

@@ -0,0 +1,255 @@
+package base58
+
+import (
+	"fmt"
+	"math/big"
+)
+
+var (
+	bn0  = big.NewInt(0)
+	bn58 = big.NewInt(58)
+)
+
+// Encode encodes the passed bytes into a base58 encoded string.
+func Encode(bin []byte) string {
+	return FastBase58Encoding(bin)
+}
+
+// EncodeAlphabet encodes the passed bytes into a base58 encoded string with the
+// passed alphabet.
+func EncodeAlphabet(bin []byte, alphabet *Alphabet) string {
+	return FastBase58EncodingAlphabet(bin, alphabet)
+}
+
+// FastBase58Encoding encodes the passed bytes into a base58 encoded string.
+func FastBase58Encoding(bin []byte) string {
+	return FastBase58EncodingAlphabet(bin, BTCAlphabet)
+}
+
+// FastBase58EncodingAlphabet encodes the passed bytes into a base58 encoded
+// string with the passed alphabet.
+func FastBase58EncodingAlphabet(bin []byte, alphabet *Alphabet) string {
+	zero := alphabet.encode[0]
+
+	binsz := len(bin)
+	var i, j, zcount, high int
+	var carry uint32
+
+	for zcount < binsz && bin[zcount] == 0 {
+		zcount++
+	}
+
+	size := (binsz-zcount)*138/100 + 1
+	var buf = make([]byte, size)
+
+	high = size - 1
+	for i = zcount; i < binsz; i++ {
+		j = size - 1
+		for carry = uint32(bin[i]); j > high || carry != 0; j-- {
+			carry = carry + 256*uint32(buf[j])
+			buf[j] = byte(carry % 58)
+			carry /= 58
+		}
+		high = j
+	}
+
+	for j = 0; j < size && buf[j] == 0; j++ {
+	}
+
+	var b58 = make([]byte, size-j+zcount)
+
+	if zcount != 0 {
+		for i = 0; i < zcount; i++ {
+			b58[i] = zero
+		}
+	}
+
+	for i = zcount; j < size; i++ {
+		b58[i] = alphabet.encode[buf[j]]
+		j++
+	}
+
+	return string(b58)
+}
+
+// TrivialBase58Encoding encodes the passed bytes into a base58 encoded string
+// (inefficiently).
+func TrivialBase58Encoding(a []byte) string {
+	return TrivialBase58EncodingAlphabet(a, BTCAlphabet)
+}
+
+// TrivialBase58EncodingAlphabet encodes the passed bytes into a base58 encoded
+// string (inefficiently) with the passed alphabet.
+func TrivialBase58EncodingAlphabet(a []byte, alphabet *Alphabet) string {
+	zero := alphabet.encode[0]
+	idx := len(a)*138/100 + 1
+	buf := make([]byte, idx)
+	bn := new(big.Int).SetBytes(a)
+	var mo *big.Int
+	for bn.Cmp(bn0) != 0 {
+		bn, mo = bn.DivMod(bn, bn58, new(big.Int))
+		idx--
+		buf[idx] = alphabet.encode[mo.Int64()]
+	}
+	for i := range a {
+		if a[i] != 0 {
+			break
+		}
+		idx--
+		buf[idx] = zero
+	}
+	return string(buf[idx:])
+}
+
+// Decode decodes the base58 encoded bytes.
+func Decode(str string) ([]byte, error) {
+	return FastBase58Decoding(str)
+}
+
+// DecodeAlphabet decodes the base58 encoded bytes using the given b58 alphabet.
+func DecodeAlphabet(str string, alphabet *Alphabet) ([]byte, error) {
+	return FastBase58DecodingAlphabet(str, alphabet)
+}
+
+// FastBase58Decoding decodes the base58 encoded bytes.
+func FastBase58Decoding(str string) ([]byte, error) {
+	return FastBase58DecodingAlphabet(str, BTCAlphabet)
+}
+
+// FastBase58DecodingAlphabet decodes the base58 encoded bytes using the given
+// b58 alphabet.
+func FastBase58DecodingAlphabet(str string, alphabet *Alphabet) ([]byte, error) {
+	if len(str) == 0 {
+		return nil, fmt.Errorf("zero length string")
+	}
+
+	var (
+		t        uint64
+		zmask, c uint32
+		zcount   int
+
+		b58u  = []rune(str)
+		b58sz = len(b58u)
+
+		outisz    = (b58sz + 3) / 4 // check to see if we need to change this buffer size to optimize
+		binu      = make([]byte, (b58sz+3)*3)
+		bytesleft = b58sz % 4
+
+		zero = rune(alphabet.encode[0])
+	)
+
+	if bytesleft > 0 {
+		zmask = (0xffffffff << uint32(bytesleft*8))
+	} else {
+		bytesleft = 4
+	}
+
+	var outi = make([]uint32, outisz)
+
+	for i := 0; i < b58sz && b58u[i] == zero; i++ {
+		zcount++
+	}
+
+	for _, r := range b58u {
+		if r > 127 {
+			return nil, fmt.Errorf("High-bit set on invalid digit")
+		}
+		if alphabet.decode[r] == -1 {
+			return nil, fmt.Errorf("Invalid base58 digit (%q)", r)
+		}
+
+		c = uint32(alphabet.decode[r])
+
+		for j := (outisz - 1); j >= 0; j-- {
+			t = uint64(outi[j])*58 + uint64(c)
+			c = uint32(t>>32) & 0x3f
+			outi[j] = uint32(t & 0xffffffff)
+		}
+
+		if c > 0 {
+			return nil, fmt.Errorf("Output number too big (carry to the next int32)")
+		}
+
+		if outi[0]&zmask != 0 {
+			return nil, fmt.Errorf("Output number too big (last int32 filled too far)")
+		}
+	}
+
+	// the nested for-loop below is the same as the original code:
+	// switch (bytesleft) {
+	// 	case 3:
+	// 		*(binu++) = (outi[0] & 0xff0000) >> 16;
+	// 		//-fallthrough
+	// 	case 2:
+	// 		*(binu++) = (outi[0] & 0xff00) >>  8;
+	// 		//-fallthrough
+	// 	case 1:
+	// 		*(binu++) = (outi[0] & 0xff);
+	// 		++j;
+	// 		//-fallthrough
+	// 	default:
+	// 		break;
+	// }
+	//
+	// for (; j < outisz; ++j)
+	// {
+	// 	*(binu++) = (outi[j] >> 0x18) & 0xff;
+	// 	*(binu++) = (outi[j] >> 0x10) & 0xff;
+	// 	*(binu++) = (outi[j] >>    8) & 0xff;
+	// 	*(binu++) = (outi[j] >>    0) & 0xff;
+	// }
+	var j, cnt int
+	for j, cnt = 0, 0; j < outisz; j++ {
+		for mask := byte(bytesleft-1) * 8; mask <= 0x18; mask, cnt = mask-8, cnt+1 {
+			binu[cnt] = byte(outi[j] >> mask)
+		}
+		if j == 0 {
+			bytesleft = 4 // because it could be less than 4 the first time through
+		}
+	}
+
+	for n, v := range binu {
+		if v > 0 {
+			start := n - zcount
+			if start < 0 {
+				start = 0
+			}
+			return binu[start:cnt], nil
+		}
+	}
+	return binu[:cnt], nil
+}
+
+// TrivialBase58Decoding decodes the base58 encoded bytes (inefficiently).
+func TrivialBase58Decoding(str string) ([]byte, error) {
+	return TrivialBase58DecodingAlphabet(str, BTCAlphabet)
+}
+
+// TrivialBase58DecodingAlphabet decodes the base58 encoded bytes
+// (inefficiently) using the given b58 alphabet.
+func TrivialBase58DecodingAlphabet(str string, alphabet *Alphabet) ([]byte, error) {
+	zero := alphabet.encode[0]
+
+	var zcount int
+	for i := 0; i < len(str) && str[i] == zero; i++ {
+		zcount++
+	}
+	leading := make([]byte, zcount)
+
+	var padChar rune = -1
+	src := []byte(str)
+	j := 0
+	for ; j < len(src) && src[j] == byte(padChar); j++ {
+	}
+
+	n := new(big.Int)
+	for i := range src[j:] {
+		c := alphabet.decode[src[i]]
+		if c == -1 {
+			return nil, fmt.Errorf("illegal base58 data at input index: %d", i)
+		}
+		n.Mul(n, bn58)
+		n.Add(n, big.NewInt(int64(c)))
+	}
+	return append(leading, n.Bytes()...), nil
+}

vendor/github.com/multiformats/go-base32/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2009 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/multiformats/go-base32/base32.go

@@ -0,0 +1,505 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package base32 implements base32 encoding as specified by RFC 4648.
+package base32
+
+import (
+	"io"
+	"strconv"
+)
+
+/*
+ * Encodings
+ */
+
+// An Encoding is a radix 32 encoding/decoding scheme, defined by a
+// 32-character alphabet. The most common is the "base32" encoding
+// introduced for SASL GSSAPI and standardized in RFC 4648.
+// The alternate "base32hex" encoding is used in DNSSEC.
+type Encoding struct {
+	encode    string
+	decodeMap [256]byte
+	padChar   rune
+}
+
+// Alphabet returns the Base32 alphabet used
+func (enc *Encoding) Alphabet() string {
+	return enc.encode
+}
+
+const (
+	StdPadding rune = '='
+	NoPadding  rune = -1
+)
+
+const encodeStd = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
+const encodeHex = "0123456789ABCDEFGHIJKLMNOPQRSTUV"
+
+// NewEncoding returns a new Encoding defined by the given alphabet,
+// which must be a 32-byte string.
+func NewEncoding(encoder string) *Encoding {
+	e := new(Encoding)
+	e.padChar = StdPadding
+	e.encode = encoder
+	for i := 0; i < len(e.decodeMap); i++ {
+		e.decodeMap[i] = 0xFF
+	}
+	for i := 0; i < len(encoder); i++ {
+		e.decodeMap[encoder[i]] = byte(i)
+	}
+	return e
+}
+
+// NewEncoding returns a new case insensitive Encoding defined by the
+// given alphabet, which must be a 32-byte string.
+func NewEncodingCI(encoder string) *Encoding {
+	e := new(Encoding)
+	e.padChar = StdPadding
+	e.encode = encoder
+	for i := 0; i < len(e.decodeMap); i++ {
+		e.decodeMap[i] = 0xFF
+	}
+	for i := 0; i < len(encoder); i++ {
+		e.decodeMap[asciiToLower(encoder[i])] = byte(i)
+		e.decodeMap[asciiToUpper(encoder[i])] = byte(i)
+	}
+	return e
+}
+
+func asciiToLower(c byte) byte {
+	if c >= 'A' && c <= 'Z' {
+		return c + 32
+	}
+	return c
+}
+
+func asciiToUpper(c byte) byte {
+	if c >= 'a' && c <= 'z' {
+		return c - 32
+	}
+	return c
+}
+
+// WithPadding creates a new encoding identical to enc except
+// with a specified padding character, or NoPadding to disable padding.
+func (enc Encoding) WithPadding(padding rune) *Encoding {
+	enc.padChar = padding
+	return &enc
+}
+
+// StdEncoding is the standard base32 encoding, as defined in
+// RFC 4648.
+var StdEncoding = NewEncodingCI(encodeStd)
+
+// HexEncoding is the ``Extended Hex Alphabet'' defined in RFC 4648.
+// It is typically used in DNS.
+var HexEncoding = NewEncodingCI(encodeHex)
+
+var RawStdEncoding = NewEncodingCI(encodeStd).WithPadding(NoPadding)
+var RawHexEncoding = NewEncodingCI(encodeHex).WithPadding(NoPadding)
+
+/*
+ * Encoder
+ */
+
+// Encode encodes src using the encoding enc, writing
+// EncodedLen(len(src)) bytes to dst.
+//
+// The encoding pads the output to a multiple of 8 bytes,
+// so Encode is not appropriate for use on individual blocks
+// of a large data stream. Use NewEncoder() instead.
+func (enc *Encoding) Encode(dst, src []byte) {
+	if len(src) == 0 {
+		return
+	}
+
+	for len(src) > 0 {
+		var carry byte
+
+		// Unpack 8x 5-bit source blocks into a 5 byte
+		// destination quantum
+		switch len(src) {
+		default:
+			dst[7] = enc.encode[src[4]&0x1F]
+			carry = src[4] >> 5
+			fallthrough
+		case 4:
+			dst[6] = enc.encode[carry|(src[3]<<3)&0x1F]
+			dst[5] = enc.encode[(src[3]>>2)&0x1F]
+			carry = src[3] >> 7
+			fallthrough
+		case 3:
+			dst[4] = enc.encode[carry|(src[2]<<1)&0x1F]
+			carry = (src[2] >> 4) & 0x1F
+			fallthrough
+		case 2:
+			dst[3] = enc.encode[carry|(src[1]<<4)&0x1F]
+			dst[2] = enc.encode[(src[1]>>1)&0x1F]
+			carry = (src[1] >> 6) & 0x1F
+			fallthrough
+		case 1:
+			dst[1] = enc.encode[carry|(src[0]<<2)&0x1F]
+			dst[0] = enc.encode[src[0]>>3]
+		}
+
+		// Pad the final quantum
+		if len(src) < 5 {
+			if enc.padChar != NoPadding {
+				dst[7] = byte(enc.padChar)
+				if len(src) < 4 {
+					dst[6] = byte(enc.padChar)
+					dst[5] = byte(enc.padChar)
+					if len(src) < 3 {
+						dst[4] = byte(enc.padChar)
+						if len(src) < 2 {
+							dst[3] = byte(enc.padChar)
+							dst[2] = byte(enc.padChar)
+						}
+					}
+				}
+			}
+			break
+		}
+		src = src[5:]
+		dst = dst[8:]
+	}
+}
+
+// EncodeToString returns the base32 encoding of src.
+func (enc *Encoding) EncodeToString(src []byte) string {
+	buf := make([]byte, enc.EncodedLen(len(src)))
+	enc.Encode(buf, src)
+	return string(buf)
+}
+
+type encoder struct {
+	err  error
+	enc  *Encoding
+	w    io.Writer
+	buf  [5]byte    // buffered data waiting to be encoded
+	nbuf int        // number of bytes in buf
+	out  [1024]byte // output buffer
+}
+
+func (e *encoder) Write(p []byte) (n int, err error) {
+	if e.err != nil {
+		return 0, e.err
+	}
+
+	// Leading fringe.
+	if e.nbuf > 0 {
+		var i int
+		for i = 0; i < len(p) && e.nbuf < 5; i++ {
+			e.buf[e.nbuf] = p[i]
+			e.nbuf++
+		}
+		n += i
+		p = p[i:]
+		if e.nbuf < 5 {
+			return
+		}
+		e.enc.Encode(e.out[0:], e.buf[0:])
+		if _, e.err = e.w.Write(e.out[0:8]); e.err != nil {
+			return n, e.err
+		}
+		e.nbuf = 0
+	}
+
+	// Large interior chunks.
+	for len(p) >= 5 {
+		nn := len(e.out) / 8 * 5
+		if nn > len(p) {
+			nn = len(p)
+			nn -= nn % 5
+		}
+		e.enc.Encode(e.out[0:], p[0:nn])
+		if _, e.err = e.w.Write(e.out[0 : nn/5*8]); e.err != nil {
+			return n, e.err
+		}
+		n += nn
+		p = p[nn:]
+	}
+
+	// Trailing fringe.
+	for i := 0; i < len(p); i++ {
+		e.buf[i] = p[i]
+	}
+	e.nbuf = len(p)
+	n += len(p)
+	return
+}
+
+// Close flushes any pending output from the encoder.
+// It is an error to call Write after calling Close.
+func (e *encoder) Close() error {
+	// If there's anything left in the buffer, flush it out
+	if e.err == nil && e.nbuf > 0 {
+		e.enc.Encode(e.out[0:], e.buf[0:e.nbuf])
+		e.nbuf = 0
+		_, e.err = e.w.Write(e.out[0:8])
+	}
+	return e.err
+}
+
+// NewEncoder returns a new base32 stream encoder. Data written to
+// the returned writer will be encoded using enc and then written to w.
+// Base32 encodings operate in 5-byte blocks; when finished
+// writing, the caller must Close the returned encoder to flush any
+// partially written blocks.
+func NewEncoder(enc *Encoding, w io.Writer) io.WriteCloser {
+	return &encoder{enc: enc, w: w}
+}
+
+// EncodedLen returns the length in bytes of the base32 encoding
+// of an input buffer of length n.
+func (enc *Encoding) EncodedLen(n int) int {
+	if enc.padChar == NoPadding {
+		return (n*8 + 4) / 5 // minimum # chars at 5 bits per char
+	}
+	return (n + 4) / 5 * 8
+}
+
+/*
+ * Decoder
+ */
+
+type CorruptInputError int64
+
+func (e CorruptInputError) Error() string {
+	return "illegal base32 data at input byte " + strconv.FormatInt(int64(e), 10)
+}
+
+// decode is like Decode but returns an additional 'end' value, which
+// indicates if end-of-message padding was encountered and thus any
+// additional data is an error. This method assumes that src has been
+// stripped of all supported whitespace ('\r' and '\n').
+func (enc *Encoding) decode(dst, src []byte) (n int, end bool, err error) {
+	olen := len(src)
+	for len(src) > 0 && !end {
+		// Decode quantum using the base32 alphabet
+		var dbuf [8]byte
+		dlen := 8
+
+		for j := 0; j < 8; {
+			if len(src) == 0 {
+				if enc.padChar != NoPadding {
+					return n, false, CorruptInputError(olen - len(src) - j)
+				}
+				dlen = j
+				break
+			}
+			in := src[0]
+			src = src[1:]
+			if in == byte(enc.padChar) && j >= 2 && len(src) < 8 {
+				if enc.padChar == NoPadding {
+					return n, false, CorruptInputError(olen)
+				}
+
+				// We've reached the end and there's padding
+				if len(src)+j < 8-1 {
+					// not enough padding
+					return n, false, CorruptInputError(olen)
+				}
+				for k := 0; k < 8-1-j; k++ {
+					if len(src) > k && src[k] != byte(enc.padChar) {
+						// incorrect padding
+						return n, false, CorruptInputError(olen - len(src) + k - 1)
+					}
+				}
+				dlen, end = j, true
+				// 7, 5 and 2 are not valid padding lengths, and so 1, 3 and 6 are not
+				// valid dlen values. See RFC 4648 Section 6 "Base 32 Encoding" listing
+				// the five valid padding lengths, and Section 9 "Illustrations and
+				// Examples" for an illustration for how the 1st, 3rd and 6th base32
+				// src bytes do not yield enough information to decode a dst byte.
+				if dlen == 1 || dlen == 3 || dlen == 6 {
+					return n, false, CorruptInputError(olen - len(src) - 1)
+				}
+				break
+			}
+			dbuf[j] = enc.decodeMap[in]
+			if dbuf[j] == 0xFF {
+				return n, false, CorruptInputError(olen - len(src) - 1)
+			}
+			j++
+		}
+
+		// Pack 8x 5-bit source blocks into 5 byte destination
+		// quantum
+		switch dlen {
+		case 8:
+			dst[4] = dbuf[6]<<5 | dbuf[7]
+			fallthrough
+		case 7:
+			dst[3] = dbuf[4]<<7 | dbuf[5]<<2 | dbuf[6]>>3
+			fallthrough
+		case 5:
+			dst[2] = dbuf[3]<<4 | dbuf[4]>>1
+			fallthrough
+		case 4:
+			dst[1] = dbuf[1]<<6 | dbuf[2]<<1 | dbuf[3]>>4
+			fallthrough
+		case 2:
+			dst[0] = dbuf[0]<<3 | dbuf[1]>>2
+		}
+
+		if len(dst) > 5 {
+			dst = dst[5:]
+		}
+
+		switch dlen {
+		case 2:
+			n += 1
+		case 4:
+			n += 2
+		case 5:
+			n += 3
+		case 7:
+			n += 4
+		case 8:
+			n += 5
+		}
+	}
+	return n, end, nil
+}
+
+// Decode decodes src using the encoding enc. It writes at most
+// DecodedLen(len(src)) bytes to dst and returns the number of bytes
+// written. If src contains invalid base32 data, it will return the
+// number of bytes successfully written and CorruptInputError.
+// New line characters (\r and \n) are ignored.
+func (enc *Encoding) Decode(dst, s []byte) (n int, err error) {
+	// FIXME: if dst is the same as s use decodeInPlace
+	stripped := make([]byte, 0, len(s))
+	for _, c := range s {
+		if c != '\r' && c != '\n' {
+			stripped = append(stripped, c)
+		}
+	}
+	n, _, err = enc.decode(dst, stripped)
+	return
+}
+
+func (enc *Encoding) decodeInPlace(strb []byte) (n int, err error) {
+	off := 0
+	for _, b := range strb {
+		if b == '\n' || b == '\r' {
+			continue
+		}
+		strb[off] = b
+		off++
+	}
+	n, _, err = enc.decode(strb, strb[:off])
+	return
+}
+
+// DecodeString returns the bytes represented by the base32 string s.
+func (enc *Encoding) DecodeString(s string) ([]byte, error) {
+	strb := []byte(s)
+	n, err := enc.decodeInPlace(strb)
+	if err != nil {
+		return nil, err
+	}
+	return strb[:n], nil
+}
+
+type decoder struct {
+	err    error
+	enc    *Encoding
+	r      io.Reader
+	end    bool       // saw end of message
+	buf    [1024]byte // leftover input
+	nbuf   int
+	out    []byte // leftover decoded output
+	outbuf [1024 / 8 * 5]byte
+}
+
+func (d *decoder) Read(p []byte) (n int, err error) {
+	if d.err != nil {
+		return 0, d.err
+	}
+
+	// Use leftover decoded output from last read.
+	if len(d.out) > 0 {
+		n = copy(p, d.out)
+		d.out = d.out[n:]
+		return n, nil
+	}
+
+	// Read a chunk.
+	nn := len(p) / 5 * 8
+	if nn < 8 {
+		nn = 8
+	}
+	if nn > len(d.buf) {
+		nn = len(d.buf)
+	}
+	nn, d.err = io.ReadAtLeast(d.r, d.buf[d.nbuf:nn], 8-d.nbuf)
+	d.nbuf += nn
+	if d.nbuf < 8 {
+		return 0, d.err
+	}
+
+	// Decode chunk into p, or d.out and then p if p is too small.
+	nr := d.nbuf / 8 * 8
+	nw := d.nbuf / 8 * 5
+	if nw > len(p) {
+		nw, d.end, d.err = d.enc.decode(d.outbuf[0:], d.buf[0:nr])
+		d.out = d.outbuf[0:nw]
+		n = copy(p, d.out)
+		d.out = d.out[n:]
+	} else {
+		n, d.end, d.err = d.enc.decode(p, d.buf[0:nr])
+	}
+	d.nbuf -= nr
+	for i := 0; i < d.nbuf; i++ {
+		d.buf[i] = d.buf[i+nr]
+	}
+
+	if d.err == nil {
+		d.err = err
+	}
+	return n, d.err
+}
+
+type newlineFilteringReader struct {
+	wrapped io.Reader
+}
+
+func (r *newlineFilteringReader) Read(p []byte) (int, error) {
+	n, err := r.wrapped.Read(p)
+	for n > 0 {
+		offset := 0
+		for i, b := range p[0:n] {
+			if b != '\r' && b != '\n' {
+				if i != offset {
+					p[offset] = b
+				}
+				offset++
+			}
+		}
+		if offset > 0 {
+			return offset, err
+		}
+		// Previous buffer entirely whitespace, read again
+		n, err = r.wrapped.Read(p)
+	}
+	return n, err
+}
+
+// NewDecoder constructs a new base32 stream decoder.
+func NewDecoder(enc *Encoding, r io.Reader) io.Reader {
+	return &decoder{enc: enc, r: &newlineFilteringReader{r}}
+}
+
+// DecodedLen returns the maximum length in bytes of the decoded data
+// corresponding to n bytes of base32-encoded data.
+func (enc *Encoding) DecodedLen(n int) int {
+	if enc.padChar == NoPadding {
+		return (n*5 + 7) / 8
+	}
+
+	return n / 8 * 5
+}

vendor/github.com/multiformats/go-base32/go.mod

@@ -0,0 +1 @@
+module github.com/multiformats/go-base32

vendor/github.com/multiformats/go-base32/package.json

@@ -0,0 +1,15 @@
+{
+  "author": "Golang",
+  "bugs": {
+    "url": "https://github.com/multiformats/go-base32"
+  },
+  "gx": {
+    "dvcsimport": "github.com/multiformats/go-base32"
+  },
+  "gxVersion": "0.7.0",
+  "language": "go",
+  "license": "BSD-3",
+  "name": "base32",
+  "version": "0.0.3"
+}
+

vendor/github.com/multiformats/go-multibase/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Protocol Labs Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/github.com/multiformats/go-multibase/Makefile

@@ -0,0 +1,13 @@
+test: deps
+	go test -race -v ./...
+
+export IPFS_API ?= v04x.ipfs.io
+
+gx:
+	go get -u github.com/whyrusleeping/gx
+	go get -u github.com/whyrusleeping/gx-go
+
+deps: gx
+	gx --verbose install --global
+	gx-go rewrite
+	go get -t ./...

vendor/github.com/multiformats/go-multibase/README.md

@@ -0,0 +1,49 @@
+# go-multibase
+
+[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://ipn.io)
+[![](https://img.shields.io/badge/project-multiformats-blue.svg?style=flat-square)](https://github.com/multiformats/multiformats)
+[![](https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square)](https://webchat.freenode.net/?channels=%23ipfs)
+[![](https://img.shields.io/badge/readme%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
+[![Travis CI](https://img.shields.io/travis/multiformats/go-multibase.svg?style=flat-square&branch=master)](https://travis-ci.org/multiformats/go-multibase)
+[![codecov.io](https://img.shields.io/codecov/c/github/multiformats/go-multibase.svg?style=flat-square&branch=master)](https://codecov.io/github/multiformats/go-multibase?branch=master)
+
+> Implementation of [multibase](https://github.com/multiformats/multibase) -self identifying base encodings- in Go.
+
+
+## Install
+
+`go-multibase` is a standard Go module which can be installed with:
+
+```sh
+go get github.com/multiformats/go-multibase
+```
+
+Note that `go-multibase` is packaged with Gx, so it is recommended to use Gx to install and use it (see Usage section).
+
+## Usage
+
+This module is packaged with [Gx](https://github.com/whyrusleeping/gx). In order to use it in your own project it is recommended that you:
+
+```sh
+go get -u github.com/whyrusleeping/gx
+go get -u github.com/whyrusleeping/gx-go
+cd <your-project-repository>
+gx init
+gx import github.com/multiformats/go-multibase
+gx install --global
+gx-go --rewrite
+```
+
+Please check [Gx](https://github.com/whyrusleeping/gx) and [Gx-go](https://github.com/whyrusleeping/gx-go) documentation for more information.
+
+## Contribute
+
+Contributions welcome. Please check out [the issues](https://github.com/multiformats/go-multibase/issues).
+
+Check out our [contributing document](https://github.com/multiformats/multiformats/blob/master/contributing.md) for more information on how we work, and about contributing in general. Please be aware that all interactions related to multiformats are subject to the IPFS [Code of Conduct](https://github.com/ipfs/community/blob/master/code-of-conduct.md).
+
+Small note: If editing the README, please conform to the [standard-readme](https://github.com/RichardLitt/standard-readme) specification.
+
+## License
+
+[MIT](LICENSE) © 2016 Protocol Labs Inc.

vendor/github.com/multiformats/go-multibase/base16.go

@@ -0,0 +1,21 @@
+package multibase
+
+func hexEncodeToStringUpper(src []byte) string {
+	dst := make([]byte, len(src)*2)
+	hexEncodeUpper(dst, src)
+	return string(dst)
+}
+
+var hexTableUppers = [16]byte{
+	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+	'A', 'B', 'C', 'D', 'E', 'F',
+}
+
+func hexEncodeUpper(dst, src []byte) int {
+	for i, v := range src {
+		dst[i*2] = hexTableUppers[v>>4]
+		dst[i*2+1] = hexTableUppers[v&0x0f]
+	}
+
+	return len(src) * 2
+}

vendor/github.com/multiformats/go-multibase/base2.go

@@ -0,0 +1,52 @@
+package multibase
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// binaryEncodeToString takes an array of bytes and returns
+// multibase binary representation
+func binaryEncodeToString(src []byte) string {
+	dst := make([]byte, len(src)*8)
+	encodeBinary(dst, src)
+	return string(dst)
+}
+
+// encodeBinary takes the src and dst bytes and converts each
+// byte to their binary rep using power reduction method
+func encodeBinary(dst []byte, src []byte) {
+	for i, b := range src {
+		for j := 0; j < 8; j++ {
+			if b&(1<<uint(7-j)) == 0 {
+				dst[i*8+j] = '0'
+			} else {
+				dst[i*8+j] = '1'
+			}
+		}
+	}
+}
+
+// decodeBinaryString takes multibase binary representation
+// and returns a byte array
+func decodeBinaryString(s string) ([]byte, error) {
+	if len(s)&7 != 0 {
+		// prepend the padding
+		s = strings.Repeat("0", 8-len(s)&7) + s
+	}
+
+	data := make([]byte, len(s)>>3)
+
+	for i, dstIndex := 0, 0; i < len(s); i = i + 8 {
+		value, err := strconv.ParseInt(s[i:i+8], 2, 0)
+		if err != nil {
+			return nil, fmt.Errorf("error while conversion: %s", err)
+		}
+
+		data[dstIndex] = byte(value)
+		dstIndex++
+	}
+
+	return data, nil
+}

vendor/github.com/multiformats/go-multibase/base32.go

@@ -0,0 +1,17 @@
+package multibase
+
+import (
+	b32 "github.com/multiformats/go-base32"
+)
+
+var base32StdLowerPad = b32.NewEncodingCI("abcdefghijklmnopqrstuvwxyz234567")
+var base32StdLowerNoPad = base32StdLowerPad.WithPadding(b32.NoPadding)
+
+var base32StdUpperPad = b32.NewEncodingCI("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567")
+var base32StdUpperNoPad = base32StdUpperPad.WithPadding(b32.NoPadding)
+
+var base32HexLowerPad = b32.NewEncodingCI("0123456789abcdefghijklmnopqrstuv")
+var base32HexLowerNoPad = base32HexLowerPad.WithPadding(b32.NoPadding)
+
+var base32HexUpperPad = b32.NewEncodingCI("0123456789ABCDEFGHIJKLMNOPQRSTUV")
+var base32HexUpperNoPad = base32HexUpperPad.WithPadding(b32.NoPadding)

vendor/github.com/multiformats/go-multibase/encoder.go

@@ -0,0 +1,63 @@
+package multibase
+
+import (
+	"fmt"
+)
+
+// Encoder is a multibase encoding that is verified to be supported and
+// supports an Encode method that does not return an error
+type Encoder struct {
+	enc Encoding
+}
+
+// NewEncoder create a new Encoder from an Encoding
+func NewEncoder(base Encoding) (Encoder, error) {
+	_, ok := EncodingToStr[base]
+	if !ok {
+		return Encoder{-1}, fmt.Errorf("Unsupported multibase encoding: %d", base)
+	}
+	return Encoder{base}, nil
+}
+
+// MustNewEncoder is like NewEncoder but will panic if the encoding is
+// invalid.
+func MustNewEncoder(base Encoding) Encoder {
+	_, ok := EncodingToStr[base]
+	if !ok {
+		panic("Unsupported multibase encoding")
+	}
+	return Encoder{base}
+}
+
+// EncoderByName creates an encoder from a string, the string can
+// either be the multibase name or single character multibase prefix
+func EncoderByName(str string) (Encoder, error) {
+	var base Encoding
+	ok := true
+	if len(str) == 0 {
+		return Encoder{-1}, fmt.Errorf("Empty multibase encoding")
+	} else if len(str) == 1 {
+		base = Encoding(str[0])
+		_, ok = EncodingToStr[base]
+	} else {
+		base, ok = Encodings[str]
+	}
+	if !ok {
+		return Encoder{-1}, fmt.Errorf("Unsupported multibase encoding: %s", str)
+	}
+	return Encoder{base}, nil
+}
+
+func (p Encoder) Encoding() Encoding {
+	return p.enc
+}
+
+// Encode encodes the multibase using the given Encoder.
+func (p Encoder) Encode(data []byte) string {
+	str, err := Encode(p.enc, data)
+	if err != nil {
+		// should not happen
+		panic(err)
+	}
+	return str
+}

vendor/github.com/multiformats/go-multibase/go.mod

@@ -0,0 +1,6 @@
+module github.com/multiformats/go-multibase
+
+require (
+	github.com/mr-tron/base58 v1.1.0
+	github.com/multiformats/go-base32 v0.0.3
+)

vendor/github.com/multiformats/go-multibase/go.sum

@@ -0,0 +1,4 @@
+github.com/mr-tron/base58 v1.1.0 h1:Y51FGVJ91WBqCEabAi5OPUz38eAx8DakuAm5svLcsfQ=
+github.com/mr-tron/base58 v1.1.0/go.mod h1:xcD2VGqlgYjBdcBLw+TuYLr8afG+Hj8g2eTVqeSzSU8=
+github.com/multiformats/go-base32 v0.0.3 h1:tw5+NhuwaOjJCC5Pp82QuXbrmLzWg7uxlMFp8Nq/kkI=
+github.com/multiformats/go-base32 v0.0.3/go.mod h1:pLiuGC8y0QR3Ue4Zug5UzK9LjgbkL8NSQj0zQ5Nz/AA=

vendor/github.com/multiformats/go-multibase/multibase.go

@@ -0,0 +1,187 @@
+package multibase
+
+import (
+	"encoding/base64"
+	"encoding/hex"
+	"fmt"
+
+	b58 "github.com/mr-tron/base58/base58"
+	b32 "github.com/multiformats/go-base32"
+)
+
+// Encoding identifies the type of base-encoding that a multibase is carrying.
+type Encoding int
+
+// These are the encodings specified in the standard, not are all
+// supported yet
+const (
+	Identity          = 0x00
+	Base1             = '1'
+	Base2             = '0'
+	Base8             = '7'
+	Base10            = '9'
+	Base16            = 'f'
+	Base16Upper       = 'F'
+	Base32            = 'b'
+	Base32Upper       = 'B'
+	Base32pad         = 'c'
+	Base32padUpper    = 'C'
+	Base32hex         = 'v'
+	Base32hexUpper    = 'V'
+	Base32hexPad      = 't'
+	Base32hexPadUpper = 'T'
+	Base58Flickr      = 'Z'
+	Base58BTC         = 'z'
+	Base64            = 'm'
+	Base64url         = 'u'
+	Base64pad         = 'M'
+	Base64urlPad      = 'U'
+)
+
+// Encodings is a map of the supported encoding, unsupported encoding
+// specified in standard are left out
+var Encodings = map[string]Encoding{
+	"identity":          0x00,
+	"base2":             '0',
+	"base16":            'f',
+	"base16upper":       'F',
+	"base32":            'b',
+	"base32upper":       'B',
+	"base32pad":         'c',
+	"base32padupper":    'C',
+	"base32hex":         'v',
+	"base32hexupper":    'V',
+	"base32hexpad":      't',
+	"base32hexpadupper": 'T',
+	"base58flickr":      'Z',
+	"base58btc":         'z',
+	"base64":            'm',
+	"base64url":         'u',
+	"base64pad":         'M',
+	"base64urlpad":      'U',
+}
+
+var EncodingToStr = map[Encoding]string{
+	0x00: "identity",
+	'0':  "base2",
+	'f':  "base16",
+	'F':  "base16upper",
+	'b':  "base32",
+	'B':  "base32upper",
+	'c':  "base32pad",
+	'C':  "base32padupper",
+	'v':  "base32hex",
+	'V':  "base32hexupper",
+	't':  "base32hexpad",
+	'T':  "base32hexpadupper",
+	'Z':  "base58flickr",
+	'z':  "base58btc",
+	'm':  "base64",
+	'u':  "base64url",
+	'M':  "base64pad",
+	'U':  "base64urlpad",
+}
+
+// ErrUnsupportedEncoding is returned when the selected encoding is not known or
+// implemented.
+var ErrUnsupportedEncoding = fmt.Errorf("selected encoding not supported")
+
+// Encode encodes a given byte slice with the selected encoding and returns a
+// multibase string (<encoding><base-encoded-string>). It will return
+// an error if the selected base is not known.
+func Encode(base Encoding, data []byte) (string, error) {
+	switch base {
+	case Identity:
+		// 0x00 inside a string is OK in golang and causes no problems with the length calculation.
+		return string(Identity) + string(data), nil
+	case Base2:
+		return string(Base2) + binaryEncodeToString(data), nil
+	case Base16:
+		return string(Base16) + hex.EncodeToString(data), nil
+	case Base16Upper:
+		return string(Base16Upper) + hexEncodeToStringUpper(data), nil
+	case Base32:
+		return string(Base32) + base32StdLowerNoPad.EncodeToString(data), nil
+	case Base32Upper:
+		return string(Base32Upper) + base32StdUpperNoPad.EncodeToString(data), nil
+	case Base32hex:
+		return string(Base32hex) + base32HexLowerNoPad.EncodeToString(data), nil
+	case Base32hexUpper:
+		return string(Base32hexUpper) + base32HexUpperNoPad.EncodeToString(data), nil
+	case Base32pad:
+		return string(Base32pad) + base32StdLowerPad.EncodeToString(data), nil
+	case Base32padUpper:
+		return string(Base32padUpper) + base32StdUpperPad.EncodeToString(data), nil
+	case Base32hexPad:
+		return string(Base32hexPad) + base32HexLowerPad.EncodeToString(data), nil
+	case Base32hexPadUpper:
+		return string(Base32hexPadUpper) + base32HexUpperPad.EncodeToString(data), nil
+	case Base58BTC:
+		return string(Base58BTC) + b58.EncodeAlphabet(data, b58.BTCAlphabet), nil
+	case Base58Flickr:
+		return string(Base58Flickr) + b58.EncodeAlphabet(data, b58.FlickrAlphabet), nil
+	case Base64pad:
+		return string(Base64pad) + base64.StdEncoding.EncodeToString(data), nil
+	case Base64urlPad:
+		return string(Base64urlPad) + base64.URLEncoding.EncodeToString(data), nil
+	case Base64url:
+		return string(Base64url) + base64.RawURLEncoding.EncodeToString(data), nil
+	case Base64:
+		return string(Base64) + base64.RawStdEncoding.EncodeToString(data), nil
+	default:
+		return "", ErrUnsupportedEncoding
+	}
+}
+
+// Decode takes a multibase string and decodes into a bytes buffer.
+// It will return an error if the selected base is not known.
+func Decode(data string) (Encoding, []byte, error) {
+	if len(data) == 0 {
+		return 0, nil, fmt.Errorf("cannot decode multibase for zero length string")
+	}
+
+	enc := Encoding(data[0])
+
+	switch enc {
+	case Identity:
+		return Identity, []byte(data[1:]), nil
+	case Base2:
+		bytes, err := decodeBinaryString(data[1:])
+		return enc, bytes, err
+	case Base16, Base16Upper:
+		bytes, err := hex.DecodeString(data[1:])
+		return enc, bytes, err
+	case Base32, Base32Upper:
+		bytes, err := b32.RawStdEncoding.DecodeString(data[1:])
+		return enc, bytes, err
+	case Base32hex, Base32hexUpper:
+		bytes, err := b32.RawHexEncoding.DecodeString(data[1:])
+		return enc, bytes, err
+	case Base32pad, Base32padUpper:
+		bytes, err := b32.StdEncoding.DecodeString(data[1:])
+		return enc, bytes, err
+	case Base32hexPad, Base32hexPadUpper:
+		bytes, err := b32.HexEncoding.DecodeString(data[1:])
+		return enc, bytes, err
+	case Base58BTC:
+		bytes, err := b58.DecodeAlphabet(data[1:], b58.BTCAlphabet)
+		return Base58BTC, bytes, err
+	case Base58Flickr:
+		bytes, err := b58.DecodeAlphabet(data[1:], b58.FlickrAlphabet)
+		return Base58Flickr, bytes, err
+	case Base64pad:
+		bytes, err := base64.StdEncoding.DecodeString(data[1:])
+		return Base64pad, bytes, err
+	case Base64urlPad:
+		bytes, err := base64.URLEncoding.DecodeString(data[1:])
+		return Base64urlPad, bytes, err
+	case Base64:
+		bytes, err := base64.RawStdEncoding.DecodeString(data[1:])
+		return Base64, bytes, err
+	case Base64url:
+		bytes, err := base64.RawURLEncoding.DecodeString(data[1:])
+		return Base64url, bytes, err
+	default:
+		return -1, nil, ErrUnsupportedEncoding
+	}
+}

vendor/github.com/multiformats/go-multibase/package.json

@@ -0,0 +1,30 @@
+{
+  "author": "whyrusleeping",
+  "bugs": {
+    "url": "https://github.com/multiformats/go-multibase"
+  },
+  "gx": {
+    "dvcsimport": "github.com/multiformats/go-multibase"
+  },
+  "gxDependencies": [
+    {
+      "author": "mr-tron",
+      "hash": "QmWFAMPqsEyUX7gDUsRVmMWz59FxSpJ1b2v6bJ1yYzo7jY",
+      "name": "go-base58-fast",
+      "version": "0.1.1"
+    },
+    {
+      "author": "Golang",
+      "hash": "QmPbbYin7KBd1Y1BfUe15vHzwJiioyi3wtKQTtXWWf8SC5",
+      "name": "base32",
+      "version": "0.0.3"
+    }
+  ],
+  "gxVersion": "0.8.0",
+  "language": "go",
+  "license": "",
+  "name": "go-multibase",
+  "releaseCmd": "git commit -a -m \"gx publish $VERSION\"",
+  "version": "0.3.0"
+}
+

vendor/github.com/multiformats/go-multihash/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/github.com/multiformats/go-multihash/Makefile

@@ -0,0 +1,11 @@
+gx:
+	go get github.com/whyrusleeping/gx
+	go get github.com/whyrusleeping/gx-go
+
+deps: gx
+	gx --verbose install --global
+	gx-go rewrite
+
+publish:
+	gx-go rewrite --undo
+

vendor/github.com/multiformats/go-multihash/README.md

@@ -0,0 +1,90 @@
+# go-multihash
+
+[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://ipn.io)
+[![](https://img.shields.io/badge/project-multiformats-blue.svg?style=flat-square)](https://github.com/multiformats/multiformats)
+[![](https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square)](https://webchat.freenode.net/?channels=%23ipfs)
+[![](https://img.shields.io/badge/readme%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
+[![GoDoc](https://godoc.org/github.com/multiformats/go-multihash?status.svg)](https://godoc.org/github.com/multiformats/go-multihash)
+[![Travis CI](https://img.shields.io/travis/multiformats/go-multihash.svg?style=flat-square&branch=master)](https://travis-ci.org/multiformats/go-multihash)
+[![codecov.io](https://img.shields.io/codecov/c/github/multiformats/go-multihash.svg?style=flat-square&branch=master)](https://codecov.io/github/multiformats/go-multihash?branch=master)
+
+> [multihash](https://github.com/multiformats/multihash) implementation in Go
+
+## Table of Contents
+
+- [Install](#install)
+- [Usage](#usage)
+- [Maintainers](#maintainers)
+- [Contribute](#contribute)
+- [License](#license)
+
+## Install
+
+`go-multihash` is a standard Go module which can be installed with:
+
+```sh
+go get github.com/multiformats/go-multihash
+```
+
+## Usage
+
+
+### Example
+
+This example takes a standard hex-encoded data and uses `EncodeName` to calculate the SHA1 multihash value for the buffer.
+
+The resulting hex-encoded data corresponds to: `<hash function code><digest size><hash function output>`, which could be re-parsed
+with `Multihash.FromHexString()`.
+
+
+```go
+package main
+
+import (
+	"encoding/hex"
+	"fmt"
+
+	"github.com/multiformats/go-multihash"
+)
+
+func main() {
+	// ignores errors for simplicity.
+	// don't do that at home.
+	// Decode a SHA1 hash to a binary buffer
+	buf, _ := hex.DecodeString("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33")
+
+	// Create a new multihash with it.
+	mHashBuf, _ := multihash.EncodeName(buf, "sha1")
+	// Print the multihash as hex string
+	fmt.Printf("hex: %s\n", hex.EncodeToString(mHashBuf))
+
+	// Parse the binary multihash to a DecodedMultihash
+	mHash, _ := multihash.Decode(mHashBuf)
+	// Convert the sha1 value to hex string
+	sha1hex := hex.EncodeToString(mHash.Digest)
+	// Print all the information in the multihash
+	fmt.Printf("obj: %v 0x%x %d %s\n", mHash.Name, mHash.Code, mHash.Length, sha1hex)
+}
+```
+
+To run, copy to [example/foo.go](example/foo.go) and:
+
+```
+> cd example/
+> go build
+> ./example
+hex: 11140beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33
+obj: sha1 0x11 20 0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33
+```
+
+## Contribute
+
+Contributions welcome. Please check out [the issues](https://github.com/multiformats/go-multihash/issues).
+
+Check out our [contributing document](https://github.com/multiformats/multiformats/blob/master/contributing.md) for more information on how we work, and about contributing in general. Please be aware that all interactions related to multiformats are subject to the IPFS [Code of Conduct](https://github.com/ipfs/community/blob/master/code-of-conduct.md).
+
+Small note: If editing the README, please conform to the [standard-readme](https://github.com/RichardLitt/standard-readme) specification.
+
+## License
+
+[MIT](LICENSE) © 2014 Juan Batiz-Benet

vendor/github.com/multiformats/go-multihash/codecov.yml

@@ -0,0 +1,3 @@
+coverage:
+  range: "50...100"
+comment: off

vendor/github.com/multiformats/go-multihash/go.mod

@@ -0,0 +1,11 @@
+module github.com/multiformats/go-multihash
+
+require (
+	github.com/gxed/hashland/keccakpg v0.0.1
+	github.com/gxed/hashland/murmur3 v0.0.1
+	github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1
+	github.com/minio/sha256-simd v0.0.0-20190131020904-2d45a736cd16
+	github.com/mr-tron/base58 v1.1.0
+	golang.org/x/crypto v0.0.0-20190211182817-74369b46fc67
+	golang.org/x/sys v0.0.0-20190219092855-153ac476189d // indirect
+)

vendor/github.com/multiformats/go-multihash/go.sum

@@ -0,0 +1,14 @@
+github.com/gxed/hashland/keccakpg v0.0.1 h1:wrk3uMNaMxbXiHibbPO4S0ymqJMm41WiudyFSs7UnsU=
+github.com/gxed/hashland/keccakpg v0.0.1/go.mod h1:kRzw3HkwxFU1mpmPP8v1WyQzwdGfmKFJ6tItnhQ67kU=
+github.com/gxed/hashland/murmur3 v0.0.1 h1:SheiaIt0sda5K+8FLz952/1iWS9zrnKsEJaOJu4ZbSc=
+github.com/gxed/hashland/murmur3 v0.0.1/go.mod h1:KjXop02n4/ckmZSnY2+HKcLud/tcmvhST0bie/0lS48=
+github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1 h1:lYpkrQH5ajf0OXOcUbGjvZxxijuBwbbmlSxLiuofa+g=
+github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1/go.mod h1:pD8RvIylQ358TN4wwqatJ8rNavkEINozVn9DtGI3dfQ=
+github.com/minio/sha256-simd v0.0.0-20190131020904-2d45a736cd16 h1:5W7KhL8HVF3XCFOweFD3BNESdnO8ewyYTFT2R+/b8FQ=
+github.com/minio/sha256-simd v0.0.0-20190131020904-2d45a736cd16/go.mod h1:2FMWW+8GMoPweT6+pI63m9YE3Lmw4J71hV56Chs1E/U=
+github.com/mr-tron/base58 v1.1.0 h1:Y51FGVJ91WBqCEabAi5OPUz38eAx8DakuAm5svLcsfQ=
+github.com/mr-tron/base58 v1.1.0/go.mod h1:xcD2VGqlgYjBdcBLw+TuYLr8afG+Hj8g2eTVqeSzSU8=
+golang.org/x/crypto v0.0.0-20190211182817-74369b46fc67 h1:ng3VDlRp5/DHpSWl02R4rM9I+8M2rhmsuLwAMmkLQWE=
+golang.org/x/crypto v0.0.0-20190211182817-74369b46fc67/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/sys v0.0.0-20190219092855-153ac476189d h1:Z0Ahzd7HltpJtjAHHxX8QFP3j1yYgiuvjbjRzDj/KH0=
+golang.org/x/sys v0.0.0-20190219092855-153ac476189d/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=

vendor/github.com/multiformats/go-multihash/io.go

@@ -0,0 +1,103 @@
+package multihash
+
+import (
+	"encoding/binary"
+	"errors"
+	"io"
+	"math"
+)
+
+// Reader is an io.Reader wrapper that exposes a function
+// to read a whole multihash, parse it, and return it.
+type Reader interface {
+	io.Reader
+
+	ReadMultihash() (Multihash, error)
+}
+
+// Writer is an io.Writer wrapper that exposes a function
+// to write a whole multihash.
+type Writer interface {
+	io.Writer
+
+	WriteMultihash(Multihash) error
+}
+
+// NewReader wraps an io.Reader with a multihash.Reader
+func NewReader(r io.Reader) Reader {
+	return &mhReader{r}
+}
+
+// NewWriter wraps an io.Writer with a multihash.Writer
+func NewWriter(w io.Writer) Writer {
+	return &mhWriter{w}
+}
+
+type mhReader struct {
+	r io.Reader
+}
+
+func (r *mhReader) Read(buf []byte) (n int, err error) {
+	return r.r.Read(buf)
+}
+
+func (r *mhReader) ReadByte() (byte, error) {
+	if br, ok := r.r.(io.ByteReader); ok {
+		return br.ReadByte()
+	}
+	var b [1]byte
+	n, err := r.r.Read(b[:])
+	if n == 1 {
+		return b[0], nil
+	}
+	if err == nil {
+		if n != 0 {
+			panic("reader returned an invalid length")
+		}
+		err = io.ErrNoProgress
+	}
+	return 0, err
+}
+
+func (r *mhReader) ReadMultihash() (Multihash, error) {
+	code, err := binary.ReadUvarint(r)
+	if err != nil {
+		return nil, err
+	}
+
+	length, err := binary.ReadUvarint(r)
+	if err != nil {
+		return nil, err
+	}
+	if length > math.MaxInt32 {
+		return nil, errors.New("digest too long, supporting only <= 2^31-1")
+	}
+
+	pre := make([]byte, 2*binary.MaxVarintLen64)
+	spot := pre
+	n := binary.PutUvarint(spot, code)
+	spot = pre[n:]
+	n += binary.PutUvarint(spot, length)
+
+	buf := make([]byte, int(length)+n)
+	copy(buf, pre[:n])
+
+	if _, err := io.ReadFull(r.r, buf[n:]); err != nil {
+		return nil, err
+	}
+
+	return Cast(buf)
+}
+
+type mhWriter struct {
+	w io.Writer
+}
+
+func (w *mhWriter) Write(buf []byte) (n int, err error) {
+	return w.w.Write(buf)
+}
+
+func (w *mhWriter) WriteMultihash(m Multihash) error {
+	_, err := w.w.Write([]byte(m))
+	return err
+}

vendor/github.com/multiformats/go-multihash/multihash.go

@@ -0,0 +1,293 @@
+// Package multihash is the Go implementation of
+// https://github.com/multiformats/multihash, or self-describing
+// hashes.
+package multihash
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"math"
+
+	b58 "github.com/mr-tron/base58/base58"
+)
+
+// errors
+var (
+	ErrUnknownCode      = errors.New("unknown multihash code")
+	ErrTooShort         = errors.New("multihash too short. must be >= 2 bytes")
+	ErrTooLong          = errors.New("multihash too long. must be < 129 bytes")
+	ErrLenNotSupported  = errors.New("multihash does not yet support digests longer than 127 bytes")
+	ErrInvalidMultihash = errors.New("input isn't valid multihash")
+
+	ErrVarintBufferShort = errors.New("uvarint: buffer too small")
+	ErrVarintTooLong     = errors.New("uvarint: varint too big (max 64bit)")
+)
+
+// ErrInconsistentLen is returned when a decoded multihash has an inconsistent length
+type ErrInconsistentLen struct {
+	dm *DecodedMultihash
+}
+
+func (e ErrInconsistentLen) Error() string {
+	return fmt.Sprintf("multihash length inconsistent: %v", e.dm)
+}
+
+// constants
+const (
+	ID         = 0x00
+	SHA1       = 0x11
+	SHA2_256   = 0x12
+	SHA2_512   = 0x13
+	SHA3_224   = 0x17
+	SHA3_256   = 0x16
+	SHA3_384   = 0x15
+	SHA3_512   = 0x14
+	SHA3       = SHA3_512
+	KECCAK_224 = 0x1A
+	KECCAK_256 = 0x1B
+	KECCAK_384 = 0x1C
+	KECCAK_512 = 0x1D
+
+	SHAKE_128 = 0x18
+	SHAKE_256 = 0x19
+
+	BLAKE2B_MIN = 0xb201
+	BLAKE2B_MAX = 0xb240
+	BLAKE2S_MIN = 0xb241
+	BLAKE2S_MAX = 0xb260
+
+	DBL_SHA2_256 = 0x56
+
+	MURMUR3 = 0x22
+
+	X11 = 0x1100
+)
+
+func init() {
+	// Add blake2b (64 codes)
+	for c := uint64(BLAKE2B_MIN); c <= BLAKE2B_MAX; c++ {
+		n := c - BLAKE2B_MIN + 1
+		name := fmt.Sprintf("blake2b-%d", n*8)
+		Names[name] = c
+		Codes[c] = name
+		DefaultLengths[c] = int(n)
+	}
+
+	// Add blake2s (32 codes)
+	for c := uint64(BLAKE2S_MIN); c <= BLAKE2S_MAX; c++ {
+		n := c - BLAKE2S_MIN + 1
+		name := fmt.Sprintf("blake2s-%d", n*8)
+		Names[name] = c
+		Codes[c] = name
+		DefaultLengths[c] = int(n)
+	}
+}
+
+// Names maps the name of a hash to the code
+var Names = map[string]uint64{
+	"id":           ID,
+	"sha1":         SHA1,
+	"sha2-256":     SHA2_256,
+	"sha2-512":     SHA2_512,
+	"sha3":         SHA3_512,
+	"sha3-224":     SHA3_224,
+	"sha3-256":     SHA3_256,
+	"sha3-384":     SHA3_384,
+	"sha3-512":     SHA3_512,
+	"dbl-sha2-256": DBL_SHA2_256,
+	"murmur3":      MURMUR3,
+	"keccak-224":   KECCAK_224,
+	"keccak-256":   KECCAK_256,
+	"keccak-384":   KECCAK_384,
+	"keccak-512":   KECCAK_512,
+	"shake-128":    SHAKE_128,
+	"shake-256":    SHAKE_256,
+	"x11":          X11,
+}
+
+// Codes maps a hash code to it's name
+var Codes = map[uint64]string{
+	ID:           "id",
+	SHA1:         "sha1",
+	SHA2_256:     "sha2-256",
+	SHA2_512:     "sha2-512",
+	SHA3_224:     "sha3-224",
+	SHA3_256:     "sha3-256",
+	SHA3_384:     "sha3-384",
+	SHA3_512:     "sha3-512",
+	DBL_SHA2_256: "dbl-sha2-256",
+	MURMUR3:      "murmur3",
+	KECCAK_224:   "keccak-224",
+	KECCAK_256:   "keccak-256",
+	KECCAK_384:   "keccak-384",
+	KECCAK_512:   "keccak-512",
+	SHAKE_128:    "shake-128",
+	SHAKE_256:    "shake-256",
+	X11:          "x11",
+}
+
+// DefaultLengths maps a hash code to it's default length
+var DefaultLengths = map[uint64]int{
+	ID:           -1,
+	SHA1:         20,
+	SHA2_256:     32,
+	SHA2_512:     64,
+	SHA3_224:     28,
+	SHA3_256:     32,
+	SHA3_384:     48,
+	SHA3_512:     64,
+	DBL_SHA2_256: 32,
+	KECCAK_224:   28,
+	KECCAK_256:   32,
+	MURMUR3:      4,
+	KECCAK_384:   48,
+	KECCAK_512:   64,
+	SHAKE_128:    32,
+	SHAKE_256:    64,
+	X11:          64,
+}
+
+func uvarint(buf []byte) (uint64, []byte, error) {
+	n, c := binary.Uvarint(buf)
+
+	if c == 0 {
+		return n, buf, ErrVarintBufferShort
+	} else if c < 0 {
+		return n, buf[-c:], ErrVarintTooLong
+	} else {
+		return n, buf[c:], nil
+	}
+}
+
+// DecodedMultihash represents a parsed multihash and allows
+// easy access to the different parts of a multihash.
+type DecodedMultihash struct {
+	Code   uint64
+	Name   string
+	Length int    // Length is just int as it is type of len() opearator
+	Digest []byte // Digest holds the raw multihash bytes
+}
+
+// Multihash is byte slice with the following form:
+// <hash function code><digest size><hash function output>.
+// See the spec for more information.
+type Multihash []byte
+
+// HexString returns the hex-encoded representation of a multihash.
+func (m *Multihash) HexString() string {
+	return hex.EncodeToString([]byte(*m))
+}
+
+// String is an alias to HexString().
+func (m *Multihash) String() string {
+	return m.HexString()
+}
+
+// FromHexString parses a hex-encoded multihash.
+func FromHexString(s string) (Multihash, error) {
+	b, err := hex.DecodeString(s)
+	if err != nil {
+		return Multihash{}, err
+	}
+
+	return Cast(b)
+}
+
+// B58String returns the B58-encoded representation of a multihash.
+func (m Multihash) B58String() string {
+	return b58.Encode([]byte(m))
+}
+
+// FromB58String parses a B58-encoded multihash.
+func FromB58String(s string) (m Multihash, err error) {
+	b, err := b58.Decode(s)
+	if err != nil {
+		return Multihash{}, ErrInvalidMultihash
+	}
+
+	return Cast(b)
+}
+
+// Cast casts a buffer onto a multihash, and returns an error
+// if it does not work.
+func Cast(buf []byte) (Multihash, error) {
+	dm, err := Decode(buf)
+	if err != nil {
+		return Multihash{}, err
+	}
+
+	if !ValidCode(dm.Code) {
+		return Multihash{}, ErrUnknownCode
+	}
+
+	return Multihash(buf), nil
+}
+
+// Decode parses multihash bytes into a DecodedMultihash.
+func Decode(buf []byte) (*DecodedMultihash, error) {
+
+	if len(buf) < 2 {
+		return nil, ErrTooShort
+	}
+
+	var err error
+	var code, length uint64
+
+	code, buf, err = uvarint(buf)
+	if err != nil {
+		return nil, err
+	}
+
+	length, buf, err = uvarint(buf)
+	if err != nil {
+		return nil, err
+	}
+
+	if length > math.MaxInt32 {
+		return nil, errors.New("digest too long, supporting only <= 2^31-1")
+	}
+
+	dm := &DecodedMultihash{
+		Code:   code,
+		Name:   Codes[code],
+		Length: int(length),
+		Digest: buf,
+	}
+
+	if len(dm.Digest) != dm.Length {
+		return nil, ErrInconsistentLen{dm}
+	}
+
+	return dm, nil
+}
+
+// Encode a hash digest along with the specified function code.
+// Note: the length is derived from the length of the digest itself.
+func Encode(buf []byte, code uint64) ([]byte, error) {
+
+	if !ValidCode(code) {
+		return nil, ErrUnknownCode
+	}
+
+	start := make([]byte, 2*binary.MaxVarintLen64, 2*binary.MaxVarintLen64+len(buf))
+	spot := start
+	n := binary.PutUvarint(spot, code)
+	spot = start[n:]
+	n += binary.PutUvarint(spot, uint64(len(buf)))
+
+	return append(start[:n], buf...), nil
+}
+
+// EncodeName is like Encode() but providing a string name
+// instead of a numeric code. See Names for allowed values.
+func EncodeName(buf []byte, name string) ([]byte, error) {
+	return Encode(buf, Names[name])
+}
+
+// ValidCode checks whether a multihash code is valid.
+func ValidCode(code uint64) bool {
+	_, ok := Codes[code]
+	return ok
+}

vendor/github.com/multiformats/go-multihash/package.json

@@ -0,0 +1,54 @@
+{
+  "author": "multiformats",
+  "bugs": {
+    "url": "https://github.com/multiformats/go-multihash/issues"
+  },
+  "gx": {
+    "dvcsimport": "github.com/multiformats/go-multihash"
+  },
+  "gxDependencies": [
+    {
+      "author": "whyrusleeping",
+      "hash": "QmW7VUmSvhvSGbYbdsh7uRjhGmsYkc9fL8aJ5CorxxrU5N",
+      "name": "go-crypto",
+      "version": "0.2.1"
+    },
+    {
+      "author": "mr-tron",
+      "hash": "QmWFAMPqsEyUX7gDUsRVmMWz59FxSpJ1b2v6bJ1yYzo7jY",
+      "name": "go-base58-fast",
+      "version": "0.1.1"
+    },
+    {
+      "author": "whyrusleeping",
+      "hash": "QmZtJMfZZvoD3EKpQaf8xsFi83HMtX5acQekY8exMbcWEi",
+      "name": "keccakpg",
+      "version": "0.0.1"
+    },
+    {
+      "author": "minio",
+      "hash": "QmcTzQXRcU2vf8yX5EEboz1BSvWC7wWmeYAKVQmhp8WZYU",
+      "name": "sha256-simd",
+      "version": "0.1.2"
+    },
+    {
+      "author": "minio",
+      "hash": "QmZp3eKdYQHHAneECmeK6HhiMwTPufmjC8DuuaGKv3unvx",
+      "name": "blake2b-simd",
+      "version": "0.1.1"
+    },
+    {
+      "author": "whyrusleeping",
+      "hash": "QmWAXZgFyppTRshtnVHJ8LnA1yoHjUr41ZnsWPoA8wnSgF",
+      "name": "hashland-murmur3",
+      "version": "0.0.1"
+    }
+  ],
+  "gxVersion": "0.9.0",
+  "language": "go",
+  "license": "MIT",
+  "name": "go-multihash",
+  "releaseCmd": "git commit -a -m \"gx release $VERSION\"",
+  "version": "1.0.10"
+}
+